_ZN4absl12lts_2026052613base_internal16SchedulingHelperC2ENS1_14SchedulingModeE:
  118|     50|  explicit SchedulingHelper(base_internal::SchedulingMode mode) : mode_(mode) {
  119|     50|    if (mode_ == base_internal::SCHEDULE_KERNEL_ONLY) {
  ------------------
  |  Branch (119:9): [True: 0, False: 50]
  ------------------
  120|      0|      guard_result_ = base_internal::SchedulingGuard::DisableRescheduling();
  121|      0|    }
  122|     50|  }
_ZN4absl12lts_2026052613base_internal16SchedulingHelperD2Ev:
  124|     50|  ~SchedulingHelper() {
  125|     50|    if (mode_ == base_internal::SCHEDULE_KERNEL_ONLY) {
  ------------------
  |  Branch (125:9): [True: 0, False: 50]
  ------------------
  126|      0|      base_internal::SchedulingGuard::EnableRescheduling(guard_result_);
  127|      0|    }
  128|     50|  }
_ZN4absl12lts_2026052613base_internal11ControlWordEPNS0_9once_flagE:
  195|     76|    once_flag* absl_nonnull flag) {
  196|     76|  return &flag->control_;
  197|     76|}
_ZN4absl12lts_202605269call_onceIMNS0_14flags_internal8FlagImplEFvvEJPS3_EEEvRNS0_9once_flagEOT_DpOT0_:
  215|     74|    call_once(absl::once_flag& flag, Callable&& fn, Args&&... args) {
  216|     74|  std::atomic<uint32_t>* once = base_internal::ControlWord(&flag);
  217|     74|  uint32_t s = once->load(std::memory_order_acquire);
  218|     74|  if (ABSL_PREDICT_FALSE(s != base_internal::kOnceDone)) {
  ------------------
  |  |  190|     74|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 48, False: 26]
  |  |  |  Branch (190:49): [Folded, False: 74]
  |  |  |  Branch (190:58): [True: 48, False: 26]
  |  |  ------------------
  ------------------
  219|     48|    base_internal::CallOnceImpl(
  220|     48|        once, base_internal::SCHEDULE_COOPERATIVE_AND_KERNEL,
  221|     48|        std::forward<Callable>(fn), std::forward<Args>(args)...);
  222|     48|  }
  223|     74|}
_ZN4absl12lts_2026052613base_internal12CallOnceImplIMNS0_14flags_internal8FlagImplEFvvEJPS4_EEEvPNSt3__16atomicIjEENS1_14SchedulingModeEOT_DpOT0_:
  155|     48|                 Args&&... args) {
  156|       |#ifndef NDEBUG
  157|       |  {
  158|       |    uint32_t old_control = control->load(std::memory_order_relaxed);
  159|       |    if (old_control != kOnceInit &&
  160|       |        old_control != kOnceRunning &&
  161|       |        old_control != kOnceWaiter &&
  162|       |        old_control != kOnceDone) {
  163|       |      // Memory corruption may cause this error.
  164|       |      ABSL_RAW_LOG(FATAL, "Unexpected value for control word: 0x%lx",
  165|       |                   static_cast<unsigned long>(old_control));  // NOLINT
  166|       |    }
  167|       |  }
  168|       |#endif  // NDEBUG
  169|     48|  static const base_internal::SpinLockWaitTransition trans[] = {
  170|     48|      {kOnceInit, kOnceRunning, true},
  171|     48|      {kOnceRunning, kOnceWaiter, false},
  172|     48|      {kOnceDone, kOnceDone, true}};
  173|       |
  174|       |  // Must do this before potentially modifying control word's state.
  175|     48|  base_internal::SchedulingHelper maybe_disable_scheduling(scheduling_mode);
  176|       |  // Short circuit the simplest case to avoid procedure call overhead.
  177|       |  // The base_internal::SpinLockWait() call returns either kOnceInit or
  178|       |  // kOnceDone. If it returns kOnceDone, it must have loaded the control word
  179|       |  // with std::memory_order_acquire and seen a value of kOnceDone.
  180|     48|  uint32_t old_control = kOnceInit;
  181|     48|  if (control->compare_exchange_strong(old_control, kOnceRunning,
  ------------------
  |  Branch (181:7): [True: 48, False: 0]
  ------------------
  182|     48|                                       std::memory_order_relaxed) ||
  183|      0|      base_internal::SpinLockWait(control, ABSL_ARRAYSIZE(trans), trans,
  ------------------
  |  |   46|      0|  (sizeof(::absl::macros_internal::ArraySizeHelper(array)))
  ------------------
  |  Branch (183:7): [True: 0, False: 0]
  ------------------
  184|     48|                                  scheduling_mode) == kOnceInit) {
  185|     48|    std::invoke(std::forward<Callable>(fn), std::forward<Args>(args)...);
  186|     48|    old_control =
  187|     48|        control->exchange(base_internal::kOnceDone, std::memory_order_release);
  188|     48|    if (old_control == base_internal::kOnceWaiter) {
  ------------------
  |  Branch (188:9): [True: 0, False: 48]
  ------------------
  189|      0|      base_internal::SpinLockWake(control, true);
  190|      0|    }
  191|     48|  }  // else *control is already kOnceDone
  192|     48|}
_ZN4absl12lts_202605269call_onceIRFvvEJEEEvRNS0_9once_flagEOT_DpOT0_:
  215|      2|    call_once(absl::once_flag& flag, Callable&& fn, Args&&... args) {
  216|      2|  std::atomic<uint32_t>* once = base_internal::ControlWord(&flag);
  217|      2|  uint32_t s = once->load(std::memory_order_acquire);
  218|      2|  if (ABSL_PREDICT_FALSE(s != base_internal::kOnceDone)) {
  ------------------
  |  |  190|      2|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 2, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 2]
  |  |  |  Branch (190:58): [True: 2, False: 0]
  |  |  ------------------
  ------------------
  219|      2|    base_internal::CallOnceImpl(
  220|      2|        once, base_internal::SCHEDULE_COOPERATIVE_AND_KERNEL,
  221|      2|        std::forward<Callable>(fn), std::forward<Args>(args)...);
  222|      2|  }
  223|      2|}
_ZN4absl12lts_2026052613base_internal12CallOnceImplIRFvvEJEEEvPNSt3__16atomicIjEENS1_14SchedulingModeEOT_DpOT0_:
  155|      2|                 Args&&... args) {
  156|       |#ifndef NDEBUG
  157|       |  {
  158|       |    uint32_t old_control = control->load(std::memory_order_relaxed);
  159|       |    if (old_control != kOnceInit &&
  160|       |        old_control != kOnceRunning &&
  161|       |        old_control != kOnceWaiter &&
  162|       |        old_control != kOnceDone) {
  163|       |      // Memory corruption may cause this error.
  164|       |      ABSL_RAW_LOG(FATAL, "Unexpected value for control word: 0x%lx",
  165|       |                   static_cast<unsigned long>(old_control));  // NOLINT
  166|       |    }
  167|       |  }
  168|       |#endif  // NDEBUG
  169|      2|  static const base_internal::SpinLockWaitTransition trans[] = {
  170|      2|      {kOnceInit, kOnceRunning, true},
  171|      2|      {kOnceRunning, kOnceWaiter, false},
  172|      2|      {kOnceDone, kOnceDone, true}};
  173|       |
  174|       |  // Must do this before potentially modifying control word's state.
  175|      2|  base_internal::SchedulingHelper maybe_disable_scheduling(scheduling_mode);
  176|       |  // Short circuit the simplest case to avoid procedure call overhead.
  177|       |  // The base_internal::SpinLockWait() call returns either kOnceInit or
  178|       |  // kOnceDone. If it returns kOnceDone, it must have loaded the control word
  179|       |  // with std::memory_order_acquire and seen a value of kOnceDone.
  180|      2|  uint32_t old_control = kOnceInit;
  181|      2|  if (control->compare_exchange_strong(old_control, kOnceRunning,
  ------------------
  |  Branch (181:7): [True: 2, False: 0]
  ------------------
  182|      2|                                       std::memory_order_relaxed) ||
  183|      0|      base_internal::SpinLockWait(control, ABSL_ARRAYSIZE(trans), trans,
  ------------------
  |  |   46|      0|  (sizeof(::absl::macros_internal::ArraySizeHelper(array)))
  ------------------
  |  Branch (183:7): [True: 0, False: 0]
  ------------------
  184|      2|                                  scheduling_mode) == kOnceInit) {
  185|      2|    std::invoke(std::forward<Callable>(fn), std::forward<Args>(args)...);
  186|      2|    old_control =
  187|      2|        control->exchange(base_internal::kOnceDone, std::memory_order_release);
  188|      2|    if (old_control == base_internal::kOnceWaiter) {
  ------------------
  |  Branch (188:9): [True: 0, False: 2]
  ------------------
  189|      0|      base_internal::SpinLockWake(control, true);
  190|      0|    }
  191|      2|  }  // else *control is already kOnceDone
  192|      2|}

_ZN4absl12lts_202605268bit_castImlTnNSt3__19enable_ifIXaaaaeqstT_stT0_sr3std21is_trivially_copyableIS5_EE5valuesr3std21is_trivially_copyableIS4_EE5valueEiE4typeELi0EEES4_RKS5_:
  190|  4.53k|inline constexpr Dest bit_cast(const Source& source) {
  191|  4.53k|  return __builtin_bit_cast(Dest, source);
  192|  4.53k|}
_ZN4absl12lts_202605268bit_castIlmTnNSt3__19enable_ifIXaaaaeqstT_stT0_sr3std21is_trivially_copyableIS5_EE5valuesr3std21is_trivially_copyableIS4_EE5valueEiE4typeELi0EEES4_RKS5_:
  190|  2.26k|inline constexpr Dest bit_cast(const Source& source) {
  191|  2.26k|  return __builtin_bit_cast(Dest, source);
  192|  2.26k|}
_ZN4absl12lts_202605268bit_castIdmTnNSt3__19enable_ifIXaaaaeqstT_stT0_sr3std21is_trivially_copyableIS5_EE5valuesr3std21is_trivially_copyableIS4_EE5valueEiE4typeELi0EEES4_RKS5_:
  190|  16.6k|inline constexpr Dest bit_cast(const Source& source) {
  191|  16.6k|  return __builtin_bit_cast(Dest, source);
  192|  16.6k|}
_ZN4absl12lts_202605268bit_castINS0_14flags_internal19FlagValueAndInitBitIN8fuzztest8internal14TimeBudgetTypeEEElTnNSt3__19enable_ifIXaaaaeqstT_stT0_sr3std21is_trivially_copyableISB_EE5valuesr3std21is_trivially_copyableISA_EE5valueEiE4typeELi0EEESA_RKSB_:
  190|      2|inline constexpr Dest bit_cast(const Source& source) {
  191|      2|  return __builtin_bit_cast(Dest, source);
  192|      2|}
_ZN4absl12lts_202605268bit_castIPvNS0_14FastTypeIdTypeETnNSt3__19enable_ifIXaaaaeqstT_stT0_sr3std21is_trivially_copyableIS7_EE5valuesr3std21is_trivially_copyableIS6_EE5valueEiE4typeELi0EEES6_RKS7_:
  190|      2|inline constexpr Dest bit_cast(const Source& source) {
  191|      2|  return __builtin_bit_cast(Dest, source);
  192|      2|}
_ZN4absl12lts_202605268bit_castINS0_14flags_internal19FlagValueAndInitBitIbEElTnNSt3__19enable_ifIXaaaaeqstT_stT0_sr3std21is_trivially_copyableIS8_EE5valuesr3std21is_trivially_copyableIS7_EE5valueEiE4typeELi0EEES7_RKS8_:
  190|     12|inline constexpr Dest bit_cast(const Source& source) {
  191|     12|  return __builtin_bit_cast(Dest, source);
  192|     12|}
_ZN4absl12lts_202605268bit_castINS0_14FastTypeIdTypeEPvTnNSt3__19enable_ifIXaaaaeqstT_stT0_sr3std21is_trivially_copyableIS7_EE5valuesr3std21is_trivially_copyableIS6_EE5valueEiE4typeELi0EEES6_RKS7_:
  190|      2|inline constexpr Dest bit_cast(const Source& source) {
  191|      2|  return __builtin_bit_cast(Dest, source);
  192|      2|}
_ZN4absl12lts_202605268bit_castIlNSt3__15arrayIcLm8EEETnNS2_9enable_ifIXaaaaeqstT_stT0_sr3std21is_trivially_copyableIS7_EE5valuesr3std21is_trivially_copyableIS6_EE5valueEiE4typeELi0EEES6_RKS7_:
  190|     16|inline constexpr Dest bit_cast(const Source& source) {
  191|     16|  return __builtin_bit_cast(Dest, source);
  192|     16|}

_ZN4absl12lts_2026052614FastTypeIdTypeC2EPKv:
   57|      4|  explicit constexpr FastTypeIdType(const void* ptr) : ptr_(ptr) {}
_ZN4absl12lts_20260526eqENS0_14FastTypeIdTypeES1_:
   45|      2|  friend constexpr bool operator==(FastTypeIdType a, FastTypeIdType b) {
   46|      2|    return a.ptr_ == b.ptr_;
   47|      2|  }
_ZN4absl12lts_2026052610FastTypeIdIbEENS0_14FastTypeIdTypeEv:
   66|      2|constexpr FastTypeIdType FastTypeId() {
   67|      2|  return FastTypeIdType(&base_internal::FastTypeTag<Type>::kDummyVar);
   68|      2|}
_ZN4absl12lts_2026052610FastTypeIdINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEENS0_14FastTypeIdTypeEv:
   66|      2|constexpr FastTypeIdType FastTypeId() {
   67|      2|  return FastTypeIdType(&base_internal::FastTypeTag<Type>::kDummyVar);
   68|      2|}

_ZN4absl12lts_202605269gbswap_32Ej:
   48|     20|constexpr uint32_t gbswap_32(uint32_t x) {
   49|     20|#if ABSL_HAVE_BUILTIN(__builtin_bswap32) || defined(__GNUC__)
   50|     20|  return __builtin_bswap32(x);
   51|       |#else
   52|       |  return (((x & uint32_t{0xFF}) << 24) |
   53|       |          ((x & uint32_t{0xFF00}) << 8) |
   54|       |          ((x & uint32_t{0xFF0000}) >> 8) |
   55|       |          ((x & uint32_t{0xFF000000}) >> 24));
   56|       |#endif
   57|     20|}
_ZN4absl12lts_202605269gbswap_16Et:
   59|      2|constexpr uint16_t gbswap_16(uint16_t x) {
   60|      2|#if ABSL_HAVE_BUILTIN(__builtin_bswap16) || defined(__GNUC__)
   61|      2|  return __builtin_bswap16(x);
   62|       |#else
   63|       |  return (((x & uint16_t{0xFF}) << 8) |
   64|       |          ((x & uint16_t{0xFF00}) >> 8));
   65|       |#endif
   66|      2|}
_ZN4absl12lts_2026052613little_endian10FromHost64Em:
  109|     10|inline uint64_t FromHost64(uint64_t x) { return x; }
_ZN4absl12lts_2026052613little_endian8ToHost64Em:
  110|     20|inline uint64_t ToHost64(uint64_t x) { return x; }
_ZN4absl12lts_2026052613little_endian6ToHostEm:
  136|     16|inline uint64_t ToHost(uint64_t x) { return ToHost64(x); }
_ZN4absl12lts_2026052613little_endian6Load64EPKv:
  176|      4|inline uint64_t Load64(const void* absl_nonnull p) {
  177|      4|  return ToHost64(ABSL_INTERNAL_UNALIGNED_LOAD64(p));
  ------------------
  |  |   78|      4|  (absl::base_internal::UnalignedLoad64(_p))
  ------------------
  178|      4|}
_ZN4absl12lts_2026052613little_endian7Store64EPvm:
  180|     10|inline void Store64(void* absl_nonnull p, uint64_t v) {
  181|     10|  ABSL_INTERNAL_UNALIGNED_STORE64(p, FromHost64(v));
  ------------------
  |  |   85|     10|  (absl::base_internal::UnalignedStore64(_p, _val))
  ------------------
  182|     10|}
_ZN4absl12lts_2026052610big_endian8ToHost16Et:
  194|      2|inline uint16_t ToHost16(uint16_t x) { return gbswap_16(x); }
_ZN4absl12lts_2026052610big_endian8ToHost32Ej:
  197|     20|inline uint32_t ToHost32(uint32_t x) { return gbswap_32(x); }
_ZN4absl12lts_2026052610big_endian6Load16EPKv:
  250|      2|inline uint16_t Load16(const void* absl_nonnull p) {
  251|      2|  return ToHost16(ABSL_INTERNAL_UNALIGNED_LOAD16(p));
  ------------------
  |  |   74|      2|  (absl::base_internal::UnalignedLoad16(_p))
  ------------------
  252|      2|}
_ZN4absl12lts_2026052610big_endian6Load32EPKv:
  258|     20|inline uint32_t Load32(const void* absl_nonnull p) {
  259|     20|  return ToHost32(ABSL_INTERNAL_UNALIGNED_LOAD32(p));
  ------------------
  |  |   76|     20|  (absl::base_internal::UnalignedLoad32(_p))
  ------------------
  260|     20|}

_ZN4absl12lts_2026052613base_internal8SpinLockC2Ev:
   62|     16|  constexpr SpinLock() : lockword_(kSpinLockCooperative) { RegisterWithTsan(); }
_ZN4absl12lts_2026052613base_internal8SpinLock16RegisterWithTsanEv:
  221|     16|  constexpr void RegisterWithTsan() {
  222|     16|#if ABSL_HAVE_BUILTIN(__builtin_is_constant_evaluated)
  223|     16|    if (!__builtin_is_constant_evaluated()) {
  ------------------
  |  Branch (223:9): [True: 16, Folded]
  ------------------
  224|     16|      ABSL_TSAN_MUTEX_CREATE(this, __tsan_mutex_not_static);
  225|     16|    }
  226|     16|#endif
  227|     16|  }
_ZN4absl12lts_2026052613base_internal14SpinLockHolderC2ERNS1_8SpinLockE:
  257|     18|      : std::lock_guard<SpinLock>(l) {}
_ZN4absl12lts_2026052613base_internal8SpinLock4lockEv:
   98|     18|  inline void lock() ABSL_EXCLUSIVE_LOCK_FUNCTION() {
   99|     18|    ABSL_TSAN_MUTEX_PRE_LOCK(this, 0);
  100|     18|    if (!TryLockImpl()) {
  ------------------
  |  Branch (100:9): [True: 0, False: 18]
  ------------------
  101|      0|      SlowLock();
  102|      0|    }
  103|     18|    ABSL_TSAN_MUTEX_POST_LOCK(this, 0, 0);
  104|     18|  }
_ZN4absl12lts_2026052613base_internal8SpinLock11TryLockImplEv:
  238|     18|  inline bool TryLockImpl() {
  239|     18|    uint32_t lock_value = lockword_.load(std::memory_order_relaxed);
  240|     18|    return (TryLockInternal(lock_value, 0) & kSpinLockHeld) == 0;
  241|     18|  }
_ZN4absl12lts_2026052613base_internal8SpinLock15TryLockInternalEjj:
  282|     18|                                          uint32_t wait_cycles) {
  283|     18|  if ((lock_value & kSpinLockHeld) != 0) {
  ------------------
  |  Branch (283:7): [True: 0, False: 18]
  ------------------
  284|      0|    return lock_value;
  285|      0|  }
  286|       |
  287|     18|  uint32_t sched_disabled_bit = 0;
  288|     18|  if ((lock_value & kSpinLockCooperative) == 0) {
  ------------------
  |  Branch (288:7): [True: 0, False: 18]
  ------------------
  289|       |    // For non-cooperative locks we must make sure we mark ourselves as
  290|       |    // non-reschedulable before we attempt to CompareAndSwap.
  291|      0|    if (SchedulingGuard::DisableRescheduling()) {
  ------------------
  |  Branch (291:9): [True: 0, False: 0]
  ------------------
  292|      0|      sched_disabled_bit = kSpinLockDisabledScheduling;
  293|      0|    }
  294|      0|  }
  295|       |
  296|     18|  if (!lockword_.compare_exchange_strong(
  ------------------
  |  Branch (296:7): [True: 0, False: 18]
  ------------------
  297|     18|          lock_value,
  298|     18|          kSpinLockHeld | lock_value | wait_cycles | sched_disabled_bit,
  299|     18|          std::memory_order_acquire, std::memory_order_relaxed)) {
  300|      0|    SchedulingGuard::EnableRescheduling(sched_disabled_bit != 0);
  301|      0|  }
  302|       |
  303|     18|  return lock_value;
  304|     18|}
_ZN4absl12lts_2026052613base_internal8SpinLock6unlockEv:
  128|     18|  inline void unlock() ABSL_UNLOCK_FUNCTION() {
  129|     18|    ABSL_TSAN_MUTEX_PRE_UNLOCK(this, 0);
  130|     18|    uint32_t lock_value = lockword_.load(std::memory_order_relaxed);
  131|     18|    lock_value = lockword_.exchange(lock_value & kSpinLockCooperative,
  132|     18|                                    std::memory_order_release);
  133|       |
  134|     18|    if ((lock_value & kSpinLockDisabledScheduling) != 0) {
  ------------------
  |  Branch (134:9): [True: 0, False: 18]
  ------------------
  135|      0|      SchedulingGuard::EnableRescheduling(true);
  136|      0|    }
  137|     18|    if ((lock_value & kWaitTimeMask) != 0) {
  ------------------
  |  Branch (137:9): [True: 0, False: 18]
  ------------------
  138|       |      // Collect contentionz profile info, and speed the wakeup of any waiter.
  139|       |      // The wait_cycles value indicates how long this thread spent waiting
  140|       |      // for the lock.
  141|      0|      SlowUnlock(lock_value);
  142|      0|    }
  143|     18|    ABSL_TSAN_MUTEX_POST_UNLOCK(this, 0);
  144|     18|  }

_ZN4absl12lts_2026052613base_internal15UnalignedLoad32EPKv:
   45|     60|inline uint32_t UnalignedLoad32(const void* absl_nonnull p) {
   46|     60|  uint32_t t;
   47|     60|  memcpy(&t, p, sizeof t);
   48|     60|  return t;
   49|     60|}
_ZN4absl12lts_2026052613base_internal15UnalignedLoad64EPKv:
   51|    278|inline uint64_t UnalignedLoad64(const void* absl_nonnull p) {
   52|    278|  uint64_t t;
   53|    278|  memcpy(&t, p, sizeof t);
   54|    278|  return t;
   55|    278|}
_ZN4absl12lts_2026052613base_internal15UnalignedLoad16EPKv:
   39|      2|inline uint16_t UnalignedLoad16(const void* absl_nonnull p) {
   40|      2|  uint16_t t;
   41|      2|  memcpy(&t, p, sizeof t);
   42|      2|  return t;
   43|      2|}
_ZN4absl12lts_2026052613base_internal16UnalignedStore64EPvm:
   65|     10|inline void UnalignedStore64(void* absl_nonnull p, uint64_t v) {
   66|     10|  memcpy(p, &v, sizeof v);
   67|     10|}

_ZN4absl12lts_2026052612NoDestructorINS0_5MutexEEC2IJETnNSt3__19enable_ifIXntsr3std7is_sameIFvDpRu7__decayIT_EEFvRS3_EEE5valueEiE4typeELi0EEEDpOS7_:
  122|     10|      : impl_(std::forward<Ts>(args)...) {}
_ZN4absl12lts_2026052612NoDestructorINS0_5MutexEE13PlacementImplC2IJEEEDpOT_:
  160|     10|    explicit PlacementImpl(Args&&... args) {
  161|     10|      new (&space_) T(std::forward<Args>(args)...);
  162|     10|    }
_ZN4absl12lts_2026052612NoDestructorINS0_5MutexEEdeEv:
  137|    116|  T& operator*() { return *get(); }
_ZN4absl12lts_2026052612NoDestructorINS0_5MutexEE3getEv:
  139|    116|  T* absl_nonnull get() { return impl_.get(); }
_ZN4absl12lts_2026052612NoDestructorINS0_5MutexEE13PlacementImpl3getEv:
  166|    116|    T* absl_nonnull get() {
  167|    116|      return std::launder(reinterpret_cast<T*>(&space_));
  168|    116|    }
_ZN4absl12lts_2026052612NoDestructorINS0_14flags_internal12FlagRegistryEEC2IJETnNSt3__19enable_ifIXntsr3std7is_sameIFvDpRu7__decayIT_EEFvRS4_EEE5valueEiE4typeELi0EEEDpOS8_:
  122|      2|      : impl_(std::forward<Ts>(args)...) {}
_ZN4absl12lts_2026052612NoDestructorINS0_14flags_internal12FlagRegistryEE13PlacementImplC2IJEEEDpOT_:
  160|      2|    explicit PlacementImpl(Args&&... args) {
  161|      2|      new (&space_) T(std::forward<Args>(args)...);
  162|      2|    }
_ZN4absl12lts_2026052612NoDestructorINS0_14flags_internal12FlagRegistryEEdeEv:
  137|     54|  T& operator*() { return *get(); }
_ZN4absl12lts_2026052612NoDestructorINS0_14flags_internal12FlagRegistryEE3getEv:
  139|     54|  T* absl_nonnull get() { return impl_.get(); }
_ZN4absl12lts_2026052612NoDestructorINS0_14flags_internal12FlagRegistryEE13PlacementImpl3getEv:
  166|     54|    T* absl_nonnull get() {
  167|     54|      return std::launder(reinterpret_cast<T*>(&space_));
  168|     54|    }

_ZN4absl12lts_2026052620PrefetchToLocalCacheEPKv:
  146|     46|    const void* addr) {
  147|     46|  __builtin_prefetch(addr, 0, 3);
  148|     46|}

_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_15CommandLineFlagEE5applyINS1_12EqualElementIS7_NS1_8StringEqEEEJRNS3_4pairIKS7_S9_EEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSJ_DpOSK_:
  680|      4|  apply(F&& f, Args&&... args) {
  681|      4|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  682|      4|                                                   std::forward<Args>(args)...);
  683|      4|  }
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_15CommandLineFlagEE7elementEPNS1_13map_slot_typeIS7_S9_EE:
  694|     82|  static std::pair<const K, V>& element(slot_type* slot) { return slot->value; }
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_15CommandLineFlagEE5applyINS1_12raw_hash_setISA_JEE19EmplaceDecomposableEJNS3_4pairIKS7_S9_EEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSI_DpOSJ_:
  680|     50|  apply(F&& f, Args&&... args) {
  681|     50|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  682|     50|                                                   std::forward<Args>(args)...);
  683|     50|  }
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_15CommandLineFlagEE5applyINS1_11HashElementINS1_10StringHashELb1EEEJRNS3_4pairIKS7_S9_EEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSJ_DpOSK_:
  680|     28|  apply(F&& f, Args&&... args) {
  681|     28|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  682|     28|                                                   std::forward<Args>(args)...);
  683|     28|  }
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_15CommandLineFlagEE8transferINS3_9allocatorINS3_4pairIKS7_S9_EEEEEEDaPT_PNS1_13map_slot_typeIS7_S9_EESL_:
  673|     28|                       slot_type* old_slot) {
  674|     28|    return slot_policy::transfer(alloc, new_slot, old_slot);
  675|     28|  }
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_15CommandLineFlagEE9constructINS3_9allocatorINS3_4pairIKS7_S9_EEEEJRKNS3_21piecewise_construct_tENS3_5tupleIJOSE_EEENSK_IJOS9_EEEEEEvPT_PNS1_13map_slot_typeIS7_S9_EEDpOT0_:
  661|     50|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  662|     50|    slot_policy::construct(alloc, slot, std::forward<Args>(args)...);
  663|     50|  }
_ZN4absl12lts_2026052613flat_hash_mapINSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPNS0_15CommandLineFlagENS0_18container_internal10StringHashENS9_8StringEqENS2_9allocatorINS2_4pairIKS6_S8_EEEEEC2Ev:
  196|      2|  flat_hash_map() {}

_ZN4absl12lts_2026052613InlinedVectorINS0_14SourceLocationELm1ENSt3__19allocatorIS2_EEED2Ev:
  300|  3.57k|  ~InlinedVector() {}
_ZN4absl12lts_2026052613InlinedVectorINS0_14SourceLocationELm1ENSt3__19allocatorIS2_EEEC2Ev:
  128|  3.57k|  InlinedVector() noexcept(noexcept(allocator_type())) : storage_() {}
_ZN4absl12lts_2026052613InlinedVectorINS0_14SourceLocationELm1ENSt3__19allocatorIS2_EEE9push_backERKS2_:
  753|  3.57k|  void push_back(const_reference v) { static_cast<void>(emplace_back(v)); }
_ZN4absl12lts_2026052613InlinedVectorINS0_14SourceLocationELm1ENSt3__19allocatorIS2_EEE12emplace_backIJRKS2_EEERS2_DpOT_:
  746|  3.57k|  reference emplace_back(Args&&... args) ABSL_ATTRIBUTE_LIFETIME_BOUND {
  747|  3.57k|    return storage_.EmplaceBack(std::forward<Args>(args)...);
  748|  3.57k|  }

_ZN4absl12lts_2026052618container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEvE7elementISB_EEDTclsrT_7elementfp_EEPNS1_13map_slot_typeIS8_SA_EE:
   85|     82|      -> decltype(P::element(slot)) {
   86|     82|    return P::element(slot);
   87|     82|  }
_ZN4absl12lts_2026052618container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEvE8transferINS4_9allocatorINS4_4pairIKS8_SA_EEEEEEvPT_PNS1_13map_slot_typeIS8_SA_EESN_:
   75|     28|  static void transfer(Alloc* alloc, slot_type* new_slot, slot_type* old_slot) {
   76|     28|    transfer_impl(alloc, new_slot, old_slot, Rank2{});
   77|     28|  }
_ZN4absl12lts_2026052618container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEvE13transfer_implINS4_9allocatorINS4_4pairIKS8_SA_EEEESB_EEDTclsrT0_8transferfp_fp0_fp1_EEPT_PNS1_13map_slot_typeIS8_SA_EESP_NSC_5Rank2E:
  119|     28|                                                           old_slot)) {
  120|     28|    return P::transfer(alloc, new_slot, old_slot);
  121|     28|  }
_ZN4absl12lts_2026052618container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEvE9constructINS4_9allocatorINS4_4pairIKS8_SA_EEEEJRKNS4_21piecewise_construct_tENS4_5tupleIJOSG_EEENSM_IJOSA_EEEEEEvPT_PNS1_13map_slot_typeIS8_SA_EEDpOT0_:
   51|     50|  static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
   52|     50|    Policy::construct(alloc, slot, std::forward<Args>(args)...);
   53|     50|  }

_ZNR4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageImLm1ENS2_10StorageTagIJNSt3__19allocatorINS0_14SourceLocationEEEmEEELb0EE3getEv:
   92|  7.14k|  constexpr T& get() & { return value; }
_ZNR4absl12lts_2026052618container_internal15CompressedTupleIJNSt3__19allocatorINS0_14SourceLocationEEEmEE3getILi1EEERNS1_25internal_compressed_tuple4ElemIS7_XT_EE4typeEv:
  244|  7.14k|  constexpr ElemT<I>& get() & {
  245|  7.14k|    return StorageT<I>::get();
  246|  7.14k|  }
_ZNKR4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageImLm1ENS2_10StorageTagIJNSt3__19allocatorINS0_14SourceLocationEEEmEEELb0EE3getEv:
   91|  10.7k|  constexpr const T& get() const& { return value; }
_ZNKR4absl12lts_2026052618container_internal15CompressedTupleIJNSt3__19allocatorINS0_14SourceLocationEEEmEE3getILi1EEERKNS1_25internal_compressed_tuple4ElemIS7_XT_EE4typeEv:
  249|  10.7k|  constexpr const ElemT<I>& get() const& {
  250|  10.7k|    return StorageT<I>::get();
  251|  10.7k|  }
_ZNR4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINSt3__19allocatorINS0_14SourceLocationEEELm0ENS2_10StorageTagIJS7_mEEELb1EE3getEv:
  105|  3.57k|  constexpr T& get() & { return *this; }
_ZNR4absl12lts_2026052618container_internal15CompressedTupleIJNSt3__19allocatorINS0_14SourceLocationEEEmEE3getILi0EEERNS1_25internal_compressed_tuple4ElemIS7_XT_EE4typeEv:
  244|  3.57k|  constexpr ElemT<I>& get() & {
  245|  3.57k|    return StorageT<I>::get();
  246|  3.57k|  }
_ZNKR4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINS1_12CommonFieldsELm0ENS2_10StorageTagIJS4_NS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEEELb0EE3getEv:
   91|    376|  constexpr const T& get() const& { return value; }
_ZNKR4absl12lts_2026052618container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEE3getILi0EEERKNS1_25internal_compressed_tuple4ElemIS9_XT_EE4typeEv:
  249|    376|  constexpr const ElemT<I>& get() const& {
  250|    376|    return StorageT<I>::get();
  251|    376|  }
_ZNR4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINS1_12CommonFieldsELm0ENS2_10StorageTagIJS4_NS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEEELb0EE3getEv:
   92|    236|  constexpr T& get() & { return value; }
_ZNR4absl12lts_2026052618container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEE3getILi0EEERNS1_25internal_compressed_tuple4ElemIS9_XT_EE4typeEv:
  244|    236|  constexpr ElemT<I>& get() & {
  245|    236|    return StorageT<I>::get();
  246|    236|  }
_ZNR4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINSt3__19allocatorIcEELm3ENS2_10StorageTagIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqES6_EEELb1EE3getEv:
  105|     80|  constexpr T& get() & { return *this; }
_ZNR4absl12lts_2026052618container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEE3getILi3EEERNS1_25internal_compressed_tuple4ElemIS9_XT_EE4typeEv:
  244|     80|  constexpr ElemT<I>& get() & {
  245|     80|    return StorageT<I>::get();
  246|     80|  }
_ZN4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINS1_12CommonFieldsELm0ENS2_10StorageTagIJS4_NS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEEELb0EEC2IS4_EENS8_10in_place_tEOT_:
   90|      2|      : value(std::forward<V>(v)) {}
_ZNKR4absl12lts_2026052618container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEE3getILi1EEERKNS1_25internal_compressed_tuple4ElemIS9_XT_EE4typeEv:
  249|     74|  constexpr const ElemT<I>& get() const& {
  250|     74|    return StorageT<I>::get();
  251|     74|  }
_ZNKR4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINS1_10StringHashELm1ENS2_10StorageTagIJNS1_12CommonFieldsES4_NS1_8StringEqENSt3__19allocatorIcEEEEELb1EE3getEv:
  104|     74|  constexpr const T& get() const& { return *this; }
_ZNKR4absl12lts_2026052618container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEE3getILi2EEERKNS1_25internal_compressed_tuple4ElemIS9_XT_EE4typeEv:
  249|      4|  constexpr const ElemT<I>& get() const& {
  250|      4|    return StorageT<I>::get();
  251|      4|  }
_ZNKR4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINS1_8StringEqELm2ENS2_10StorageTagIJNS1_12CommonFieldsENS1_10StringHashES4_NSt3__19allocatorIcEEEEELb1EE3getEv:
  104|      4|  constexpr const T& get() const& { return *this; }
_ZNR4absl12lts_2026052618container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEE3getILi1EEERNS1_25internal_compressed_tuple4ElemIS9_XT_EE4typeEv:
  244|      4|  constexpr ElemT<I>& get() & {
  245|      4|    return StorageT<I>::get();
  246|      4|  }
_ZNR4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINS1_10StringHashELm1ENS2_10StorageTagIJNS1_12CommonFieldsES4_NS1_8StringEqENSt3__19allocatorIcEEEEELb1EE3getEv:
  105|      4|  constexpr T& get() & { return *this; }
_ZN4absl12lts_2026052618container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEEC2IS3_JS4_S5_S8_ETnNS6_9enable_ifIXsr3std11conjunctionINS6_8negationINS6_7is_sameIFvS9_EFvu7__decayIT_EEEEEENS1_25internal_compressed_tuple27TupleItemsMoveConstructibleIS9_JSF_DpT0_EEEEE5valueEbE4typeELb1EEEOSF_DpOSM_:
  239|      2|      : CompressedTuple::CompressedTupleImpl(std::in_place,
  240|      2|                                             std::forward<First>(first),
  241|      2|                                             std::forward<Vs>(base)...) {}
_ZN4absl12lts_2026052618container_internal25internal_compressed_tuple19CompressedTupleImplINS1_15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEEENS8_16integer_sequenceImJLm0ELm1ELm2ELm3EEEELb1EEC2IJS5_S6_S7_SA_EEENS8_10in_place_tEDpOT_:
  126|      8|      : Storage<Ts, I, StorageTag<Ts...>>(std::in_place,
  127|      8|                                          std::forward<Vs>(args))... {}
_ZN4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINS1_10StringHashELm1ENS2_10StorageTagIJNS1_12CommonFieldsES4_NS1_8StringEqENSt3__19allocatorIcEEEEELb1EEC2IS4_EENS8_10in_place_tEOT_:
  102|      2|  explicit constexpr Storage(std::in_place_t, V&& v) : T(std::forward<V>(v)) {}
_ZN4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINS1_8StringEqELm2ENS2_10StorageTagIJNS1_12CommonFieldsENS1_10StringHashES4_NSt3__19allocatorIcEEEEELb1EEC2IS4_EENS8_10in_place_tEOT_:
  102|      2|  explicit constexpr Storage(std::in_place_t, V&& v) : T(std::forward<V>(v)) {}
_ZN4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINSt3__19allocatorIcEELm3ENS2_10StorageTagIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqES6_EEELb1EEC2IS6_EENS4_10in_place_tEOT_:
  102|      2|  explicit constexpr Storage(std::in_place_t, V&& v) : T(std::forward<V>(v)) {}
_ZN4absl12lts_2026052618container_internal15CompressedTupleIJNSt3__19allocatorINS0_14SourceLocationEEEmEEC2IS6_JjETnNS3_9enable_ifIXsr3std11conjunctionINS3_8negationINS3_7is_sameIFvS7_EFvu7__decayIT_EEEEEENS1_25internal_compressed_tuple27TupleItemsMoveConstructibleIS7_JSD_DpT0_EEEEE5valueEbE4typeELb1EEEOSD_DpOSK_:
  239|  3.57k|      : CompressedTuple::CompressedTupleImpl(std::in_place,
  240|  3.57k|                                             std::forward<First>(first),
  241|  3.57k|                                             std::forward<Vs>(base)...) {}
_ZN4absl12lts_2026052618container_internal25internal_compressed_tuple19CompressedTupleImplINS1_15CompressedTupleIJNSt3__19allocatorINS0_14SourceLocationEEEmEEENS5_16integer_sequenceImJLm0ELm1EEEELb1EEC2IJS8_jEEENS5_10in_place_tEDpOT_:
  126|  7.14k|      : Storage<Ts, I, StorageTag<Ts...>>(std::in_place,
  127|  7.14k|                                          std::forward<Vs>(args))... {}
_ZN4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINSt3__19allocatorINS0_14SourceLocationEEELm0ENS2_10StorageTagIJS7_mEEELb1EEC2IS7_EENS4_10in_place_tEOT_:
  102|  3.57k|  explicit constexpr Storage(std::in_place_t, V&& v) : T(std::forward<V>(v)) {}
_ZN4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageImLm1ENS2_10StorageTagIJNSt3__19allocatorINS0_14SourceLocationEEEmEEELb0EEC2IjEENS5_10in_place_tEOT_:
   90|  3.57k|      : value(std::forward<V>(v)) {}

_ZN4absl12lts_2026052618container_internal29SanitizerUnpoisonMemoryRegionEPKvm:
  251|     90|inline void SanitizerUnpoisonMemoryRegion(const void* m, size_t s) {
  252|       |#ifdef ABSL_HAVE_ADDRESS_SANITIZER
  253|       |  ASAN_UNPOISON_MEMORY_REGION(m, s);
  254|       |#endif
  255|       |#ifdef ABSL_HAVE_MEMORY_SANITIZER
  256|       |  __msan_unpoison(m, s);
  257|       |#endif
  258|     90|  (void)m;
  259|     90|  (void)s;
  260|     90|}
_ZN4absl12lts_2026052618container_internal27SanitizerPoisonMemoryRegionEPKvm:
  240|     38|inline void SanitizerPoisonMemoryRegion(const void* m, size_t s) {
  241|       |#ifdef ABSL_HAVE_ADDRESS_SANITIZER
  242|       |  ASAN_POISON_MEMORY_REGION(m, s);
  243|       |#endif
  244|       |#ifdef ABSL_HAVE_MEMORY_SANITIZER
  245|       |  __msan_poison(m, s);
  246|       |#endif
  247|     38|  (void)m;
  248|     38|  (void)s;
  249|     38|}
_ZN4absl12lts_2026052618container_internal11HashElementINS1_10StringHashELb1EEC2ERKS3_m:
  495|     78|  HashElement(const Hash& h, size_t s) : hash(h), seed(s) {}
_ZN4absl12lts_2026052618container_internal13DecomposePairINS1_12EqualElementINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEENS1_8StringEqEEEJRNS4_4pairIKS8_PNS0_15CommandLineFlagEEEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSH_DpOSI_:
  226|      4|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  227|      4|  return memory_internal::DecomposePairImpl(
  228|      4|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  229|      4|}
_ZN4absl12lts_2026052618container_internal15memory_internal17DecomposePairImplINS1_12EqualElementINSt3__117basic_string_viewIcNS5_11char_traitsIcEEEENS1_8StringEqEEERKS9_NS5_5tupleIJRKPNS0_15CommandLineFlagEEEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNS5_19piecewise_constructEEclsr3stdE7declvalINSE_IJSL_EEEEEclsr3stdE7declvalIT1_EEEEOSK_NS5_4pairISO_SP_EE:
  158|      4|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  159|      4|  const auto& key = std::get<0>(p.first);
  160|      4|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  161|      4|                            std::move(p.second));
  162|      4|}
_ZNK4absl12lts_2026052618container_internal12EqualElementINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEENS1_8StringEqEEclIS7_JRKNS3_21piecewise_construct_tENS3_5tupleIJRKS7_EEENSE_IJRKPNS0_15CommandLineFlagEEEEEEEbRKT_DpOT0_:
  529|      4|  bool operator()(const K2& lhs, Args&&...) const {
  530|      4|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(eq(lhs, rhs));
  ------------------
  |  |  488|      4|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
  531|      4|  }
_ZN4absl12lts_2026052618container_internal8PairArgsIKNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS3_4pairINS3_5tupleIJRKT_EEENSC_IJRKT0_EEEEERKNSB_ISD_SH_EE:
  207|     32|    const std::pair<F, S>& p) {
  208|     32|  return PairArgs(p.first, p.second);
  209|     32|}
_ZN4absl12lts_2026052618container_internal8PairArgsIRKNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEERKPNS0_15CommandLineFlagEEENS3_4pairINS3_5tupleIJOT_EEENSF_IJOT0_EEEEESH_SK_:
  201|     32|std::pair<std::tuple<F&&>, std::tuple<S&&>> PairArgs(F&& f, S&& s) {
  202|     32|  return {std::piecewise_construct, std::forward_as_tuple(std::forward<F>(f)),
  203|     32|          std::forward_as_tuple(std::forward<S>(s))};
  204|     32|}
_ZNK4absl12lts_2026052618container_internal11HashElementINS1_10StringHashELb1EEclINSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEJEEEmRKT_DpOT0_:
  498|     50|  size_t operator()(const K& key, Args&&...) const {
  499|     50|    if constexpr (kIsDefault) {
  500|       |      // TODO(b/384509507): resolve `no header providing
  501|       |      // "absl::hash_internal::SupportsHashWithSeed" is directly included`.
  502|       |      // Maybe we should make "internal/hash.h" be a separate library.
  503|     50|      return absl::hash_internal::HashWithSeed().hash(hash, key, seed);
  504|     50|    }
  505|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  506|      0|    return hash(key) ^ seed;
  507|     50|  }
_ZN4absl12lts_2026052618container_internal13DecomposePairINS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE19EmplaceDecomposableEJNS5_4pairIKS9_SB_EEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSI_DpOSJ_:
  226|     50|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  227|     50|  return memory_internal::DecomposePairImpl(
  228|     50|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  229|     50|}
_ZN4absl12lts_2026052618container_internal15memory_internal17DecomposePairImplINS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE19EmplaceDecomposableEOKSA_NS6_5tupleIJOSC_EEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNS6_19piecewise_constructEEclsr3stdE7declvalINSI_IJSM_EEEEEclsr3stdE7declvalIT1_EEEEOSL_NS6_4pairISP_SQ_EE:
  158|     50|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  159|     50|  const auto& key = std::get<0>(p.first);
  160|     50|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  161|     50|                            std::move(p.second));
  162|     50|}
_ZN4absl12lts_2026052618container_internal23TypeErasedApplyToSlotFnINS1_10StringHashENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEELb1EEEmPKvPvm:
  542|      2|size_t TypeErasedApplyToSlotFn(const void* fn, void* slot, size_t seed) {
  543|      2|  const auto* f = static_cast<const Fn*>(fn);
  544|      2|  return HashElement<Fn, kIsDefault>{*f, seed}(*static_cast<const T*>(slot));
  545|      2|}
_ZN4absl12lts_2026052618container_internal13DecomposePairINS1_11HashElementINS1_10StringHashELb1EEEJRNSt3__14pairIKNS6_17basic_string_viewIcNS6_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSH_DpOSI_:
  226|     28|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  227|     28|  return memory_internal::DecomposePairImpl(
  228|     28|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  229|     28|}
_ZN4absl12lts_2026052618container_internal15memory_internal17DecomposePairImplINS1_11HashElementINS1_10StringHashELb1EEERKNSt3__117basic_string_viewIcNS7_11char_traitsIcEEEENS7_5tupleIJRKPNS0_15CommandLineFlagEEEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNS7_19piecewise_constructEEclsr3stdE7declvalINSE_IJSL_EEEEEclsr3stdE7declvalIT1_EEEEOSK_NS7_4pairISO_SP_EE:
  158|     28|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  159|     28|  const auto& key = std::get<0>(p.first);
  160|     28|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  161|     28|                            std::move(p.second));
  162|     28|}
_ZNK4absl12lts_2026052618container_internal11HashElementINS1_10StringHashELb1EEclINSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEJRKNS6_21piecewise_construct_tENS6_5tupleIJRKSA_EEENSE_IJRKPNS0_15CommandLineFlagEEEEEEEmRKT_DpOT0_:
  498|     28|  size_t operator()(const K& key, Args&&...) const {
  499|     28|    if constexpr (kIsDefault) {
  500|       |      // TODO(b/384509507): resolve `no header providing
  501|       |      // "absl::hash_internal::SupportsHashWithSeed" is directly included`.
  502|       |      // Maybe we should make "internal/hash.h" be a separate library.
  503|     28|      return absl::hash_internal::HashWithSeed().hash(hash, key, seed);
  504|     28|    }
  505|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  506|      0|    return hash(key) ^ seed;
  507|     28|  }
_ZN4absl12lts_2026052618container_internal15map_slot_policyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_15CommandLineFlagEE8transferINS3_9allocatorINS3_4pairIKS7_S9_EEEEEEDaPT_PNS1_13map_slot_typeIS7_S9_EESL_:
  442|     28|                       slot_type* old_slot) {
  443|       |    // This should really just be
  444|       |    // typename absl::is_trivially_relocatable<value_type>::type()
  445|       |    // but std::pair is not trivially copyable in C++23 in some standard
  446|       |    // library versions.
  447|       |    // See https://github.com/llvm/llvm-project/pull/95444 for instance.
  448|     28|    auto is_relocatable = typename std::conjunction<
  449|     28|        absl::is_trivially_relocatable<typename value_type::first_type>,
  450|     28|        absl::is_trivially_relocatable<typename value_type::second_type>>::
  451|     28|        type();
  452|       |
  453|     28|    emplace(new_slot);
  454|     28|    if (is_relocatable) {
  ------------------
  |  Branch (454:9): [True: 28, Folded]
  ------------------
  455|       |      // TODO(b/247130232,b/251814870): remove casts after fixing warnings.
  456|     28|      std::memcpy(static_cast<void*>(std::launder(&new_slot->value)),
  457|     28|                  static_cast<const void*>(&old_slot->value),
  458|     28|                  sizeof(value_type));
  459|     28|      return is_relocatable;
  460|     28|    }
  461|       |
  462|      0|    if (kMutableKeys::value) {
  ------------------
  |  Branch (462:9): [True: 0, Folded]
  ------------------
  463|      0|      std::allocator_traits<Allocator>::construct(
  464|      0|          *alloc, &new_slot->mutable_value, std::move(old_slot->mutable_value));
  465|      0|    } else {
  466|      0|      std::allocator_traits<Allocator>::construct(*alloc, &new_slot->value,
  467|      0|                                                  std::move(old_slot->value));
  468|      0|    }
  469|      0|    destroy(alloc, old_slot);
  470|      0|    return is_relocatable;
  471|     28|  }
_ZN4absl12lts_2026052618container_internal15map_slot_policyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_15CommandLineFlagEE7emplaceEPNS1_13map_slot_typeIS7_S9_EE:
  368|     78|  static void emplace(slot_type* slot) {
  369|       |    // The construction of union doesn't do anything at runtime but it allows us
  370|       |    // to access its members without violating aliasing rules.
  371|     78|    new (slot) slot_type;
  372|     78|  }
_ZN4absl12lts_2026052618container_internal13map_slot_typeINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_15CommandLineFlagEEC2Ev:
  349|     78|  map_slot_type() {}
_ZN4absl12lts_2026052618container_internal7HashKeyINS1_10StringHashENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEELb1EEC2ERKS3_RKS8_:
  515|      4|  HashKey(const Hash& h, const Key& k) : hash(h), key(k) {}
_ZNK4absl12lts_2026052618container_internal7HashKeyINS1_10StringHashENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEELb1EEclEm:
  517|      2|  size_t operator()(size_t seed) const {
  518|      2|    return HashElement<Hash, kIsDefault>{hash, seed}(key);
  519|      2|  }
_ZN4absl12lts_2026052618container_internal15map_slot_policyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_15CommandLineFlagEE9constructINS3_9allocatorINS3_4pairIKS7_S9_EEEEJRKNS3_21piecewise_construct_tENS3_5tupleIJOSE_EEENSK_IJOS9_EEEEEEvPT_PNS1_13map_slot_typeIS7_S9_EEDpOT0_:
  397|     50|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  398|     50|    emplace(slot);
  399|     50|    if (kMutableKeys::value) {
  ------------------
  |  Branch (399:9): [True: 50, Folded]
  ------------------
  400|     50|      std::allocator_traits<Allocator>::construct(*alloc, &slot->mutable_value,
  401|     50|                                                  std::forward<Args>(args)...);
  402|     50|    } else {
  403|      0|      std::allocator_traits<Allocator>::construct(*alloc, &slot->value,
  404|      0|                                                  std::forward<Args>(args)...);
  405|      0|    }
  406|     50|  }
_ZN4absl12lts_2026052618container_internal8PairArgsIKNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS3_4pairINS3_5tupleIJOT_EEENSC_IJOT0_EEEEEONSB_ISD_SG_EE:
  211|     50|std::pair<std::tuple<F&&>, std::tuple<S&&>> PairArgs(std::pair<F, S>&& p) {
  212|     50|  return PairArgs(std::forward<F>(p.first), std::forward<S>(p.second));
  213|     50|}
_ZN4absl12lts_2026052618container_internal8PairArgsIKNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS3_4pairINS3_5tupleIJOT_EEENSC_IJOT0_EEEEESE_SH_:
  201|     50|std::pair<std::tuple<F&&>, std::tuple<S&&>> PairArgs(F&& f, S&& s) {
  202|     50|  return {std::piecewise_construct, std::forward_as_tuple(std::forward<F>(f)),
  203|     50|          std::forward_as_tuple(std::forward<S>(s))};
  204|     50|}
_ZN4absl12lts_2026052618container_internal8AllocateILm8ENSt3__19allocatorIcEEEEPvPT0_m:
   62|     10|void* Allocate(Alloc* alloc, size_t n) {
   63|     10|  static_assert(Alignment > 0, "");
   64|     10|  assert(n && "n must be positive");
   65|     10|  using M = AlignedType<Alignment>;
   66|     10|  using A = typename std::allocator_traits<Alloc>::template rebind_alloc<M>;
   67|     10|  using AT = typename std::allocator_traits<Alloc>::template rebind_traits<M>;
   68|       |  // On macOS, "mem_alloc" is a #define with one argument defined in
   69|       |  // rpc/types.h, so we can't name the variable "mem_alloc" and initialize it
   70|       |  // with the "foo(bar)" syntax.
   71|     10|  A my_mem_alloc(*alloc);
   72|     10|  void* p = AT::allocate(my_mem_alloc, (n + sizeof(M) - 1) / sizeof(M));
   73|       |  assert(reinterpret_cast<uintptr_t>(p) % Alignment == 0 &&
   74|     10|         "allocator does not respect alignment");
   75|     10|  return p;
   76|     10|}
_ZN4absl12lts_2026052618container_internal10DeallocateILm8ENSt3__19allocatorIcEEEEvPT0_Pvm:
   93|      8|void Deallocate(Alloc* alloc, void* p, size_t n) {
   94|      8|  static_assert(Alignment > 0, "");
   95|      8|  assert(n && "n must be positive");
   96|      8|  using M = AlignedType<Alignment>;
   97|      8|  using A = typename std::allocator_traits<Alloc>::template rebind_alloc<M>;
   98|      8|  using AT = typename std::allocator_traits<Alloc>::template rebind_traits<M>;
   99|       |  // On macOS, "mem_alloc" is a #define with one argument defined in
  100|       |  // rpc/types.h, so we can't name the variable "mem_alloc" and initialize it
  101|       |  // with the "foo(bar)" syntax.
  102|      8|  A my_mem_alloc(*alloc);
  103|      8|  AT::deallocate(my_mem_alloc, static_cast<M*>(p),
  104|      8|                 (n + sizeof(M) - 1) / sizeof(M));
  105|      8|}

_ZNK4absl12lts_2026052618container_internal10StringHash14hash_with_seedENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEm:
   86|     78|  size_t hash_with_seed(absl::string_view v, size_t seed) const {
   87|     78|    return absl::hash_internal::HashWithSeed().hash(
   88|     78|        absl::Hash<absl::string_view>{}, v, seed);
   89|     78|  }
_ZNK4absl12lts_2026052618container_internal8StringEqclENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEES7_:
   98|      4|  bool operator()(absl::string_view lhs, absl::string_view rhs) const {
   99|      4|    return lhs == rhs;
  100|      4|  }

_ZN4absl12lts_2026052618container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEvE5applyINS1_12EqualElementIS8_NS1_8StringEqEEEJRNS4_4pairIKS8_SA_EEESB_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSM_DpOSN_:
  130|      4|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|      4|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|      4|  }
_ZN4absl12lts_2026052618container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEvE5applyINS1_12raw_hash_setISB_JEE19EmplaceDecomposableEJNS4_4pairIKS8_SA_EEESB_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSL_DpOSM_:
  130|     50|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|     50|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|     50|  }
_ZN4absl12lts_2026052618container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEvE5applyINS1_11HashElementINS1_10StringHashELb1EEEJRNS4_4pairIKS8_SA_EEESB_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSM_DpOSN_:
  130|     28|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|     28|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|     28|  }

_ZN4absl12lts_2026052618container_internal13TrailingZerosImEEjT_:
   63|     12|uint32_t TrailingZeros(T x) {
   64|     12|  ABSL_ASSUME(x != 0);
  ------------------
  |  |  271|     12|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
   65|     12|  return static_cast<uint32_t>(countr_zero(x));
   66|     12|}
_ZN4absl12lts_2026052618container_internal13GroupSse2ImplC2EPKNS1_6ctrl_tE:
  284|     50|  explicit GroupSse2Impl(const ctrl_t* pos) {
  285|     50|    ctrl = _mm_loadu_si128(reinterpret_cast<const __m128i*>(pos));
  286|     50|  }
_ZNK4absl12lts_2026052618container_internal13GroupSse2Impl8MaskFullEv:
  308|      2|  BitMaskType MaskFull() const { return BitMaskType(MoveMask(ctrl) ^ 0xffff); }
_ZN4absl12lts_2026052618container_internal13GroupSse2Impl8MoveMaskEDv2_x:
  344|     96|  static MaskInt MoveMask(__m128i xmm) {
  345|     96|    auto mask = static_cast<MaskInt>(_mm_movemask_epi8(xmm));
  346|     96|#ifdef __clang__
  347|       |    // TODO(b/472522597): Without the inline asm, clang ends up generating an
  348|       |    // unnecessary movzx to zero the upper bits of the output, but those bits
  349|       |    // are already zero. See https://godbolt.org/z/G6xW1Ecbx.
  350|     96|    asm("" : "+r"(mask));  // NOLINT
  351|     96|#endif
  352|     96|    return mask;
  353|     96|  }
_ZN4absl12lts_2026052618container_internal7BitMaskIjLi16ELi0ELb0EEC2Ej:
  133|     96|  explicit BitMask(T mask) : Base(mask) {
  134|     96|    if (Shift == 3 && !NullifyBitsOnIteration) {
  ------------------
  |  Branch (134:9): [Folded, False: 96]
  |  Branch (134:23): [True: 0, Folded]
  ------------------
  135|       |      ABSL_SWISSTABLE_ASSERT(this->mask_ == (this->mask_ & kMsbs8Bytes));
  ------------------
  |  |   58|      0|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  136|      0|    }
  137|     96|  }
_ZN4absl12lts_2026052618container_internal18NonIterableBitMaskIjLi16ELi0EEC2Ej:
   85|    144|  explicit NonIterableBitMask(T mask) : mask_(mask) {}
_ZNK4absl12lts_2026052618container_internal7BitMaskIjLi16ELi0ELb0EE5beginEv:
  153|     48|  BitMask begin() const { return *this; }
_ZNK4absl12lts_2026052618container_internal7BitMaskIjLi16ELi0ELb0EE3endEv:
  154|     48|  BitMask end() const { return BitMask(0); }
_ZN4absl12lts_2026052618container_internalneERKNS1_7BitMaskIjLi16ELi0ELb0EEES5_:
  160|     78|  friend bool operator!=(const BitMask& a, const BitMask& b) {
  161|     78|    return a.mask_ != b.mask_;
  162|     78|  }
_ZNK4absl12lts_2026052618container_internal7BitMaskIjLi16ELi0ELb0EEdeEv:
  151|     30|  uint32_t operator*() const { return Base::LowestBitSet(); }
_ZNK4absl12lts_2026052618container_internal18NonIterableBitMaskIjLi16ELi0EE12LowestBitSetEv:
   90|     72|  uint32_t LowestBitSet() const {
   91|     72|    return container_internal::TrailingZeros(mask_) >> Shift;
   92|     72|  }
_ZN4absl12lts_2026052618container_internal13TrailingZerosIjEEjT_:
   63|     72|uint32_t TrailingZeros(T x) {
   64|     72|  ABSL_ASSUME(x != 0);
  ------------------
  |  |  271|     72|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
   65|     72|  return static_cast<uint32_t>(countr_zero(x));
   66|     72|}
_ZNK4absl12lts_2026052618container_internal18NonIterableBitMaskIjLi16ELi0EEcvbEv:
   87|     48|  explicit operator bool() const { return mask_ != 0; }
_ZN4absl12lts_2026052618container_internal7BitMaskIjLi16ELi0ELb0EEppEv:
  143|     30|  BitMask& operator++() {
  144|     30|    if (Shift == 3 && NullifyBitsOnIteration) {
  ------------------
  |  Branch (144:9): [Folded, False: 30]
  |  Branch (144:23): [Folded, False: 0]
  ------------------
  145|      0|      this->mask_ &= kMsbs8Bytes;
  146|      0|    }
  147|     30|    this->mask_ &= (this->mask_ - 1);
  148|     30|    return *this;
  149|     30|  }
_ZNK4absl12lts_2026052618container_internal13GroupSse2Impl5MatchEh:
  289|     46|  BitMaskType Match(h2_t hash) const {
  290|     46|    auto match = _mm_set1_epi8(static_cast<char>(hash));
  291|     46|    return BitMaskType(MoveMask(_mm_cmpeq_epi8(match, ctrl)));
  292|     46|  }
_ZNK4absl12lts_2026052618container_internal13GroupSse2Impl9MaskEmptyEv:
  295|     46|  NonIterableBitMaskType MaskEmpty() const {
  296|       |#ifdef ABSL_INTERNAL_HAVE_SSSE3
  297|       |    // This only works because ctrl_t::kEmpty is -128.
  298|       |    return NonIterableBitMaskType(MoveMask(_mm_sign_epi8(ctrl, ctrl)));
  299|       |#else
  300|     46|    auto match = _mm_set1_epi8(static_cast<char>(ctrl_t::kEmpty));
  301|     46|    return NonIterableBitMaskType(MoveMask(_mm_cmpeq_epi8(match, ctrl)));
  302|     46|#endif
  303|     46|  }
_ZN4absl12lts_2026052618container_internal16IsEmptyOrDeletedENS1_6ctrl_tE:
  228|     66|inline bool IsEmptyOrDeleted(ctrl_t c) { return c < ctrl_t::kSentinel; }
_ZNK4absl12lts_2026052618container_internal13GroupSse2Impl18MaskEmptyOrDeletedEv:
  316|      2|  NonIterableBitMaskType MaskEmptyOrDeleted() const {
  317|      2|    auto special = _mm_set1_epi8(static_cast<char>(ctrl_t::kSentinel));
  318|      2|    return NonIterableBitMaskType(
  319|      2|        MoveMask(_mm_cmpgt_epi8_fixed(special, ctrl)));
  320|      2|  }
_ZN4absl12lts_2026052618container_internal6IsFullENS1_6ctrl_tE:
  221|     46|inline bool IsFull(ctrl_t c) {
  222|       |  // Cast `c` to the underlying type instead of casting `0` to `ctrl_t` as `0`
  223|       |  // is not a value in the enum. Both ways are equivalent, but this way makes
  224|       |  // linters happier.
  225|     46|  return static_cast<std::underlying_type_t<ctrl_t>>(c) >= 0;
  226|     46|}
_ZN4absl12lts_2026052618container_internal20_mm_cmpgt_epi8_fixedEDv2_xS2_:
  264|      2|inline __m128i _mm_cmpgt_epi8_fixed(__m128i a, __m128i b) {
  265|       |#if defined(__GNUC__) && !defined(__clang__)
  266|       |  if (std::is_unsigned<char>::value) {
  267|       |    const __m128i mask = _mm_set1_epi8(0x80);
  268|       |    const __m128i diff = _mm_subs_epi8(b, a);
  269|       |    return _mm_cmpeq_epi8(_mm_and_si128(diff, mask), mask);
  270|       |  }
  271|       |#endif
  272|      2|  return _mm_cmpgt_epi8(a, b);
  273|      2|}

_ZN4absl12lts_2026052618container_internal21ShouldSampleNextTableEv:
  226|      2|inline bool ShouldSampleNextTable() {
  227|       |#if defined(ABSL_INTERNAL_HASHTABLEZ_SAMPLE)
  228|       |  if (ABSL_PREDICT_TRUE(--global_next_sample.next_sample > 0)) {
  229|       |    return false;
  230|       |  }
  231|       |  return true;
  232|       |#else
  233|      2|  return false;
  234|      2|#endif  // ABSL_INTERNAL_HASHTABLEZ_SAMPLE
  235|      2|}
_ZNK4absl12lts_2026052618container_internal20HashtablezInfoHandle9IsSampledEv:
  204|     10|  inline bool IsSampled() const { return false; }
_ZN4absl12lts_2026052618container_internal20HashtablezInfoHandle20RecordStorageChangedEmm:
  205|      2|  inline void RecordStorageChanged(size_t /*size*/, size_t /*capacity*/) {}
_ZN4absl12lts_2026052618container_internal20HashtablezInfoHandle16RecordInsertMissEmm:
  210|     40|                               size_t /*distance_from_desired*/) {}

_ZN4absl12lts_2026052623inlined_vector_internal7StorageINS0_14SourceLocationELm1ENSt3__19allocatorIS3_EEE21GetSizeAndIsAllocatedEv:
  365|  7.14k|  SizeType<A>& GetSizeAndIsAllocated() { return metadata_.template get<1>(); }
_ZN4absl12lts_2026052623inlined_vector_internal7StorageINS0_14SourceLocationELm1ENSt3__19allocatorIS3_EEE21DeallocateIfAllocatedEv:
  521|  3.57k|  void DeallocateIfAllocated() {
  522|  3.57k|    if (GetIsAllocated()) {
  ------------------
  |  Branch (522:9): [True: 0, False: 3.57k]
  ------------------
  523|      0|      MallocAdapter<A>::Deallocate(GetAllocator(), GetAllocatedData(),
  524|      0|                                   GetAllocatedCapacity());
  525|      0|    }
  526|  3.57k|  }
_ZNK4absl12lts_2026052623inlined_vector_internal7StorageINS0_14SourceLocationELm1ENSt3__19allocatorIS3_EEE14GetIsAllocatedEv:
  373|  7.14k|  bool GetIsAllocated() const { return GetSizeAndIsAllocated() & 1; }
_ZNK4absl12lts_2026052623inlined_vector_internal7StorageINS0_14SourceLocationELm1ENSt3__19allocatorIS3_EEE21GetSizeAndIsAllocatedEv:
  367|  10.7k|  const SizeType<A>& GetSizeAndIsAllocated() const {
  368|  10.7k|    return metadata_.template get<1>();
  369|  10.7k|  }
_ZN4absl12lts_2026052623inlined_vector_internal7StorageINS0_14SourceLocationELm1ENSt3__19allocatorIS3_EEE12GetAllocatorEv:
  420|  3.57k|  A& GetAllocator() { return metadata_.template get<0>(); }
_ZN4absl12lts_2026052623inlined_vector_internal7StorageINS0_14SourceLocationELm1ENSt3__19allocatorIS3_EEE14GetInlinedDataEv:
  397|  3.57k|  ABSL_ATTRIBUTE_NO_SANITIZE_CFI Pointer<A> GetInlinedData() {
  398|  3.57k|    return reinterpret_cast<Pointer<A>>(data_.inlined.inlined_data);
  399|  3.57k|  }
_ZNK4absl12lts_2026052623inlined_vector_internal7StorageINS0_14SourceLocationELm1ENSt3__19allocatorIS3_EEE7GetSizeEv:
  371|  3.57k|  SizeType<A> GetSize() const { return GetSizeAndIsAllocated() >> 1; }
_ZN4absl12lts_2026052623inlined_vector_internal7StorageINS0_14SourceLocationELm1ENSt3__19allocatorIS3_EEED2Ev:
  343|  3.57k|  ~Storage() {
  344|       |    // Fast path: if we are empty and not allocated, there's nothing to do.
  345|  3.57k|    if (GetSizeAndIsAllocated() == 0) {
  ------------------
  |  Branch (345:9): [True: 0, False: 3.57k]
  ------------------
  346|      0|      return;
  347|      0|    }
  348|       |
  349|       |    // Fast path: if no destructors need to be run and we know the allocator
  350|       |    // doesn't do anything fancy, then all we need to do is deallocate (and
  351|       |    // maybe not even that).
  352|  3.57k|    if (std::is_trivially_destructible<ValueType<A>>::value &&
  ------------------
  |  Branch (352:9): [True: 0, Folded]
  ------------------
  353|  3.57k|        std::is_same<A, std::allocator<ValueType<A>>>::value) {
  ------------------
  |  Branch (353:9): [True: 0, Folded]
  ------------------
  354|  3.57k|      DeallocateIfAllocated();
  355|  3.57k|      return;
  356|  3.57k|    }
  357|       |
  358|      0|    DestroyContents();
  359|      0|  }
_ZN4absl12lts_2026052623inlined_vector_internal7StorageINS0_14SourceLocationELm1ENSt3__19allocatorIS3_EEEC2Ev:
  338|  3.57k|  Storage() : metadata_(A(), /* size and is_allocated */ 0u) {}
_ZN4absl12lts_2026052623inlined_vector_internal7StorageINS0_14SourceLocationELm1ENSt3__19allocatorIS3_EEE11EmplaceBackIJRKS3_EEERS3_DpOT_:
  817|  3.57k|auto Storage<T, N, A>::EmplaceBack(Args&&... args) -> Reference<A> {
  818|  3.57k|  StorageView<A> storage_view = MakeStorageView();
  819|  3.57k|  const SizeType<A> n = storage_view.size;
  820|  3.57k|  if (ABSL_PREDICT_TRUE(n != storage_view.capacity)) {
  ------------------
  |  |  191|  3.57k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 3.57k, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 3.57k]
  |  |  |  Branch (191:57): [True: 3.57k, False: 0]
  |  |  ------------------
  ------------------
  821|       |    // Fast path; new element fits.
  822|  3.57k|    Pointer<A> last_ptr = storage_view.data + n;
  823|  3.57k|    AllocatorTraits<A>::construct(GetAllocator(), last_ptr,
  824|  3.57k|                                  std::forward<Args>(args)...);
  825|  3.57k|    AddSize(1);
  826|  3.57k|    return *last_ptr;
  827|  3.57k|  }
  828|       |  // TODO(b/173712035): Annotate with musttail attribute to prevent regression.
  829|      0|  return EmplaceBackSlow(std::forward<Args>(args)...);
  830|  3.57k|}
_ZN4absl12lts_2026052623inlined_vector_internal7StorageINS0_14SourceLocationELm1ENSt3__19allocatorIS3_EEE15MakeStorageViewEv:
  413|  3.57k|  StorageView<A> MakeStorageView() {
  414|  3.57k|    return GetIsAllocated() ? StorageView<A>{GetAllocatedData(), GetSize(),
  ------------------
  |  Branch (414:12): [True: 0, False: 3.57k]
  ------------------
  415|      0|                                             GetAllocatedCapacity()}
  416|  3.57k|                            : StorageView<A>{GetInlinedData(), GetSize(),
  417|  3.57k|                                             GetInlinedCapacity()};
  418|  3.57k|  }
_ZNK4absl12lts_2026052623inlined_vector_internal7StorageINS0_14SourceLocationELm1ENSt3__19allocatorIS3_EEE18GetInlinedCapacityEv:
  409|  3.57k|  SizeType<A> GetInlinedCapacity() const {
  410|  3.57k|    return static_cast<SizeType<A>>(kOptimalInlinedSize);
  411|  3.57k|  }
_ZN4absl12lts_2026052623inlined_vector_internal7StorageINS0_14SourceLocationELm1ENSt3__19allocatorIS3_EEE7AddSizeEm:
  475|  3.57k|  void AddSize(SizeType<A> count) {
  476|  3.57k|    GetSizeAndIsAllocated() += count << static_cast<SizeType<A>>(1);
  477|  3.57k|  }

_ZN4absl12lts_2026052618container_internal12raw_hash_mapINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEEC2Ev:
  107|      2|  raw_hash_map() {}

_ZN4absl12lts_2026052618container_internal17NextHashTableSeedEv:
  138|      2|uint16_t NextHashTableSeed() {
  139|      2|  static_assert(PerTableSeed::kBitCount <= 16);
  140|      2|  thread_local uint16_t seed =
  141|      2|      static_cast<uint16_t>(reinterpret_cast<uintptr_t>(&seed));
  142|      2|  seed += uint16_t{0xad53};
  143|      2|  return seed;
  144|      2|}
_ZN4absl12lts_2026052618container_internal17ClearBackingArrayERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPvb:
  670|      2|                       bool reuse) {
  671|      2|  ABSL_SWISSTABLE_ASSERT(c.capacity() > MaxSmallCapacity());
  ------------------
  |  |   62|      2|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  672|      2|  if (reuse) {
  ------------------
  |  Branch (672:7): [True: 2, False: 0]
  ------------------
  673|      2|    c.set_size_to_zero();
  674|      2|    ResetCtrl(c, policy.slot_size);
  675|      2|    ResetGrowthLeft(c);
  676|      2|    c.infoz().RecordStorageChanged(0, c.capacity());
  677|      2|  } else {
  678|      0|    ClearBackingArrayNoReuse(c, policy, alloc);
  679|      0|  }
  680|      2|}
_ZN4absl12lts_2026052618container_internal24PrepareInsertSmallNonSooERNS1_12CommonFieldsERKNS1_15PolicyFunctionsENS0_11FunctionRefIFmmEEE:
 1541|      4|    absl::FunctionRef<size_t(size_t)> get_hash) {
 1542|      4|  ABSL_SWISSTABLE_ASSERT(common.is_small());
  ------------------
  |  |   62|      4|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1543|      4|  ABSL_SWISSTABLE_ASSERT(!policy.soo_enabled);
  ------------------
  |  |   62|      4|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1544|      4|  if (common.capacity() == 1) {
  ------------------
  |  Branch (1544:7): [True: 2, False: 2]
  ------------------
 1545|      2|    if (common.empty()) {
  ------------------
  |  Branch (1545:9): [True: 0, False: 2]
  ------------------
 1546|      0|      IncrementSmallSizeNonSoo(common, policy);
 1547|      0|      if (common.has_infoz()) {
  ------------------
  |  Branch (1547:11): [True: 0, False: 0]
  ------------------
 1548|      0|        common.infoz().RecordInsertMiss(get_hash(common.seed().seed()),
 1549|      0|                                        /*distance_from_desired=*/0);
 1550|      0|      }
 1551|      0|      return {SooControl(), common.slot_array()};
 1552|      2|    } else {
 1553|      2|      return Grow1To3AndPrepareInsert(common, policy, get_hash);
 1554|      2|    }
 1555|      2|  }
 1556|       |
 1557|       |  // Growing from 0 to 1 capacity.
 1558|      2|  ABSL_SWISSTABLE_ASSERT(common.capacity() == 0);
  ------------------
  |  |   62|      2|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1559|      2|  constexpr size_t kNewCapacity = 1;
 1560|       |
 1561|      2|  common.set_capacity(kNewCapacity);
 1562|      2|  HashtablezInfoHandle infoz;
 1563|      2|  const bool should_sample =
 1564|      2|      policy.is_hashtablez_eligible && ShouldSampleNextTable();
  ------------------
  |  Branch (1564:7): [True: 2, False: 0]
  |  Branch (1564:40): [True: 0, False: 2]
  ------------------
 1565|      2|  if (ABSL_PREDICT_FALSE(should_sample)) {
  ------------------
  |  |  190|      2|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 2]
  |  |  |  Branch (190:49): [Folded, False: 2]
  |  |  |  Branch (190:58): [True: 0, False: 2]
  |  |  ------------------
  ------------------
 1566|      0|    infoz = ForcedTrySample(policy.slot_size, policy.key_size,
 1567|      0|                            policy.value_size, policy.soo_capacity());
 1568|      0|  }
 1569|      2|  const bool has_infoz = infoz.IsSampled();
 1570|      2|  void* alloc = policy.get_char_alloc(common);
 1571|       |
 1572|      2|  const auto [new_ctrl, new_slots] =
 1573|      2|      AllocBackingArray(common, policy, kNewCapacity, has_infoz, alloc);
 1574|      2|  common.set_control(new_ctrl);
 1575|      2|  common.set_slots(new_slots);
 1576|       |
 1577|      2|  static_assert(NextCapacity(0) == 1);
 1578|      2|  PrepareInsertCommon(common);
 1579|       |
 1580|      2|  if (ABSL_PREDICT_FALSE(has_infoz)) {
  ------------------
  |  |  190|      2|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 2]
  |  |  |  Branch (190:49): [Folded, False: 2]
  |  |  |  Branch (190:58): [True: 0, False: 2]
  |  |  ------------------
  ------------------
 1581|      0|    common.generate_new_seed(/*has_infoz=*/true);
 1582|      0|    ReportSingleGroupTableGrowthToInfoz(common, infoz,
 1583|      0|                                        get_hash(common.seed().seed()));
 1584|      0|  }
 1585|      2|  return {SooControl(), new_slots};
 1586|      4|}
_ZN4absl12lts_2026052618container_internal19GetRefForEmptyClassERNS1_12CommonFieldsE:
 1752|     12|void* GetRefForEmptyClass(CommonFields& common) {
 1753|       |  // Empty base optimization typically make the empty base class address to be
 1754|       |  // the same as the first address of the derived class object.
 1755|       |  // But we generally assume that for empty classes we can return any valid
 1756|       |  // pointer.
 1757|     12|  return &common;
 1758|     12|}
_ZN4absl12lts_2026052618container_internal18PrepareInsertLargeERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEmNS1_18NonIterableBitMaskIjLi16ELi0EEENS1_8FindInfoE:
 2012|     46|                          FindInfo target_group) {
 2013|       |  // NOLINTNEXTLINE(misc-static-assert)
 2014|       |  ABSL_SWISSTABLE_ASSERT(!SwisstableGenerationsEnabled());
  ------------------
  |  |   62|     46|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2015|     46|  return PrepareInsertLargeImpl(common, policy, hash, mask_empty, target_group);
 2016|     46|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_119Resize1To3NewOffsetEmNS1_16PerTableSeedImplIhEE:
  107|      2|size_t Resize1To3NewOffset(size_t hash, PerTableSeed seed) {
  108|       |  // After resize from capacity 1 to 3, we always have exactly the slot with
  109|       |  // index 1 occupied, so we need to insert either at index 0 or index 2.
  110|      2|  static_assert(SooSlotIndex() == 1);
  111|      2|  return SingleGroupTableH1(hash, seed) & 2;
  112|      2|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_118SingleGroupTableH1EmNS1_16PerTableSeedImplIhEE:
  102|      6|size_t SingleGroupTableH1(size_t hash, PerTableSeed seed) {
  103|      6|  return hash ^ seed.seed();
  104|      6|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_111SlotAddressEPvmm:
  116|      2|inline void* SlotAddress(void* slot_array, size_t slot, size_t slot_size) {
  117|      2|  return static_cast<void*>(static_cast<char*>(slot_array) +
  118|      2|                            (slot * slot_size));
  119|      2|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_119PrepareInsertCommonERNS1_12CommonFieldsE:
  335|     50|void PrepareInsertCommon(CommonFields& common) {
  336|     50|  common.increment_size();
  337|     50|  common.maybe_increment_generation_on_insert();
  338|     50|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_135InitializeThreeElementsControlBytesEhhmPNS1_6ctrl_tE:
  557|      2|    h2_t orig_h2, h2_t new_h2, size_t new_offset, ctrl_t* new_ctrl) {
  558|      2|  static constexpr size_t kNewCapacity = NextCapacity(SooCapacity());
  559|      2|  static_assert(kNewCapacity == 3);
  560|      2|  static_assert(is_single_group(kNewCapacity));
  561|      2|  static_assert(SooSlotIndex() == 1);
  562|      2|  ABSL_SWISSTABLE_ASSERT(new_offset == 0 || new_offset == 2);
  ------------------
  |  |   62|      2|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  563|       |
  564|      2|  static constexpr uint64_t kEmptyXorSentinel =
  565|      2|      static_cast<uint8_t>(ctrl_t::kEmpty) ^
  566|      2|      static_cast<uint8_t>(ctrl_t::kSentinel);
  567|      2|  static constexpr uint64_t kEmpty64 = static_cast<uint8_t>(ctrl_t::kEmpty);
  568|      2|  static constexpr size_t kMirroredSooSlotIndex =
  569|      2|      SooSlotIndex() + kNewCapacity + 1;
  570|       |  // The first 8 bytes, where SOO slot original and mirrored positions are
  571|       |  // replaced with 0.
  572|       |  // Result will look like: E0ESE0EE
  573|      2|  static constexpr uint64_t kFirstCtrlBytesWithZeroes =
  574|      2|      k8EmptyBytes ^ (kEmpty64 << (8 * SooSlotIndex())) ^
  575|      2|      (kEmptyXorSentinel << (8 * kNewCapacity)) ^
  576|      2|      (kEmpty64 << (8 * kMirroredSooSlotIndex));
  577|       |
  578|      2|  const uint64_t soo_h2 = static_cast<uint64_t>(orig_h2);
  579|      2|  const uint64_t new_h2_xor_empty =
  580|      2|      static_cast<uint64_t>(new_h2 ^ static_cast<uint8_t>(ctrl_t::kEmpty));
  581|       |  // Fill the original and mirrored bytes for SOO slot.
  582|       |  // Result will look like:
  583|       |  // EHESEHEE
  584|       |  // Where H = soo_h2, E = kEmpty, S = kSentinel.
  585|      2|  uint64_t first_ctrl_bytes =
  586|      2|      ((soo_h2 << (8 * SooSlotIndex())) | kFirstCtrlBytesWithZeroes) |
  587|      2|      (soo_h2 << (8 * kMirroredSooSlotIndex));
  588|       |  // Replace original and mirrored empty bytes for the new position.
  589|       |  // Result for new_offset 0 will look like:
  590|       |  // NHESNHEE
  591|       |  // Where H = soo_h2, N = H2(new_hash), E = kEmpty, S = kSentinel.
  592|       |  // Result for new_offset 2 will look like:
  593|       |  // EHNSEHNE
  594|      2|  first_ctrl_bytes ^= (new_h2_xor_empty << (8 * new_offset));
  595|      2|  size_t new_mirrored_offset = new_offset + kNewCapacity + 1;
  596|      2|  first_ctrl_bytes ^= (new_h2_xor_empty << (8 * new_mirrored_offset));
  597|       |
  598|       |  // Fill last bytes with kEmpty.
  599|      2|  std::memset(new_ctrl + kNewCapacity, static_cast<int8_t>(ctrl_t::kEmpty),
  600|      2|              Group::kWidth);
  601|       |  // Overwrite the first 8 bytes with first_ctrl_bytes.
  602|      2|  absl::little_endian::Store64(new_ctrl, first_ctrl_bytes);
  603|       |
  604|       |  // Example for group size 16:
  605|       |  // new_ctrl after 1st memset =      ???EEEEEEEEEEEEEEEE
  606|       |  // new_offset 0:
  607|       |  // new_ctrl after 2nd store  =      NHESNHEEEEEEEEEEEEE
  608|       |  // new_offset 2:
  609|       |  // new_ctrl after 2nd store  =      EHNSEHNEEEEEEEEEEEE
  610|       |
  611|       |  // Example for group size 8:
  612|       |  // new_ctrl after 1st memset =      ???EEEEEEEE
  613|       |  // new_offset 0:
  614|       |  // new_ctrl after 2nd store  =      NHESNHEEEEE
  615|       |  // new_offset 2:
  616|       |  // new_ctrl after 2nd store  =      EHNSEHNEEEE
  617|      2|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_17SetCtrlERKNS1_12CommonFieldsEmNS1_6ctrl_tEm:
  357|     40|                    size_t slot_size) {
  358|       |  ABSL_SWISSTABLE_ASSERT(!c.is_small());
  ------------------
  |  |   62|     40|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  359|     40|  DoSanitizeOnSetCtrl(c, i, h, slot_size);
  360|     40|  ctrl_t* ctrl = c.control();
  361|     40|  ctrl[i] = h;
  362|     40|  ctrl[((i - NumClonedBytes()) & c.capacity()) +
  363|     40|       (NumClonedBytes() & c.capacity())] = h;
  364|     40|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_119DoSanitizeOnSetCtrlERKNS1_12CommonFieldsEmNS1_6ctrl_tEm:
  342|     46|                                size_t slot_size) {
  343|     46|  ABSL_SWISSTABLE_ASSERT(i < c.capacity());
  ------------------
  |  |   62|     46|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  344|     46|  auto* slot_i = static_cast<const char*>(c.slot_array()) + i * slot_size;
  345|     46|  if (IsFull(h)) {
  ------------------
  |  Branch (345:7): [True: 46, False: 0]
  ------------------
  346|     46|    SanitizerUnpoisonMemoryRegion(slot_i, slot_size);
  347|     46|  } else {
  348|      0|    SanitizerPoisonMemoryRegion(slot_i, slot_size);
  349|      0|  }
  350|     46|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_119SetCtrlInLargeTableERKNS1_12CommonFieldsEmNS1_6ctrl_tEm:
  390|      2|                                size_t slot_size) {
  391|       |  ABSL_SWISSTABLE_ASSERT(c.capacity() >= Group::kWidth - 1);
  ------------------
  |  |   62|      2|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  392|      2|  DoSanitizeOnSetCtrl(c, i, h, slot_size);
  393|      2|  ctrl_t* ctrl = c.control();
  394|      2|  ctrl[i] = h;
  395|      2|  ctrl[((i - NumClonedBytes()) & c.capacity()) + NumClonedBytes()] = h;
  396|      2|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_19ResetCtrlERNS1_12CommonFieldsEm:
  532|      2|void ResetCtrl(CommonFields& common, size_t slot_size) {
  533|      2|  const size_t capacity = common.capacity();
  534|      2|  ctrl_t* ctrl = common.control();
  535|      2|  static constexpr size_t kTwoGroupCapacity = 2 * Group::kWidth - 1;
  536|      2|  if (ABSL_PREDICT_TRUE(capacity <= kTwoGroupCapacity)) {
  ------------------
  |  |  191|      2|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 2, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 2]
  |  |  |  Branch (191:57): [True: 2, False: 0]
  |  |  ------------------
  ------------------
  537|      2|    if (IsSmallCapacity(capacity)) return;
  ------------------
  |  Branch (537:9): [True: 0, False: 2]
  ------------------
  538|      2|    std::memset(ctrl, static_cast<int8_t>(ctrl_t::kEmpty), Group::kWidth);
  539|      2|    std::memset(ctrl + capacity, static_cast<int8_t>(ctrl_t::kEmpty),
  540|      2|                Group::kWidth);
  541|      2|    if (capacity == kTwoGroupCapacity) {
  ------------------
  |  Branch (541:9): [True: 2, False: 0]
  ------------------
  542|      2|      std::memset(ctrl + Group::kWidth, static_cast<int8_t>(ctrl_t::kEmpty),
  543|      2|                  Group::kWidth);
  544|      2|    }
  545|      2|  } else {
  546|      0|    std::memset(ctrl, static_cast<int8_t>(ctrl_t::kEmpty),
  547|      0|                capacity + 1 + NumClonedBytes());
  548|      0|  }
  549|      2|  ctrl[capacity] = ctrl_t::kSentinel;
  550|      2|  SanitizerPoisonMemoryRegion(common.slot_array(), slot_size * capacity);
  551|      2|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_115ResetGrowthLeftERNS1_12CommonFieldsE:
  306|      2|void ResetGrowthLeft(CommonFields& common) {
  307|      2|  ResetGrowthLeft(common.growth_info(), common.capacity(), common.size());
  308|      2|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_115ResetGrowthLeftERNS1_10GrowthInfoEmm:
  302|      8|void ResetGrowthLeft(GrowthInfo& growth_info, size_t capacity, size_t size) {
  303|      8|  growth_info.InitGrowthLeftNoDeleted(CapacityToGrowth(capacity) - size);
  304|      8|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_117AllocBackingArrayERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEmbPv:
  776|     10|                                   void* alloc) {
  777|     10|  RawHashSetLayout layout(new_capacity, policy.slot_size, policy.slot_align,
  778|     10|                          has_infoz);
  779|       |  // Perform a direct call in the common case to allow for profile-guided
  780|       |  // heap optimization (PGHO) to understand which allocation function is used.
  781|     10|  constexpr size_t kDefaultAlignment = BackingArrayAlignment(alignof(size_t));
  782|     10|  char* mem = static_cast<char*>(
  783|     10|      ABSL_PREDICT_TRUE(
  ------------------
  |  |  191|     10|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 10, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 10]
  |  |  |  Branch (191:57): [True: 10, False: 0]
  |  |  ------------------
  ------------------
  784|     10|          policy.alloc ==
  785|     10|          (&AllocateBackingArray<kDefaultAlignment, std::allocator<char>>))
  786|     10|          ? AllocateBackingArray<kDefaultAlignment, std::allocator<char>>(
  787|     10|                alloc, layout.alloc_size())
  788|     10|          : policy.alloc(alloc, layout.alloc_size()));
  789|     10|  const GenerationType old_generation = common.generation();
  790|     10|  common.set_generation_ptr(
  791|     10|      reinterpret_cast<GenerationType*>(mem + layout.generation_offset()));
  792|     10|  common.set_generation(NextGeneration(old_generation));
  793|       |
  794|     10|  return {reinterpret_cast<ctrl_t*>(mem + layout.control_offset()),
  795|     10|          mem + layout.slot_offset()};
  796|     10|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_124Grow1To3AndPrepareInsertERNS1_12CommonFieldsERKNS1_15PolicyFunctionsENS0_11FunctionRefIFmmEEE:
 1415|      2|    absl::FunctionRef<size_t(size_t)> get_hash) {
 1416|       |  // TODO(b/413062340): Refactor to reuse more code with
 1417|       |  // GrowSooTableToNextCapacityAndPrepareInsert.
 1418|      2|  ABSL_SWISSTABLE_ASSERT(common.capacity() == 1);
  ------------------
  |  |   62|      2|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1419|      2|  ABSL_SWISSTABLE_ASSERT(!common.empty());
  ------------------
  |  |   62|      2|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1420|      2|  ABSL_SWISSTABLE_ASSERT(!policy.soo_enabled);
  ------------------
  |  |   62|      2|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1421|      2|  constexpr size_t kOldCapacity = 1;
 1422|      2|  constexpr size_t kNewCapacity = NextCapacity(kOldCapacity);
 1423|      2|  ctrl_t* old_ctrl = common.control();
 1424|      2|  void* old_slots = common.slot_array();
 1425|       |
 1426|      2|  const size_t slot_size = policy.slot_size;
 1427|      2|  const size_t slot_align = policy.slot_align;
 1428|      2|  void* alloc = policy.get_char_alloc(common);
 1429|      2|  HashtablezInfoHandle infoz = common.infoz();
 1430|      2|  const bool has_infoz = infoz.IsSampled();
 1431|      2|  common.set_capacity(kNewCapacity);
 1432|       |
 1433|      2|  const auto [new_ctrl, new_slots] =
 1434|      2|      AllocBackingArray(common, policy, kNewCapacity, has_infoz, alloc);
 1435|      2|  common.set_control(new_ctrl);
 1436|      2|  common.set_slots(new_slots);
 1437|      2|  SanitizerPoisonMemoryRegion(new_slots, kNewCapacity * slot_size);
 1438|       |
 1439|      2|  if (ABSL_PREDICT_TRUE(!has_infoz)) {
  ------------------
  |  |  191|      2|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 2, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 2]
  |  |  |  Branch (191:57): [True: 2, False: 0]
  |  |  ------------------
  ------------------
 1440|       |    // When we're sampled, we already have a seed.
 1441|      2|    common.generate_new_seed(/*has_infoz=*/false);
 1442|      2|  }
 1443|      2|  const size_t new_hash = get_hash(common.seed().seed());
 1444|      2|  h2_t new_h2 = H2(new_hash);
 1445|      2|  size_t orig_hash =
 1446|      2|      policy.hash_slot(policy.hash_fn(common), old_slots, common.seed().seed());
 1447|      2|  size_t offset = Resize1To3NewOffset(new_hash, common.seed());
 1448|      2|  InitializeThreeElementsControlBytes(H2(orig_hash), new_h2, offset, new_ctrl);
 1449|       |
 1450|      2|  void* old_element_target = NextSlot(new_slots, slot_size);
 1451|      2|  SanitizerUnpoisonMemoryRegion(old_element_target, slot_size);
 1452|      2|  policy.transfer_n(&common, old_element_target, old_slots, 1);
 1453|       |
 1454|      2|  void* new_element_target_slot = SlotAddress(new_slots, offset, slot_size);
 1455|      2|  SanitizerUnpoisonMemoryRegion(new_element_target_slot, slot_size);
 1456|       |
 1457|      2|  policy.dealloc(alloc, kOldCapacity, old_ctrl, slot_size, slot_align,
 1458|      2|                 has_infoz);
 1459|      2|  PrepareInsertCommon(common);
 1460|      2|  ABSL_SWISSTABLE_ASSERT(common.size() == 2);
  ------------------
  |  |   62|      2|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1461|      2|  GetGrowthInfoFromControl(new_ctrl).InitGrowthLeftNoDeleted(kNewCapacity - 2);
 1462|       |
 1463|      2|  if (ABSL_PREDICT_FALSE(has_infoz)) {
  ------------------
  |  |  190|      2|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 2]
  |  |  |  Branch (190:49): [Folded, False: 2]
  |  |  |  Branch (190:58): [True: 0, False: 2]
  |  |  ------------------
  ------------------
 1464|      0|    ReportSingleGroupTableGrowthToInfoz(common, infoz, new_hash);
 1465|      0|  }
 1466|      2|  return {new_ctrl + offset, new_element_target_slot};
 1467|      2|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_18NextSlotEPvmm:
  123|      6|inline void* NextSlot(void* slot, size_t slot_size, size_t i = 1) {
  124|      6|  return reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(slot) +
  125|      6|                                 slot_size * i);
  126|      6|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_125SetCtrlInSingleGroupTableERKNS1_12CommonFieldsEmhm:
  383|      4|                                      size_t slot_size) {
  384|      4|  SetCtrlInSingleGroupTable(c, i, static_cast<ctrl_t>(h), slot_size);
  385|      4|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_125SetCtrlInSingleGroupTableERKNS1_12CommonFieldsEmNS1_6ctrl_tEm:
  373|      4|                                      size_t slot_size) {
  374|      4|  ABSL_SWISSTABLE_ASSERT(!c.is_small());
  ------------------
  |  |   62|      4|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  375|       |  ABSL_SWISSTABLE_ASSERT(is_single_group(c.capacity()));
  ------------------
  |  |   62|      4|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  376|      4|  DoSanitizeOnSetCtrl(c, i, h, slot_size);
  377|      4|  ctrl_t* ctrl = c.control();
  378|      4|  ctrl[i] = h;
  379|      4|  ctrl[i + c.capacity() + 1] = h;
  380|      4|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_17SetCtrlERKNS1_12CommonFieldsEmhm:
  366|     40|inline void SetCtrl(const CommonFields& c, size_t i, h2_t h, size_t slot_size) {
  367|     40|  SetCtrl(c, i, static_cast<ctrl_t>(h), slot_size);
  368|     40|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_122PrepareInsertLargeImplERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEmNS1_18NonIterableBitMaskIjLi16ELi0EEENS1_8FindInfoE:
 1990|     46|                              FindInfo target_group) {
 1991|     46|  ABSL_SWISSTABLE_ASSERT(!common.is_small());
  ------------------
  |  |   62|     46|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1992|     46|  const GrowthInfo growth_info = common.growth_info();
 1993|       |  // When there are no deleted slots in the table
 1994|       |  // and growth_left is positive, we can insert at the first
 1995|       |  // empty slot in the probe sequence (target).
 1996|     46|  if (ABSL_PREDICT_FALSE(!growth_info.HasNoDeletedAndGrowthLeft())) {
  ------------------
  |  |  190|     46|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 6, False: 40]
  |  |  |  Branch (190:49): [Folded, False: 46]
  |  |  |  Branch (190:58): [True: 6, False: 40]
  |  |  ------------------
  ------------------
 1997|      6|    return PrepareInsertLargeSlow(common, policy, hash);
 1998|      6|  }
 1999|     40|  PrepareInsertCommon(common);
 2000|     40|  common.growth_info().OverwriteEmptyAsFull();
 2001|     40|  target_group.offset += mask_empty.LowestBitSet();
 2002|     40|  target_group.offset &= common.capacity();
 2003|     40|  SetCtrl(common, target_group.offset, H2(hash), policy.slot_size);
 2004|     40|  common.infoz().RecordInsertMiss(hash, target_group.probe_length);
 2005|     40|  return target_group.offset;
 2006|     46|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_122PrepareInsertLargeSlowERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEm:
 1653|      6|                              size_t hash) {
 1654|      6|  const GrowthInfo growth_info = common.growth_info();
 1655|      6|  ABSL_SWISSTABLE_ASSERT(!growth_info.HasNoDeletedAndGrowthLeft());
  ------------------
  |  |   62|      6|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1656|      6|  if (ABSL_PREDICT_TRUE(growth_info.HasNoGrowthLeftAndNoDeleted())) {
  ------------------
  |  |  191|      6|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 6, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 6]
  |  |  |  Branch (191:57): [True: 6, False: 0]
  |  |  ------------------
  ------------------
 1657|       |    // Table without deleted slots (>95% cases) that needs to be resized.
 1658|      6|    ABSL_SWISSTABLE_ASSERT(growth_info.HasNoDeleted() &&
  ------------------
  |  |   62|      6|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1659|      6|                           growth_info.GetGrowthLeft() == 0);
 1660|      6|    return GrowToNextCapacityAndPrepareInsert(common, policy, hash);
 1661|      6|  }
 1662|      0|  if (ABSL_PREDICT_FALSE(growth_info.HasNoGrowthLeftAssumingMayHaveDeleted())) {
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1663|       |    // Table with deleted slots that needs to be rehashed or resized.
 1664|      0|    return RehashOrGrowToNextCapacityAndPrepareInsert(common, policy, hash);
 1665|      0|  }
 1666|       |  // Table with deleted slots that has space for the inserting element.
 1667|      0|  FindInfo target = find_first_non_full(common, hash);
 1668|      0|  PrepareInsertCommon(common);
 1669|      0|  common.growth_info().OverwriteControlAsFull(common.control()[target.offset]);
 1670|      0|  SetCtrlInLargeTable(common, target.offset, H2(hash), policy.slot_size);
 1671|      0|  common.infoz().RecordInsertMiss(hash, target.probe_length);
 1672|      0|  return target.offset;
 1673|      0|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_134GrowToNextCapacityAndPrepareInsertERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEm:
 1473|      6|    size_t new_hash) {
 1474|      6|  ABSL_SWISSTABLE_ASSERT(common.growth_left() == 0);
  ------------------
  |  |   62|      6|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1475|      6|  const size_t old_capacity = common.capacity();
 1476|      6|  ABSL_SWISSTABLE_ASSERT(old_capacity > policy.soo_capacity());
  ------------------
  |  |   62|      6|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1477|      6|  ABSL_SWISSTABLE_ASSERT(!IsSmallCapacity(old_capacity));
  ------------------
  |  |   62|      6|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1478|       |
 1479|      6|  const size_t new_capacity = NextCapacity(old_capacity);
 1480|      6|  ctrl_t* old_ctrl = common.control();
 1481|      6|  void* old_slots = common.slot_array();
 1482|       |
 1483|      6|  common.set_capacity(new_capacity);
 1484|      6|  const size_t slot_size = policy.slot_size;
 1485|      6|  const size_t slot_align = policy.slot_align;
 1486|      6|  void* alloc = policy.get_char_alloc(common);
 1487|      6|  HashtablezInfoHandle infoz = common.infoz();
 1488|      6|  const bool has_infoz = infoz.IsSampled();
 1489|       |
 1490|      6|  const auto [new_ctrl, new_slots] =
 1491|      6|      AllocBackingArray(common, policy, new_capacity, has_infoz, alloc);
 1492|      6|  common.set_control(new_ctrl);
 1493|      6|  common.set_slots(new_slots);
 1494|      6|  SanitizerPoisonMemoryRegion(new_slots, new_capacity * slot_size);
 1495|       |
 1496|      6|  h2_t new_h2 = H2(new_hash);
 1497|      6|  size_t total_probe_length = 0;
 1498|      6|  FindInfo find_info;
 1499|      6|  if (ABSL_PREDICT_TRUE(is_single_group(new_capacity))) {
  ------------------
  |  |  191|      6|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 4, False: 2]
  |  |  |  Branch (191:48): [Folded, False: 6]
  |  |  |  Branch (191:57): [True: 4, False: 2]
  |  |  ------------------
  ------------------
 1500|      4|    size_t offset;
 1501|      4|    GrowIntoSingleGroupShuffleControlBytes(old_ctrl, old_capacity, new_ctrl,
 1502|      4|                                           new_capacity);
 1503|       |    // We put the new element either at the beginning or at the end of the
 1504|       |    // table with approximately equal probability.
 1505|      4|    offset =
 1506|      4|        SingleGroupTableH1(new_hash, common.seed()) & 1 ? 0 : new_capacity - 1;
  ------------------
  |  Branch (1506:9): [True: 4, False: 0]
  ------------------
 1507|       |
 1508|      4|    ABSL_SWISSTABLE_ASSERT(IsEmpty(new_ctrl[offset]));
  ------------------
  |  |   62|      4|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1509|      4|    SetCtrlInSingleGroupTable(common, offset, new_h2, policy.slot_size);
 1510|      4|    find_info = FindInfo{offset, 0};
 1511|       |    // Single group tables have all slots full on resize. So we can transfer
 1512|       |    // all slots without checking the control bytes.
 1513|      4|    ABSL_SWISSTABLE_ASSERT(common.size() == old_capacity);
  ------------------
  |  |   62|      4|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1514|      4|    void* target = NextSlot(new_slots, slot_size);
 1515|      4|    SanitizerUnpoisonMemoryRegion(target, old_capacity * slot_size);
 1516|      4|    policy.transfer_n(&common, target, old_slots, old_capacity);
 1517|      4|  } else {
 1518|      2|    total_probe_length =
 1519|      2|        GrowToNextCapacityDispatch(common, policy, old_ctrl, old_slots);
 1520|      2|    find_info = find_first_non_full(common, new_hash);
 1521|      2|    SetCtrlInLargeTable(common, find_info.offset, new_h2, policy.slot_size);
 1522|      2|  }
 1523|      6|  ABSL_SWISSTABLE_ASSERT(old_capacity > policy.soo_capacity());
  ------------------
  |  |   62|      6|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1524|      6|  (*policy.dealloc)(alloc, old_capacity, old_ctrl, slot_size, slot_align,
 1525|      6|                    has_infoz);
 1526|      6|  PrepareInsertCommon(common);
 1527|      6|  ResetGrowthLeft(GetGrowthInfoFromControl(new_ctrl), new_capacity,
 1528|      6|                  common.size());
 1529|       |
 1530|      6|  if (ABSL_PREDICT_FALSE(has_infoz)) {
  ------------------
  |  |  190|      6|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 6]
  |  |  |  Branch (190:49): [Folded, False: 6]
  |  |  |  Branch (190:58): [True: 0, False: 6]
  |  |  ------------------
  ------------------
 1531|      0|    ReportGrowthToInfoz(common, infoz, new_hash, total_probe_length,
 1532|      0|                        find_info.probe_length);
 1533|      0|  }
 1534|      6|  return find_info.offset;
 1535|      6|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_138GrowIntoSingleGroupShuffleControlBytesEPNS1_6ctrl_tEmS4_m:
  957|      4|                                            size_t new_capacity) {
  958|      4|  ABSL_SWISSTABLE_ASSERT(is_single_group(new_capacity));
  ------------------
  |  |   62|      4|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  959|      4|  constexpr size_t kHalfWidth = Group::kWidth / 2;
  960|      4|  ABSL_ASSUME(old_capacity < kHalfWidth);
  ------------------
  |  |  271|      4|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
  961|      4|  ABSL_ASSUME(old_capacity > 0);
  ------------------
  |  |  271|      4|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
  962|      4|  static_assert(Group::kWidth == 8 || Group::kWidth == 16,
  963|      4|                "Group size is not supported.");
  964|       |
  965|       |  // NOTE: operations are done with compile time known size = 8.
  966|       |  // Compiler optimizes that into single ASM operation.
  967|       |
  968|       |  // Load the bytes from old_capacity. This contains
  969|       |  // - the sentinel byte
  970|       |  // - all the old control bytes
  971|       |  // - the rest is filled with kEmpty bytes
  972|       |  // Example:
  973|       |  // old_ctrl =     012S012EEEEEEEEE...
  974|       |  // copied_bytes = S012EEEE
  975|      4|  uint64_t copied_bytes = absl::little_endian::Load64(old_ctrl + old_capacity);
  976|       |
  977|       |  // We change the sentinel byte to kEmpty before storing to both the start of
  978|       |  // the new_ctrl, and past the end of the new_ctrl later for the new cloned
  979|       |  // bytes. Note that this is faster than setting the sentinel byte to kEmpty
  980|       |  // after the copy directly in new_ctrl because we are limited on store
  981|       |  // bandwidth.
  982|      4|  static constexpr uint64_t kEmptyXorSentinel =
  983|      4|      static_cast<uint8_t>(ctrl_t::kEmpty) ^
  984|      4|      static_cast<uint8_t>(ctrl_t::kSentinel);
  985|       |
  986|       |  // Replace the first byte kSentinel with kEmpty.
  987|       |  // Resulting bytes will be shifted by one byte old control blocks.
  988|       |  // Example:
  989|       |  // old_ctrl = 012S012EEEEEEEEE...
  990|       |  // before =   S012EEEE
  991|       |  // after  =   E012EEEE
  992|      4|  copied_bytes ^= kEmptyXorSentinel;
  993|       |
  994|      4|  if (Group::kWidth == 8) {
  ------------------
  |  Branch (994:7): [Folded, False: 4]
  ------------------
  995|       |    // With group size 8, we can grow with two write operations.
  996|      0|    ABSL_SWISSTABLE_ASSERT(old_capacity < 8 &&
  ------------------
  |  |   62|      0|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  997|      0|                           "old_capacity is too large for group size 8");
  998|      0|    absl::little_endian::Store64(new_ctrl, copied_bytes);
  999|       |
 1000|      0|    static constexpr uint64_t kSentinal64 =
 1001|      0|        static_cast<uint8_t>(ctrl_t::kSentinel);
 1002|       |
 1003|       |    // Prepend kSentinel byte to the beginning of copied_bytes.
 1004|       |    // We have maximum 3 non-empty bytes at the beginning of copied_bytes for
 1005|       |    // group size 8.
 1006|       |    // Example:
 1007|       |    // old_ctrl = 012S012EEEE
 1008|       |    // before =   E012EEEE
 1009|       |    // after  =   SE012EEE
 1010|      0|    copied_bytes = (copied_bytes << 8) ^ kSentinal64;
 1011|      0|    absl::little_endian::Store64(new_ctrl + new_capacity, copied_bytes);
 1012|       |    // Example for capacity 3:
 1013|       |    // old_ctrl = 012S012EEEE
 1014|       |    // After the first store:
 1015|       |    //           >!
 1016|       |    // new_ctrl = E012EEEE???????
 1017|       |    // After the second store:
 1018|       |    //                  >!
 1019|       |    // new_ctrl = E012EEESE012EEE
 1020|      0|    return;
 1021|      0|  }
 1022|       |
 1023|      4|  ABSL_SWISSTABLE_ASSERT(Group::kWidth == 16);  // NOLINT(misc-static-assert)
  ------------------
  |  |   62|      4|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1024|       |
 1025|       |  // Fill the second half of the main control bytes with kEmpty.
 1026|       |  // For small capacity that may write into mirrored control bytes.
 1027|       |  // It is fine as we will overwrite all the bytes later.
 1028|      4|  std::memset(new_ctrl + kHalfWidth, static_cast<int8_t>(ctrl_t::kEmpty),
 1029|      4|              kHalfWidth);
 1030|       |  // Fill the second half of the mirrored control bytes with kEmpty.
 1031|      4|  std::memset(new_ctrl + new_capacity + kHalfWidth,
 1032|      4|              static_cast<int8_t>(ctrl_t::kEmpty), kHalfWidth);
 1033|       |  // Copy the first half of the non-mirrored control bytes.
 1034|      4|  absl::little_endian::Store64(new_ctrl, copied_bytes);
 1035|      4|  new_ctrl[new_capacity] = ctrl_t::kSentinel;
 1036|       |  // Copy the first half of the mirrored control bytes.
 1037|      4|  absl::little_endian::Store64(new_ctrl + new_capacity + 1, copied_bytes);
 1038|       |
 1039|       |  // Example for growth capacity 1->3:
 1040|       |  // old_ctrl =                  0S0EEEEEEEEEEEEEE
 1041|       |  // new_ctrl at the end =       E0ESE0EEEEEEEEEEEEE
 1042|       |  //                                    >!
 1043|       |  // new_ctrl after 1st memset = ????????EEEEEEEE???
 1044|       |  //                                       >!
 1045|       |  // new_ctrl after 2nd memset = ????????EEEEEEEEEEE
 1046|       |  //                            >!
 1047|       |  // new_ctrl after 1st store =  E0EEEEEEEEEEEEEEEEE
 1048|       |  // new_ctrl after kSentinel =  E0ESEEEEEEEEEEEEEEE
 1049|       |  //                                >!
 1050|       |  // new_ctrl after 2nd store =  E0ESE0EEEEEEEEEEEEE
 1051|       |
 1052|       |  // Example for growth capacity 3->7:
 1053|       |  // old_ctrl =                  012S012EEEEEEEEEEEE
 1054|       |  // new_ctrl at the end =       E012EEESE012EEEEEEEEEEE
 1055|       |  //                                    >!
 1056|       |  // new_ctrl after 1st memset = ????????EEEEEEEE???????
 1057|       |  //                                           >!
 1058|       |  // new_ctrl after 2nd memset = ????????EEEEEEEEEEEEEEE
 1059|       |  //                            >!
 1060|       |  // new_ctrl after 1st store =  E012EEEEEEEEEEEEEEEEEEE
 1061|       |  // new_ctrl after kSentinel =  E012EEESEEEEEEEEEEEEEEE
 1062|       |  //                                >!
 1063|       |  // new_ctrl after 2nd store =  E012EEESE012EEEEEEEEEEE
 1064|       |
 1065|       |  // Example for growth capacity 7->15:
 1066|       |  // old_ctrl =                  0123456S0123456EEEEEEEE
 1067|       |  // new_ctrl at the end =       E0123456EEEEEEESE0123456EEEEEEE
 1068|       |  //                                    >!
 1069|       |  // new_ctrl after 1st memset = ????????EEEEEEEE???????????????
 1070|       |  //                                                   >!
 1071|       |  // new_ctrl after 2nd memset = ????????EEEEEEEE???????EEEEEEEE
 1072|       |  //                            >!
 1073|       |  // new_ctrl after 1st store =  E0123456EEEEEEEE???????EEEEEEEE
 1074|       |  // new_ctrl after kSentinel =  E0123456EEEEEEES???????EEEEEEEE
 1075|       |  //                                            >!
 1076|       |  // new_ctrl after 2nd store =  E0123456EEEEEEESE0123456EEEEEEE
 1077|      4|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_126GrowToNextCapacityDispatchERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPNS1_6ctrl_tEPv:
 1385|      2|                                  ctrl_t* old_ctrl, void* old_slots) {
 1386|      2|  const size_t new_capacity = common.capacity();
 1387|      2|  if (ABSL_PREDICT_TRUE(new_capacity <= kMaxLocalBufferNewCapacity)) {
  ------------------
  |  |  191|      2|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 2, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 2]
  |  |  |  Branch (191:57): [True: 2, False: 0]
  |  |  ------------------
  ------------------
 1388|      2|    return GrowToNextCapacityThatFitsInLocalBuffer(common, policy, old_ctrl,
 1389|      2|                                                   old_slots);
 1390|      2|  } else {
 1391|      0|    return GrowToNextCapacityOverflowLocalBuffer(common, policy, old_ctrl,
 1392|      0|                                                 old_slots);
 1393|      0|  }
 1394|      2|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_139GrowToNextCapacityThatFitsInLocalBufferERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPNS1_6ctrl_tEPv:
 1335|      2|    ctrl_t* old_ctrl, void* old_slots) {
 1336|       |  ABSL_SWISSTABLE_ASSERT(common.capacity() <= kMaxLocalBufferNewCapacity);
  ------------------
  |  |   62|      2|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1337|      2|  return GrowToNextCapacity<
 1338|      2|      ProbedItemEncoder<ProbedItem4Bytes, /*kGuaranteedFitToBuffer=*/true>>(
 1339|      2|      common, policy, old_ctrl, old_slots);
 1340|      2|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_118GrowToNextCapacityINS2_17ProbedItemEncoderINS1_14ProbedItemImplIjLm32EEELb1EEEEEmRNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPNS1_6ctrl_tEPv:
 1316|      2|                          ctrl_t* old_ctrl, void* old_slots) {
 1317|      2|  using ProbedItem = typename Encoder::ProbedItem;
 1318|       |  ABSL_SWISSTABLE_ASSERT(common.capacity() <= ProbedItem::kMaxNewCapacity);
  ------------------
  |  |   62|      2|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1319|      2|  Encoder encoder(old_ctrl);
 1320|      2|  policy.transfer_unprobed_elements_to_next_capacity(
 1321|      2|      common, old_ctrl, old_slots, &encoder,
 1322|      2|      [](void* probed_storage, h2_t h2, size_t source_offset, size_t h1) {
 1323|      2|        auto encoder_ptr = static_cast<Encoder*>(probed_storage);
 1324|      2|        encoder_ptr->EncodeItem(ProbedItem(h2, source_offset, h1));
 1325|      2|      });
 1326|      2|  InitializeMirroredControlBytes(common.control(), common.capacity());
 1327|      2|  return encoder.DecodeAndInsertToTable(common, policy, old_slots);
 1328|      2|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_117ProbedItemEncoderINS1_14ProbedItemImplIjLm32EEELb1EEC2EPNS1_6ctrl_tE:
 1190|      2|  explicit ProbedItemEncoder(ctrl_t* control) : control_(control) {}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_130InitializeMirroredControlBytesEPNS1_6ctrl_tEm:
 1166|      2|void InitializeMirroredControlBytes(ctrl_t* new_ctrl, size_t new_capacity) {
 1167|      2|  std::memcpy(new_ctrl + new_capacity,
 1168|       |              // We own GrowthInfo just before control bytes. So it is ok
 1169|       |              // to read one byte from it.
 1170|      2|              new_ctrl - 1, Group::kWidth);
 1171|      2|  new_ctrl[new_capacity] = ctrl_t::kSentinel;
 1172|      2|}
raw_hash_set.cc:_ZNK4absl12lts_2026052618container_internal12_GLOBAL__N_117ProbedItemEncoderINS1_14ProbedItemImplIjLm32EEELb1EE22DecodeAndInsertToTableERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPv:
 1207|      2|                                void* old_slots) const {
 1208|      2|    if (pos_ == buffer_) {
  ------------------
  |  Branch (1208:9): [True: 2, False: 0]
  ------------------
 1209|      2|      return 0;
 1210|      2|    }
 1211|      0|    if constexpr (kGuaranteedFitToBuffer) {
 1212|      0|      return DecodeAndInsertImpl(common, policy, buffer_, pos_, old_slots);
 1213|      0|    }
 1214|      0|    size_t total_probe_length = DecodeAndInsertImpl(
 1215|      0|        common, policy, buffer_,
 1216|      0|        local_buffer_full_ ? buffer_ + kBufferSize : pos_, old_slots);
  ------------------
  |  Branch (1216:9): [True: 0, False: 0]
  ------------------
 1217|      0|    if (!local_buffer_full_) {
  ------------------
  |  Branch (1217:9): [True: 0, False: 0]
  ------------------
 1218|      0|      return total_probe_length;
 1219|      0|    }
 1220|      0|    total_probe_length +=
 1221|      0|        DecodeAndInsertToTableOverflow(common, policy, old_slots);
 1222|      0|    return total_probe_length;
 1223|      0|  }
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_127find_first_non_full_from_h1EPKNS1_6ctrl_tEmNS1_21HashtableCapacityImplILNS1_28HashtableCapacityStorageModeE1EEE:
  188|      2|                                     HashtableCapacity capacity) {
  189|      2|  auto seq = probe_h1(capacity, h1);
  190|      2|  if (IsEmptyOrDeleted(ctrl[seq.offset()])) {
  ------------------
  |  Branch (190:7): [True: 0, False: 2]
  ------------------
  191|      0|    return {seq.offset(), /*probe_length=*/0};
  192|      0|  }
  193|      2|  auto mask = probe_till_first_non_full_group(ctrl, seq, capacity.capacity());
  194|      2|  return {seq.offset(mask.LowestBitSet()), seq.index()};
  195|      2|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_131probe_till_first_non_full_groupEPKNS1_6ctrl_tERNS1_9probe_seqILm16EEEm:
  175|      2|    [[maybe_unused]] size_t capacity) {
  176|      2|  while (true) {
  ------------------
  |  Branch (176:10): [True: 2, Folded]
  ------------------
  177|      2|    GroupFullEmptyOrDeleted g{ctrl + seq.offset()};
  178|      2|    auto mask = g.MaskEmptyOrDeleted();
  179|      2|    if (mask) {
  ------------------
  |  Branch (179:9): [True: 2, False: 0]
  ------------------
  180|      2|      return mask;
  181|      2|    }
  182|      0|    seq.next();
  183|       |    ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity && "full table!");
  ------------------
  |  |   62|      0|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  184|      0|  }
  185|      2|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_119find_first_non_fullERKNS1_12CommonFieldsEm:
  204|      2|FindInfo find_first_non_full(const CommonFields& common, size_t hash) {
  205|      2|  return find_first_non_full_from_h1(common.control(), H1(hash),
  206|      2|                                     common.capacity_impl());
  207|      2|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_119SetCtrlInLargeTableERKNS1_12CommonFieldsEmhm:
  399|      2|                                size_t slot_size) {
  400|      2|  SetCtrlInLargeTable(c, i, static_cast<ctrl_t>(h), slot_size);
  401|      2|}

_ZN4absl12lts_2026052618container_internal12CommonFields13CreateDefaultILb0EEES2_v:
 1149|      2|  static CommonFields CreateDefault() {
 1150|      2|    return kSooEnabled ? CommonFields{soo_tag_t{}}
  ------------------
  |  Branch (1150:12): [Folded, False: 2]
  ------------------
 1151|      2|                       : CommonFields{non_soo_tag_t{}};
 1152|      2|  }
_ZN4absl12lts_2026052618container_internal21HashtableCapacityImplILNS1_28HashtableCapacityStorageModeE1EEC2Em:
  491|     12|      : capacity_data_(static_cast<IntType>(
  492|     12|            StorageMode == kCapacityByValue ? capacity
  ------------------
  |  Branch (492:13): [Folded, False: 12]
  ------------------
  493|     12|                                            : TrailingZeros(capacity + 1))) {
  494|       |    ABSL_SWISSTABLE_ASSERT(capacity == 0 || IsValidCapacity(capacity));
  ------------------
  |  |  256|     12|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  495|     12|  }
_ZN4absl12lts_2026052618container_internal23HashtableInlineDataImplILNS1_28HashtableCapacityStorageModeE1EEC2ENS1_21HashtableCapacityImplILS3_1EEENS1_19no_seed_empty_tag_tE:
  629|      2|      : capacity_internal_(capacity.ToRawData()), data_(0) {}
_ZNK4absl12lts_2026052618container_internal21HashtableCapacityImplILNS1_28HashtableCapacityStorageModeE1EE9ToRawDataEv:
  506|     12|  IntType ToRawData() const { return capacity_data_; }
_ZN4absl12lts_2026052618container_internal12CommonFieldsC2ENS1_13non_soo_tag_tE:
 1131|      2|      : inline_data_(HashtableCapacity(0), no_seed_empty_tag_t{}) {}
_ZNK4absl12lts_2026052618container_internal12CommonFields8is_smallEv:
 1242|     54|  bool is_small() const { return inline_data_.is_small(); }
_ZNK4absl12lts_2026052618container_internal23HashtableInlineDataImplILNS1_28HashtableCapacityStorageModeE1EE8is_smallEv:
  639|     54|  bool is_small() const { return capacity().is_small(); }
_ZNK4absl12lts_2026052618container_internal23HashtableInlineDataImplILNS1_28HashtableCapacityStorageModeE1EE8capacityEv:
  636|    548|  HashtableCapacity capacity() const {
  637|    548|    return HashtableCapacity::FromRawData(capacity_internal_);
  638|    548|  }
_ZN4absl12lts_2026052618container_internal21HashtableCapacityImplILNS1_28HashtableCapacityStorageModeE1EE11FromRawDataEm:
  501|    548|  static HashtableCapacityImpl FromRawData(uint64_t capacity) {
  502|    548|    auto cap = HashtableCapacityImpl(uninitialized_tag_t{});
  503|    548|    cap.capacity_data_ = static_cast<IntType>(capacity);
  504|    548|    return cap;
  505|    548|  }
_ZN4absl12lts_2026052618container_internal21HashtableCapacityImplILNS1_28HashtableCapacityStorageModeE1EEC2ENS1_19uninitialized_tag_tE:
  489|    548|  explicit HashtableCapacityImpl(uninitialized_tag_t) {}
_ZNK4absl12lts_2026052618container_internal21HashtableCapacityImplILNS1_28HashtableCapacityStorageModeE1EE8is_smallEv:
  526|     54|  constexpr bool is_small() const {
  527|       |    // Small tables have capacity 0 or 1. This expression is valid for both
  528|       |    // capacity storage modes.
  529|       |    // Comparing capacity_data_ directly leads to a better generated code.
  530|       |    // One byte comparison is used before computing the capacity in order to
  531|       |    // detect small tables faster for critical path.
  532|     54|    static_assert(MaxSmallCapacity() == 1);
  533|     54|    return capacity_data_ <= 1;
  534|     54|  }
_ZNK4absl12lts_2026052618container_internal12CommonFields4sizeEv:
 1180|     16|  size_t size() const { return inline_data_.size(); }
_ZNK4absl12lts_2026052618container_internal23HashtableInlineDataImplILNS1_28HashtableCapacityStorageModeE1EE4sizeEv:
  645|     16|  size_t size() const { return static_cast<size_t>(data_ >> kSizeShift); }
_ZNK4absl12lts_2026052618container_internal12CommonFields10slot_arrayEv:
 1173|    154|  void* slot_array() const { return heap_or_soo_.slot_array().get(); }
_ZNK4absl12lts_2026052618container_internal9HeapOrSoo10slot_arrayEv:
 1097|    156|  MaybeInitializedPtr<void> slot_array() const {
 1098|    156|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(heap.slot_array);
  ------------------
  |  |  488|    156|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
 1099|    156|  }
_ZNK4absl12lts_2026052618container_internal19MaybeInitializedPtrIvE3getEv:
 1060|    156|  T* get() const { ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(p); }
  ------------------
  |  |  488|    156|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
_ZN4absl12lts_2026052618container_internal10SooControlEv:
  340|      2|inline ctrl_t* SooControl() {
  341|       |  // Const must be cast away here; no uses of this function will actually write
  342|       |  // to it because it is only used for SOO iterators.
  343|      2|  return const_cast<ctrl_t*>(kSooControl);
  344|      2|}
_ZNK4absl12lts_2026052618container_internal34CommonFieldsGenerationInfoDisabled14generation_ptrEv:
  847|     54|  GenerationType* generation_ptr() const { return nullptr; }
_ZN4absl12lts_2026052618container_internal37HashSetIteratorGenerationInfoDisabledC2EPKh:
  871|     54|  explicit HashSetIteratorGenerationInfoDisabled(const GenerationType*) {}
_ZNK4absl12lts_2026052618container_internal12CommonFields8capacityEv:
 1232|    446|  size_t capacity() const { return capacity_impl().capacity(); }
_ZNK4absl12lts_2026052618container_internal12CommonFields13capacity_implEv:
 1227|    494|  HashtableCapacity capacity_impl() const {
 1228|    494|    HashtableCapacity cap = inline_data_.capacity();
 1229|       |    ABSL_SWISSTABLE_ASSERT(cap.IsValid());
  ------------------
  |  |  256|    494|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1230|    494|    return cap;
 1231|    494|  }
_ZNK4absl12lts_2026052618container_internal21HashtableCapacityImplILNS1_28HashtableCapacityStorageModeE1EE8capacityEv:
  520|    500|  constexpr size_t capacity() const {
  521|    500|    ABSL_SWISSTABLE_ASSERT(IsValid());
  ------------------
  |  |  256|    500|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  522|    500|    return StorageMode == kCapacityByValue ? capacity_data_
  ------------------
  |  Branch (522:12): [Folded, False: 500]
  ------------------
  523|    500|                                           : (size_t{1} << capacity_data_) - 1;
  524|    500|  }
_ZN4absl12lts_2026052618container_internal16PreviousCapacityEm:
  400|      2|constexpr size_t PreviousCapacity(size_t n) {
  401|       |  ABSL_SWISSTABLE_ASSERT(IsValidCapacity(n));
  ------------------
  |  |  256|      2|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  402|      2|  return n / 2;
  403|      2|}
_ZNK4absl12lts_2026052618container_internal12CommonFields7controlEv:
 1158|    296|  ctrl_t* control() const {
 1159|    296|    ABSL_SWISSTABLE_ASSERT(capacity() > 0);
  ------------------
  |  |  256|    296|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1160|       |    // Assume that the control bytes don't alias `this`.
 1161|    296|    ctrl_t* ctrl = heap_or_soo_.control().get();
 1162|    296|    [[maybe_unused]] size_t num_control_bytes = NumControlBytes(capacity());
 1163|    296|    ABSL_ASSUME(reinterpret_cast<uintptr_t>(ctrl + num_control_bytes) <=
  ------------------
  |  |  271|    592|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  |  |  ------------------
  |  |  |  Branch (271:44): [True: 0, False: 296]
  |  |  |  Branch (271:44): [True: 296, False: 0]
  |  |  ------------------
  ------------------
 1164|    296|                    reinterpret_cast<uintptr_t>(this) ||
 1165|    296|                reinterpret_cast<uintptr_t>(this + 1) <=
 1166|    296|                    reinterpret_cast<uintptr_t>(ctrl));
 1167|    296|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(ctrl);
  ------------------
  |  |  488|    296|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
 1168|    296|  }
_ZNK4absl12lts_2026052618container_internal9HeapOrSoo7controlEv:
 1091|    296|  MaybeInitializedPtr<ctrl_t> control() const {
 1092|    296|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(heap.control);
  ------------------
  |  |  488|    296|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
 1093|    296|  }
_ZNK4absl12lts_2026052618container_internal19MaybeInitializedPtrINS1_6ctrl_tEE3getEv:
 1060|    296|  T* get() const { ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(p); }
  ------------------
  |  |  488|    296|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
_ZN4absl12lts_2026052618container_internal15NumControlBytesEm:
  988|    314|constexpr size_t NumControlBytes(size_t capacity) {
  989|    314|  return IsSmallCapacity(capacity) ? 0 : capacity + 1 + NumClonedBytes();
  ------------------
  |  Branch (989:10): [True: 6, False: 308]
  ------------------
  990|    314|}
_ZN4absl12lts_2026052618container_internal15IsSmallCapacityEm:
  384|    334|constexpr bool IsSmallCapacity(size_t capacity) {
  385|    334|  return capacity <= MaxSmallCapacity();
  386|    334|}
_ZN4absl12lts_2026052618container_internal16MaxSmallCapacityEv:
  366|    334|constexpr size_t MaxSmallCapacity() { return 1; }
_ZN4absl12lts_2026052618container_internal14NumClonedBytesEv:
  985|    392|constexpr size_t NumClonedBytes() { return Group::kWidth - 1; }
_ZNK4absl12lts_2026052618container_internal12CommonFields4seedEv:
 1212|     84|  PerTableSeed seed() const { return inline_data_.seed(); }
_ZNK4absl12lts_2026052618container_internal23HashtableInlineDataImplILNS1_28HashtableCapacityStorageModeE1EE4seedEv:
  668|     84|  PerTableSeed seed() const { return PerTableSeed(data_ & kSeedMask); }
_ZN4absl12lts_2026052618container_internal16PerTableSeedImplIhEC2Em:
  605|     84|      : seed_(static_cast<IntType>(seed)) {}
_ZNK4absl12lts_2026052618container_internal16PerTableSeedImplIhE4seedEv:
  598|     84|  size_t seed() const { return seed_; }
_ZN4absl12lts_2026052618container_internal2H1Em:
  740|     76|inline size_t H1(size_t hash) { return hash; }
_ZN4absl12lts_2026052618container_internal2H2Em:
  745|    124|inline h2_t H2(size_t hash) { return hash >> (sizeof(size_t) * 8 - 7); }
_ZN4absl12lts_2026052618container_internal29TryFindNewIndexWithoutProbingIvEEmmmmPNS1_6ctrl_tEm:
 1652|     28|                                            size_t new_capacity) {
 1653|     28|  size_t index_diff = old_index - h1;
 1654|       |  // The first probe group starts with h1 & capacity.
 1655|       |  // All following groups start at (h1 + Group::kWidth * K) & capacity.
 1656|       |  // We can find an index within the floating group as index_diff modulo
 1657|       |  // Group::kWidth.
 1658|       |  // Both old and new capacity are larger than Group::kWidth so we can avoid
 1659|       |  // computing `& capacity`.
 1660|     28|  size_t in_floating_group_index = index_diff & (Group::kWidth - 1);
 1661|       |  // By subtracting we will get the difference between the first probe group
 1662|       |  // and the probe group corresponding to old_index.
 1663|     28|  index_diff -= in_floating_group_index;
 1664|     28|  if (ABSL_PREDICT_TRUE((index_diff & old_capacity) == 0)) {
  ------------------
  |  |  191|     28|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 28, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 28]
  |  |  |  Branch (191:57): [True: 28, False: 0]
  |  |  ------------------
  ------------------
 1665|     28|    size_t new_index = (h1 + in_floating_group_index) & new_capacity;
 1666|     28|    ABSL_ASSUME(new_index != kProbedElementIndexSentinel);
  ------------------
  |  |  271|     28|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1667|     28|    return new_index;
 1668|     28|  }
 1669|      0|  ABSL_SWISSTABLE_ASSERT(((old_index - h1) & old_capacity) >= Group::kWidth);
  ------------------
  |  |  256|      0|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1670|       |  // Try to insert element into the first probe group.
 1671|       |  // new_ctrl is not yet fully initialized so we can't use regular search via
 1672|       |  // find_first_non_full.
 1673|       |
 1674|       |  // We can search in the first probe group only if it is located in already
 1675|       |  // initialized part of the table.
 1676|      0|  if (ABSL_PREDICT_FALSE((h1 & old_capacity) >= old_index)) {
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1677|      0|    return kProbedElementIndexSentinel;
 1678|      0|  }
 1679|      0|  size_t offset = h1 & new_capacity;
 1680|      0|  Group new_g(new_ctrl + offset);
 1681|      0|  if (auto mask = new_g.MaskNonFull(); ABSL_PREDICT_TRUE(mask)) {
  ------------------
  |  |  191|      0|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 0, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 0]
  |  |  |  Branch (191:57): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1682|      0|    size_t result = offset + mask.LowestBitSet();
 1683|      0|    ABSL_ASSUME(result != kProbedElementIndexSentinel);
  ------------------
  |  |  271|      0|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1684|      0|    return result;
 1685|      0|  }
 1686|      0|  return kProbedElementIndexSentinel;
 1687|      0|}
_ZN4absl12lts_2026052618container_internal5probeERKNS1_12CommonFieldsEm:
 1631|     46|inline probe_seq<Group::kWidth> probe(const CommonFields& common, size_t hash) {
 1632|     46|  return probe(common.capacity_impl(), hash);
 1633|     46|}
_ZN4absl12lts_2026052618container_internal5probeENS1_21HashtableCapacityImplILNS1_28HashtableCapacityStorageModeE1EEEm:
 1628|     46|inline probe_seq<Group::kWidth> probe(HashtableCapacity capacity, size_t hash) {
 1629|     46|  return probe_h1(capacity, H1(hash));
 1630|     46|}
_ZN4absl12lts_2026052618container_internal8probe_h1ENS1_21HashtableCapacityImplILNS1_28HashtableCapacityStorageModeE1EEEm:
 1625|     48|                                         size_t h1) {
 1626|     48|  return probe_seq<Group::kWidth>(capacity, h1);
 1627|     48|}
_ZN4absl12lts_2026052618container_internal9probe_seqILm16EEC2ENS1_21HashtableCapacityImplILNS1_28HashtableCapacityStorageModeE1EEEm:
 1603|     48|      : capacity_(capacity), offset_(capacity.mask(hash)) {}
_ZNK4absl12lts_2026052618container_internal21HashtableCapacityImplILNS1_28HashtableCapacityStorageModeE1EE4maskEm:
  536|     52|  constexpr size_t mask(size_t value) const {
  537|       |#ifdef __BMI2__
  538|       |    if constexpr (StorageMode == kCapacityByLog) {
  539|       |      if constexpr (sizeof(size_t) == 8) {
  540|       |        return _bzhi_u64(value, capacity_data_);
  541|       |      } else {
  542|       |        return _bzhi_u32(value, capacity_data_);
  543|       |      }
  544|       |    }
  545|       |#endif  // __BMI2__
  546|     52|    return value & capacity();
  547|     52|  }
_ZNK4absl12lts_2026052618container_internal9probe_seqILm16EE6offsetEv:
 1606|    142|  size_t offset() const { return offset_; }
_ZNK4absl12lts_2026052618container_internal9probe_seqILm16EE6offsetEm:
 1607|      4|  size_t offset(size_t i) const { return capacity_.mask(offset_ + i); }
_ZNK4absl12lts_2026052618container_internal9probe_seqILm16EE5indexEv:
 1615|     48|  size_t index() const { return index_; }
_ZNK4absl12lts_2026052618container_internal12CommonFields11slots_unionEv:
 1174|      2|  MaybeInitializedPtr<void> slots_union() const {
 1175|      2|    return heap_or_soo_.slot_array();
 1176|      2|  }
_ZN4absl12lts_2026052618container_internal26AssertIsValidForComparisonEPKNS1_6ctrl_tEhPKh:
 1456|    104|                                       const GenerationType* generation_ptr) {
 1457|    104|  if (!SwisstableDebugEnabled()) return;
  ------------------
  |  Branch (1457:7): [True: 104, Folded]
  ------------------
 1458|      0|  const bool ctrl_is_valid_for_comparison =
 1459|      0|      ctrl == nullptr || ctrl == DefaultIterControl() ||
  ------------------
  |  Branch (1459:7): [True: 0, False: 0]
  |  Branch (1459:26): [True: 0, False: 0]
  ------------------
 1460|      0|      IsFull(CrashIfIteratorIsInvalid(ctrl));
  ------------------
  |  Branch (1460:7): [True: 0, False: 0]
  ------------------
 1461|      0|  if (SwisstableGenerationsEnabled()) {
  ------------------
  |  Branch (1461:7): [Folded, False: 0]
  ------------------
 1462|      0|    if (ABSL_PREDICT_FALSE(generation !=
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1463|      0|                           CrashIfIteratorIsInvalid(generation_ptr))) {
 1464|       |      // Note: in the case of a rehash, we would expect to see a sanitizer crash
 1465|       |      // in CrashIfIteratorIsInvalid so this assertion will only catch moved
 1466|       |      // table cases, unless we're using a custom allocator that does not
 1467|       |      // deallocate the old backing array (e.g. an arena allocator).
 1468|      0|      ABSL_RAW_LOG(
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1469|      0|          FATAL,
 1470|      0|          "Invalid iterator comparison. The table was likely moved (or "
 1471|      0|          "possibly rehashed) since this iterator was initialized.");
 1472|      0|    }
 1473|      0|    if (ABSL_PREDICT_FALSE(!ctrl_is_valid_for_comparison)) {
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1474|      0|      ABSL_RAW_LOG(
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1475|      0|          FATAL, "Invalid iterator comparison. The element was likely erased.");
 1476|      0|    }
 1477|      0|  } else {
 1478|      0|    ABSL_HARDENING_ASSERT_SLOW(
  ------------------
  |  |  175|      0|#define ABSL_HARDENING_ASSERT_SLOW(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |  127|      0|#define ABSL_ASSERT(expr) ABSL_INTERNAL_UNEVALUATED((expr) ? void() : void())
  |  |  |  |  ------------------
  |  |  |  |  |  |   87|      0|#define ABSL_INTERNAL_UNEVALUATED(expr) (false ? (void)(expr) : void())
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (87:42): [Folded, False: 0]
  |  |  |  |  |  |  |  Branch (87:57): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (87:57): [True: 0, Folded]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1479|      0|        ctrl_is_valid_for_comparison &&
 1480|      0|        "Invalid iterator comparison. The element might have been erased or "
 1481|      0|        "the table might have rehashed. Consider running with --config=asan to "
 1482|      0|        "diagnose rehashing issues.");
 1483|      0|  }
 1484|      0|}
_ZNK4absl12lts_2026052618container_internal37HashSetIteratorGenerationInfoDisabled10generationEv:
  873|    204|  GenerationType generation() const { return 0; }
_ZNK4absl12lts_2026052618container_internal37HashSetIteratorGenerationInfoDisabled14generation_ptrEv:
  875|    308|  const GenerationType* generation_ptr() const { return nullptr; }
_ZN4absl12lts_2026052618container_internal19AssertSameContainerEPKNS1_6ctrl_tES4_RKPKvS8_PKhSA_:
 1516|     52|                                const GenerationType* generation_ptr_b) {
 1517|     52|  if (!SwisstableDebugEnabled()) return;
  ------------------
  |  Branch (1517:7): [True: 52, Folded]
  ------------------
 1518|       |  // `SwisstableDebugEnabled()` is also true for release builds with hardening
 1519|       |  // enabled. To minimize their impact in those builds:
 1520|       |  // - use `ABSL_PREDICT_FALSE()` to provide a compiler hint for code layout
 1521|       |  // - use `ABSL_RAW_LOG()` with a format string to reduce code size and improve
 1522|       |  //   the chances that the hot paths will be inlined.
 1523|       |
 1524|       |  // fail_if(is_invalid, message) crashes when is_invalid is true and provides
 1525|       |  // an error message based on `message`.
 1526|      0|  const auto fail_if = [](bool is_invalid, const char* message) {
 1527|      0|    if (ABSL_PREDICT_FALSE(is_invalid)) {
 1528|      0|      ABSL_RAW_LOG(FATAL, "Invalid iterator comparison. %s", message);
 1529|      0|    }
 1530|      0|  };
 1531|       |
 1532|      0|  const bool a_is_default = ctrl_a == DefaultIterControl();
 1533|      0|  const bool b_is_default = ctrl_b == DefaultIterControl();
 1534|      0|  if (a_is_default && b_is_default) return;
  ------------------
  |  Branch (1534:7): [True: 0, False: 0]
  |  Branch (1534:23): [True: 0, False: 0]
  ------------------
 1535|      0|  fail_if(a_is_default != b_is_default,
 1536|      0|          "Comparing default-constructed hashtable iterator with a "
 1537|      0|          "non-default-constructed hashtable iterator.");
 1538|       |
 1539|      0|  if (SwisstableGenerationsEnabled()) {
  ------------------
  |  Branch (1539:7): [Folded, False: 0]
  ------------------
 1540|      0|    if (ABSL_PREDICT_TRUE(generation_ptr_a == generation_ptr_b)) return;
  ------------------
  |  |  191|      0|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 0, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 0]
  |  |  |  Branch (191:57): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1541|      0|    const bool a_is_empty = IsEmptyGeneration(generation_ptr_a);
 1542|      0|    const bool b_is_empty = IsEmptyGeneration(generation_ptr_b);
 1543|      0|    fail_if(a_is_empty != b_is_empty,
 1544|      0|            "Comparing an iterator from an empty hashtable with an iterator "
 1545|      0|            "from a non-empty hashtable.");
 1546|      0|    fail_if(a_is_empty && b_is_empty,
  ------------------
  |  Branch (1546:13): [True: 0, False: 0]
  |  Branch (1546:27): [True: 0, False: 0]
  ------------------
 1547|      0|            "Comparing iterators from different empty hashtables.");
 1548|       |
 1549|      0|    const bool a_is_end = ctrl_a == nullptr;
 1550|      0|    const bool b_is_end = ctrl_b == nullptr;
 1551|      0|    fail_if(a_is_end || b_is_end,
  ------------------
  |  Branch (1551:13): [True: 0, False: 0]
  |  Branch (1551:25): [True: 0, False: 0]
  ------------------
 1552|      0|            "Comparing iterator with an end() iterator from a different "
 1553|      0|            "hashtable.");
 1554|      0|    fail_if(true, "Comparing non-end() iterators from different hashtables.");
 1555|      0|  } else {
 1556|      0|    ABSL_HARDENING_ASSERT_SLOW(
  ------------------
  |  |  175|      0|#define ABSL_HARDENING_ASSERT_SLOW(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |  127|      0|#define ABSL_ASSERT(expr) ABSL_INTERNAL_UNEVALUATED((expr) ? void() : void())
  |  |  |  |  ------------------
  |  |  |  |  |  |   87|      0|#define ABSL_INTERNAL_UNEVALUATED(expr) (false ? (void)(expr) : void())
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (87:42): [Folded, False: 0]
  |  |  |  |  |  |  |  Branch (87:57): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (87:57): [True: 0, Folded]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1557|      0|        AreItersFromSameContainer(ctrl_a, ctrl_b, slot_a, slot_b) &&
 1558|      0|        "Invalid iterator comparison. The iterators may be from different "
 1559|      0|        "containers or the container might have rehashed or moved. Consider "
 1560|      0|        "running with --config=asan to diagnose issues.");
 1561|      0|  }
 1562|      0|}
_ZN4absl12lts_2026052618container_internal12AssertIsFullEPKNS1_6ctrl_tEhPKhPKc:
 1413|    100|                         const char* operation) {
 1414|    100|  if (!SwisstableDebugEnabled()) return;
  ------------------
  |  Branch (1414:7): [True: 100, Folded]
  ------------------
 1415|       |  // `SwisstableDebugEnabled()` is also true for release builds with hardening
 1416|       |  // enabled. To minimize their impact in those builds:
 1417|       |  // - use `ABSL_PREDICT_FALSE()` to provide a compiler hint for code layout
 1418|       |  // - use `ABSL_RAW_LOG()` with a format string to reduce code size and improve
 1419|       |  //   the chances that the hot paths will be inlined.
 1420|      0|  if (ABSL_PREDICT_FALSE(ctrl == nullptr)) {
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1421|      0|    ABSL_RAW_LOG(FATAL, "%s called on end() iterator.", operation);
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1422|      0|  }
 1423|      0|  if (ABSL_PREDICT_FALSE(ctrl == DefaultIterControl())) {
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1424|      0|    ABSL_RAW_LOG(FATAL, "%s called on default-constructed iterator.",
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1425|      0|                 operation);
 1426|      0|  }
 1427|      0|  if (SwisstableGenerationsEnabled()) {
  ------------------
  |  Branch (1427:7): [Folded, False: 0]
  ------------------
 1428|      0|    if (ABSL_PREDICT_FALSE(generation !=
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1429|      0|                           CrashIfIteratorIsInvalid(generation_ptr))) {
 1430|      0|      ABSL_RAW_LOG(FATAL,
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1431|      0|                   "%s called on invalid iterator. The table could have "
 1432|      0|                   "rehashed or moved since this iterator was initialized.",
 1433|      0|                   operation);
 1434|      0|    }
 1435|      0|    if (ABSL_PREDICT_FALSE(!IsFull(CrashIfIteratorIsInvalid(ctrl)))) {
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1436|      0|      ABSL_RAW_LOG(
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1437|      0|          FATAL,
 1438|      0|          "%s called on invalid iterator. The element was likely erased.",
 1439|      0|          operation);
 1440|      0|    }
 1441|      0|  } else {
 1442|      0|    if (ABSL_PREDICT_FALSE(!IsFull(CrashIfIteratorIsInvalid(ctrl)))) {
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1443|       |      ABSL_RAW_LOG(
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1444|      0|          FATAL,
 1445|      0|          "%s called on invalid iterator. The element might have been erased "
 1446|      0|          "or the table might have rehashed. Consider running with "
 1447|      0|          "--config=asan to diagnose rehashing issues.",
 1448|      0|          operation);
 1449|      0|    }
 1450|      0|  }
 1451|      0|}
_ZN4absl12lts_2026052618container_internal15IsValidCapacityEm:
  381|      2|constexpr bool IsValidCapacity(size_t n) { return ((n + 1) & n) == 0 && n > 0; }
  ------------------
  |  Branch (381:51): [True: 2, False: 0]
  |  Branch (381:73): [True: 2, False: 0]
  ------------------
_ZN4absl12lts_2026052618container_internal12CommonFields5infozEv:
 1274|     50|  HashtablezInfoHandle infoz() {
 1275|     50|    return has_infoz() ? *infoz_ptr() : HashtablezInfoHandle();
  ------------------
  |  Branch (1275:12): [True: 0, False: 50]
  ------------------
 1276|     50|  }
_ZN4absl12lts_2026052618container_internal13ControlOffsetEbb:
  999|     18|constexpr size_t ControlOffset(bool has_infoz, bool has_growth_info) {
 1000|     18|  if (ABSL_PREDICT_FALSE(has_infoz)) {
  ------------------
  |  |  190|     18|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 18]
  |  |  |  Branch (190:49): [Folded, False: 18]
  |  |  |  Branch (190:58): [True: 0, False: 18]
  |  |  ------------------
  ------------------
 1001|       |    // We always allocate GrowthInfo for sampled tables to allow branchless
 1002|       |    // access to infoz pointer.
 1003|      0|    return sizeof(HashtablezInfoHandle) + sizeof(GrowthInfo);
 1004|      0|  }
 1005|     18|  return has_growth_info ? sizeof(GrowthInfo) : 0;
  ------------------
  |  Branch (1005:10): [True: 14, False: 4]
  ------------------
 1006|     18|}
_ZN4absl12lts_2026052618container_internal24HasGrowthInfoForCapacityEm:
  993|     18|constexpr bool HasGrowthInfoForCapacity(size_t capacity) {
  994|     18|  return !IsSmallCapacity(capacity);
  995|     18|}
_ZNK4absl12lts_2026052618container_internal12CommonFields9has_infozEv:
 1258|     50|  bool has_infoz() const { return inline_data_.has_infoz(); }
_ZNK4absl12lts_2026052618container_internal23HashtableInlineDataImplILNS1_28HashtableCapacityStorageModeE1EE9has_infozEv:
  683|     50|  bool has_infoz() const {
  684|     50|    return ABSL_PREDICT_FALSE((data_ & kHasInfozMask) != 0);
  ------------------
  |  |  190|     50|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:49): [Folded, False: 50]
  |  |  |  Branch (190:58): [True: 0, False: 50]
  |  |  ------------------
  ------------------
  685|     50|  }
_ZN4absl12lts_2026052618container_internal23HashtableInlineDataImplILNS1_28HashtableCapacityStorageModeE1EE8set_sizeEm:
  663|      2|  void set_size(size_t size) {
  664|      2|    data_ =
  665|      2|        (data_ & kMetadataMask) | (static_cast<uint64_t>(size) << kSizeShift);
  666|      2|  }
_ZN4absl12lts_2026052618container_internal34CommonFieldsGenerationInfoDisabled36maybe_increment_generation_on_insertEv:
  838|     50|  void maybe_increment_generation_on_insert() {}
_ZN4absl12lts_2026052618container_internal34CommonFieldsGenerationInfoDisabled19set_reserved_growthEm:
  842|      2|  void set_reserved_growth(size_t) {}
_ZN4absl12lts_2026052618container_internal34CommonFieldsGenerationInfoDisabled20set_reservation_sizeEm:
  844|      2|  void set_reservation_size(size_t) {}
_ZNK4absl12lts_2026052618container_internal34CommonFieldsGenerationInfoDisabled10generationEv:
  845|     10|  GenerationType generation() const { return 0; }
_ZN4absl12lts_2026052618container_internal34CommonFieldsGenerationInfoDisabled14set_generationEh:
  846|     10|  void set_generation(GenerationType) {}
_ZN4absl12lts_2026052618container_internal34CommonFieldsGenerationInfoDisabled18set_generation_ptrEPh:
  848|     10|  void set_generation_ptr(GenerationType*) {}
_ZN4absl12lts_2026052618container_internal10GrowthInfo23InitGrowthLeftNoDeletedEm:
  914|     10|  void InitGrowthLeftNoDeleted(size_t growth_left) {
  915|     10|    growth_left_info_ = growth_left;
  916|     10|  }
_ZN4absl12lts_2026052618container_internal10GrowthInfo20OverwriteEmptyAsFullEv:
  922|     40|  void OverwriteEmptyAsFull() {
  923|       |    ABSL_SWISSTABLE_ASSERT(GetGrowthLeft() > 0);
  ------------------
  |  |  256|     40|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  924|     40|    --growth_left_info_;
  925|     40|  }
_ZNK4absl12lts_2026052618container_internal10GrowthInfo25HasNoDeletedAndGrowthLeftEv:
  946|     46|  bool HasNoDeletedAndGrowthLeft() const {
  947|     46|    return static_cast<std::make_signed_t<size_t>>(growth_left_info_) > 0;
  948|     46|  }
_ZNK4absl12lts_2026052618container_internal10GrowthInfo27HasNoGrowthLeftAndNoDeletedEv:
  953|      6|  bool HasNoGrowthLeftAndNoDeleted() const { return growth_left_info_ == 0; }
_ZN4absl12lts_2026052618container_internal16RawHashSetLayoutC2Emmmb:
 1020|     18|            ControlOffset(has_infoz, HasGrowthInfoForCapacity(capacity))),
 1021|     18|        generation_offset_(control_offset_ + NumControlBytes(capacity)),
 1022|       |        slot_offset_(
 1023|     18|            AlignUpTo(generation_offset_ + NumGenerationBytes(), slot_align)),
 1024|     18|        alloc_size_(slot_offset_ + capacity * slot_size) {
 1025|     18|    ABSL_SWISSTABLE_ASSERT(IsValidCapacity(capacity));
  ------------------
  |  |  256|     18|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1026|       |    ABSL_SWISSTABLE_ASSERT(
  ------------------
  |  |  256|     18|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1027|     18|        slot_size <=
 1028|     18|        ((std::numeric_limits<size_t>::max)() - slot_offset_) / capacity);
 1029|     18|  }
_ZNK4absl12lts_2026052618container_internal16RawHashSetLayout14control_offsetEv:
 1033|     18|  size_t control_offset() const { return control_offset_; }
_ZNK4absl12lts_2026052618container_internal16RawHashSetLayout17generation_offsetEv:
 1037|     10|  size_t generation_offset() const { return generation_offset_; }
_ZNK4absl12lts_2026052618container_internal16RawHashSetLayout11slot_offsetEv:
 1041|     10|  size_t slot_offset() const { return slot_offset_; }
_ZNK4absl12lts_2026052618container_internal16RawHashSetLayout10alloc_sizeEv:
 1045|     26|  size_t alloc_size() const { return alloc_size_; }
_ZN4absl12lts_2026052618container_internal9HeapOrSoo7controlEv:
 1088|     10|  MaybeInitializedPtr<ctrl_t>& control() {
 1089|     10|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(heap.control);
  ------------------
  |  |  488|     10|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
 1090|     10|  }
_ZN4absl12lts_2026052618container_internal9HeapOrSoo10slot_arrayEv:
 1094|     10|  MaybeInitializedPtr<void>& slot_array() {
 1095|     10|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(heap.slot_array);
  ------------------
  |  |  488|     10|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
 1096|     10|  }
_ZN4absl12lts_2026052618container_internal12CommonFields11set_controlEPNS1_6ctrl_tE:
 1170|     10|  void set_control(ctrl_t* c) { heap_or_soo_.control().set(c); }
_ZN4absl12lts_2026052618container_internal12CommonFields9set_slotsEPv:
 1177|     10|  void set_slots(void* s) { heap_or_soo_.slot_array().set(s); }
_ZN4absl12lts_2026052618container_internal12CommonFields16set_size_to_zeroEv:
 1182|      2|  void set_size_to_zero() { inline_data_.set_size(0); }
_ZN4absl12lts_2026052618container_internal12CommonFields14increment_sizeEv:
 1191|     50|  void increment_size() {
 1192|       |    ABSL_SWISSTABLE_ASSERT(size() < capacity());
  ------------------
  |  |  256|     50|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1193|     50|    inline_data_.increment_size();
 1194|     50|  }
_ZNK4absl12lts_2026052618container_internal12CommonFields5emptyEv:
 1203|      2|  bool empty() const { return inline_data_.empty(); }
_ZN4absl12lts_2026052618container_internal12CommonFields17generate_new_seedEb:
 1216|      2|  void generate_new_seed(bool has_infoz) {
 1217|       |    // Note: we can't use has_infoz() here because we set has_infoz later than
 1218|       |    // we generate the seed.
 1219|      2|    if (ABSL_PREDICT_FALSE(has_infoz)) {
  ------------------
  |  |  190|      2|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 2]
  |  |  |  Branch (190:49): [Folded, False: 2]
  |  |  |  Branch (190:58): [True: 0, False: 2]
  |  |  ------------------
  ------------------
 1220|      0|      inline_data_.set_sampled_seed();
 1221|      0|      return;
 1222|      0|    }
 1223|      2|    inline_data_.generate_new_seed();
 1224|      2|  }
_ZN4absl12lts_2026052618container_internal12CommonFields12set_capacityENS1_21HashtableCapacityImplILNS1_28HashtableCapacityStorageModeE1EEE:
 1238|     10|  void set_capacity(HashtableCapacity c) { inline_data_.set_capacity(c); }
_ZN4absl12lts_2026052618container_internal12CommonFields12set_capacityEm:
 1239|     10|  void set_capacity(size_t c) {
 1240|     10|    set_capacity(HashtableCapacity(c));
 1241|     10|  }
_ZN4absl12lts_2026052618container_internal12CommonFields11growth_infoEv:
 1250|     94|  GrowthInfo& growth_info() {
 1251|       |    ABSL_SWISSTABLE_ASSERT(HasGrowthInfoForCapacity(capacity()));
  ------------------
  |  |  256|     94|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1252|     94|    return GetGrowthInfoFromControl(control());
 1253|     94|  }
_ZN4absl12lts_2026052618container_internal23SentinelEmptyGenerationEv:
  264|     10|constexpr GenerationType SentinelEmptyGeneration() { return 0; }
_ZN4absl12lts_2026052618container_internal14NextGenerationEh:
  266|     10|constexpr GenerationType NextGeneration(GenerationType generation) {
  267|     10|  return ++generation == SentinelEmptyGeneration() ? ++generation : generation;
  ------------------
  |  Branch (267:10): [True: 0, False: 10]
  ------------------
  268|     10|}
_ZN4absl12lts_2026052618container_internal18NumGenerationBytesEv:
  275|     18|constexpr size_t NumGenerationBytes() { return 0; }
_ZN4absl12lts_2026052618container_internal12NextCapacityEm:
  394|      6|constexpr size_t NextCapacity(size_t n) {
  395|       |  ABSL_SWISSTABLE_ASSERT(IsValidCapacity(n) || n == 0);
  ------------------
  |  |  256|      6|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  396|      6|  return n * 2 + 1;
  397|      6|}
_ZN4absl12lts_2026052618container_internal16CapacityToGrowthEm:
  415|      8|constexpr size_t CapacityToGrowth(size_t capacity) {
  416|      8|  ABSL_SWISSTABLE_ASSERT(IsValidCapacity(capacity));
  ------------------
  |  |  256|      8|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  417|       |  // `capacity*7/8`
  418|      8|  if (Group::kWidth == 8 && capacity == 7) {
  ------------------
  |  Branch (418:7): [Folded, False: 8]
  |  Branch (418:29): [True: 0, False: 0]
  ------------------
  419|       |    // x-x/8 does not work when x==7.
  420|      0|    return 6;
  421|      0|  }
  422|      8|  return capacity - capacity / 8;
  423|      8|}
_ZN4absl12lts_2026052618container_internal9AlignUpToEmm:
 1010|     18|constexpr size_t AlignUpTo(size_t offset, size_t align) {
 1011|     18|  return (offset + align - 1) & (~align + 1);
 1012|     18|}
_ZN4absl12lts_2026052618container_internal24GetGrowthInfoFromControlEPNS1_6ctrl_tE:
 1113|    102|inline GrowthInfo& GetGrowthInfoFromControl(ctrl_t* control) {
 1114|    102|  auto* gl_ptr = reinterpret_cast<GrowthInfo*>(control) - 1;
 1115|       |  ABSL_SWISSTABLE_ASSERT(
  ------------------
  |  |  256|    102|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1116|    102|      reinterpret_cast<uintptr_t>(gl_ptr) % alignof(GrowthInfo) == 0);
 1117|    102|  return *gl_ptr;
 1118|    102|}
_ZN4absl12lts_2026052618container_internal15is_single_groupEm:
 1571|      6|constexpr bool is_single_group(size_t capacity) {
 1572|      6|  return capacity <= Group::kWidth;
 1573|      6|}
_ZN4absl12lts_2026052618container_internal12SooSlotIndexEv:
 1848|      2|constexpr size_t SooSlotIndex() { return 1; }
_ZN4absl12lts_2026052618container_internal19MaybeInitializedPtrINS1_6ctrl_tEE3setEPS3_:
 1061|     10|  void set(T* ptr) { p = ptr; }
_ZN4absl12lts_2026052618container_internal19MaybeInitializedPtrIvE3setEPv:
 1061|     10|  void set(T* ptr) { p = ptr; }
_ZN4absl12lts_2026052618container_internal23HashtableInlineDataImplILNS1_28HashtableCapacityStorageModeE1EE14increment_sizeEv:
  646|     50|  void increment_size() { data_ += kSizeOneNoMetadata; }
_ZNK4absl12lts_2026052618container_internal23HashtableInlineDataImplILNS1_28HashtableCapacityStorageModeE1EE5emptyEv:
  652|      2|  bool empty() const { return data_ < kSizeOneNoMetadata; }
_ZN4absl12lts_2026052618container_internal23HashtableInlineDataImplILNS1_28HashtableCapacityStorageModeE1EE8set_seedEh:
  712|      2|  void set_seed(typename PerTableSeed::IntType seed) {
  713|      2|    data_ = (data_ & ~kSeedMask) | seed;
  714|      2|  }
_ZN4absl12lts_2026052618container_internal23HashtableInlineDataImplILNS1_28HashtableCapacityStorageModeE1EE17generate_new_seedEv:
  670|      2|  void generate_new_seed() {
  671|      2|    set_seed(static_cast<typename PerTableSeed::IntType>(NextHashTableSeed()));
  672|      2|  }
_ZN4absl12lts_2026052618container_internal23HashtableInlineDataImplILNS1_28HashtableCapacityStorageModeE1EE12set_capacityENS1_21HashtableCapacityImplILS3_1EEE:
  641|     10|  void set_capacity(HashtableCapacity c) { capacity_internal_ = c.ToRawData(); }
_ZN4absl12lts_2026052618container_internal20TransferNRelocatableILm24EEEvPvS3_S3_m:
 1955|      6|                                                  size_t count) {
 1956|       |  // TODO(b/382423690): Experiment with making specialization for power of 2 and
 1957|       |  // non power of 2. This would require passing the size of the slot.
 1958|      6|  memcpy(dst, src, SizeOfSlot * count);
 1959|      6|}
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE8capacityEv:
 2601|      2|  size_t capacity() const {
 2602|      2|    const size_t cap = common().capacity();
 2603|       |    // Compiler complains when using functions in ASSUME so use local variables.
 2604|      2|    [[maybe_unused]] const bool kIsValid = IsValidCapacity(cap);
 2605|      2|    [[maybe_unused]] const size_t kDefaultCapacity = DefaultCapacity();
 2606|      2|    [[maybe_unused]] const size_t kMaxValidCapacity = MaxValidCapacity();
 2607|      2|    ABSL_ASSUME(kIsValid || cap == 0);
  ------------------
  |  |  271|      2|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  |  |  ------------------
  |  |  |  Branch (271:44): [True: 2, False: 0]
  |  |  |  Branch (271:44): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2608|      2|    ABSL_ASSUME(cap >= kDefaultCapacity);
  ------------------
  |  |  271|      2|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2609|      2|    ABSL_ASSUME(cap <= kMaxValidCapacity);
  ------------------
  |  |  271|      2|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2610|      2|    return cap;
 2611|      2|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE6commonEv:
 3719|    376|  const CommonFields& common() const { return settings_.template get<0>(); }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE8is_smallEv:
 2117|     54|  bool is_small() const { return common().is_small(); }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE5emptyEv:
 2593|      6|  bool empty() const { return !size(); }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE6commonEv:
 3718|    236|  CommonFields& common() { return settings_.template get<0>(); }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE14char_alloc_refEv:
 3772|     80|  CharAlloc& char_alloc_ref() { return settings_.template get<3>(); }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE11single_slotEv:
 3743|      2|  slot_type* single_slot() {
 3744|      2|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  256|      2|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3745|      2|    return SooEnabled() ? soo_slot() : slot_array();
  ------------------
  |  Branch (3745:12): [Folded, False: 2]
  ------------------
 3746|      2|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE10slot_arrayEv:
 3730|     98|  slot_type* slot_array() const {
 3731|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  256|     98|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3732|     98|    return static_cast<slot_type*>(common().slot_array());
 3733|     98|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE13destroy_slotsEv:
 3280|      2|  void destroy_slots() {
 3281|      2|    ABSL_SWISSTABLE_ASSERT(!is_small());
  ------------------
  |  |  256|      2|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3282|      2|    if (PolicyTraits::template destroy_is_trivial<Alloc>()) return;
  ------------------
  |  Branch (3282:9): [True: 2, Folded]
  ------------------
 3283|      0|    auto destroy_slot = [&](const ctrl_t*, void* slot) {
 3284|      0|      this->destroy(static_cast<slot_type*>(slot));
 3285|      0|    };
 3286|       |    if constexpr (SwisstableAssertAccessToDestroyedTable()) {
 3287|       |      CommonFields common_copy(non_soo_tag_t{}, this->common());
 3288|       |      common().set_capacity(HashtableCapacity::CreateDestroyed());
 3289|       |      IterateOverFullSlots(common_copy, sizeof(slot_type), destroy_slot);
 3290|       |      common().set_capacity(common_copy.capacity());
 3291|      0|    } else {
 3292|      0|      IterateOverFullSlots(common(), sizeof(slot_type), destroy_slot);
 3293|      0|    }
 3294|      0|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE7controlEv:
 3726|    140|  ctrl_t* control() const {
 3727|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  256|    140|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3728|    140|    return common().control();
 3729|    140|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE12AssertOnFindIS8_EEvRKT_:
 3567|     50|  void AssertOnFind([[maybe_unused]] const K& key) {
 3568|     50|    AssertHashEqConsistent(key);
 3569|     50|    AssertNotDebugCapacity();
 3570|     50|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE22AssertHashEqConsistentIS8_EEvRKT_:
 3605|     50|  void AssertHashEqConsistent(const K& key) {
 3606|     50|#ifdef NDEBUG
 3607|     50|    return;
 3608|      0|#endif
 3609|       |    // If the hash/eq functors are known to be consistent, then skip validation.
 3610|      0|    if (std::is_same<hasher, absl::container_internal::StringHash>::value &&
  ------------------
  |  Branch (3610:9): [True: 0, Folded]
  ------------------
 3611|      0|        std::is_same<key_equal, absl::container_internal::StringEq>::value) {
  ------------------
  |  Branch (3611:9): [True: 0, Folded]
  ------------------
 3612|      0|      return;
 3613|      0|    }
 3614|      0|    if (std::is_scalar<key_type>::value &&
  ------------------
  |  Branch (3614:9): [Folded, False: 0]
  ------------------
 3615|      0|        std::is_same<hasher, absl::Hash<key_type>>::value &&
  ------------------
  |  Branch (3615:9): [Folded, False: 0]
  ------------------
 3616|      0|        std::is_same<key_equal, std::equal_to<key_type>>::value) {
  ------------------
  |  Branch (3616:9): [Folded, False: 0]
  ------------------
 3617|      0|      return;
 3618|      0|    }
 3619|      0|    if (empty()) return;
  ------------------
  |  Branch (3619:9): [True: 0, False: 0]
  ------------------
 3620|       |
 3621|      0|    const size_t hash_of_arg = hash_of(key);
 3622|      0|    const auto assert_consistent = [&](const ctrl_t*, void* slot) {
 3623|      0|      const bool is_key_equal = equal_to(key, to_slot(slot));
 3624|      0|      if (!is_key_equal) return;
 3625|       |
 3626|      0|      [[maybe_unused]] const bool is_hash_equal =
 3627|      0|          hash_of_arg == hash_of(to_slot(slot));
 3628|      0|      assert((!is_key_equal || is_hash_equal) &&
 3629|      0|             "eq(k1, k2) must imply that hash(k1) == hash(k2). "
 3630|      0|             "hash/eq functors are inconsistent.");
 3631|      0|    };
 3632|       |
 3633|      0|    if (is_small()) {
  ------------------
  |  Branch (3633:9): [True: 0, False: 0]
  ------------------
 3634|      0|      assert_consistent(/*unused*/ nullptr, single_slot());
 3635|      0|      return;
 3636|      0|    }
 3637|       |    // We only do validation for small tables so that it's constant time.
 3638|      0|    if (capacity() > 16) return;
  ------------------
  |  Branch (3638:9): [True: 0, False: 0]
  ------------------
 3639|      0|    IterateOverFullSlots(common(), sizeof(slot_type), assert_consistent);
 3640|      0|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE22AssertNotDebugCapacityEv:
 3573|     62|  void AssertNotDebugCapacity() const {
 3574|     62|#ifdef NDEBUG
 3575|     62|    if (!SwisstableGenerationsEnabled()) {
  ------------------
  |  Branch (3575:9): [True: 62, Folded]
  ------------------
 3576|     62|      return;
 3577|     62|    }
 3578|      0|#endif
 3579|      0|    const HashtableCapacity cap = maybe_invalid_capacity();
 3580|      0|    if (ABSL_PREDICT_TRUE(cap.IsValid())) {
  ------------------
  |  |  191|      0|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 0, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 0]
  |  |  |  Branch (191:57): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 3581|      0|      return;
 3582|      0|    }
 3583|      0|    assert(!cap.IsReentrance() &&
 3584|      0|           "Reentrant container access during element construction/destruction "
 3585|      0|           "is not allowed.");
 3586|       |    if constexpr (SwisstableAssertAccessToDestroyedTable()) {
 3587|       |      if (cap.IsDestroyed()) {
 3588|       |        ABSL_RAW_LOG(FATAL, "Use of destroyed hash table.");
 3589|       |      }
 3590|       |    }
 3591|      0|    if (SwisstableGenerationsEnabled() &&
  ------------------
  |  Branch (3591:9): [Folded, False: 0]
  ------------------
 3592|      0|        ABSL_PREDICT_FALSE(cap.IsMovedFrom())) {
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 3593|      0|      if (cap.IsSelfMovedFrom()) {
  ------------------
  |  Branch (3593:11): [True: 0, False: 0]
  ------------------
 3594|       |        // If this log triggers, then a hash table was move-assigned to itself
 3595|       |        // and then used again later without being reinitialized.
 3596|      0|        ABSL_RAW_LOG(FATAL, "Use of self-move-assigned hash table.");
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 3597|      0|      }
 3598|      0|      ABSL_RAW_LOG(FATAL, "Use of moved-from hash table.");
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 3599|      0|    }
 3600|      0|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE8equal_toIS8_EEbRKT_PNS1_13map_slot_typeIS8_SA_EE:
 3344|      4|                                             slot_type* slot) const {
 3345|      4|    return PolicyTraits::apply(EqualElement<K, key_equal>{key, eq_ref()},
 3346|      4|                               PolicyTraits::element(slot));
 3347|      4|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE6eq_refEv:
 3771|      4|  const key_equal& eq_ref() const { return settings_.template get<2>(); }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE8iteratorC2EPNS1_6ctrl_tEPNS1_13map_slot_typeIS8_SA_EEPKh:
 2236|     50|        : HashSetIteratorGenerationInfo(generation_ptr),
 2237|     50|          ctrl_(ctrl),
 2238|     50|          slot_(slot) {
 2239|       |      // This assumption helps the compiler know that any non-end iterator is
 2240|       |      // not equal to any end iterator.
 2241|     50|      ABSL_ASSUME(ctrl != nullptr);
  ------------------
  |  |  271|     50|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2242|     50|    }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE19prefetch_heap_blockEv:
 3711|     46|  void prefetch_heap_block() const {
 3712|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  256|     46|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3713|     46|#if ABSL_HAVE_BUILTIN(__builtin_prefetch) || defined(__GNUC__)
 3714|     46|    __builtin_prefetch(control(), 0, 1);
 3715|     46|#endif
 3716|     46|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE11iterator_atEm:
 3671|     46|  iterator iterator_at(size_t i) ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3672|     46|    return {control() + i, slot_array() + i, common().generation_ptr()};
 3673|     46|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE7hash_ofIS8_EEmRKT_:
 3349|     46|  ABSL_ATTRIBUTE_ALWAYS_INLINE size_t hash_of(const K& key) const {
 3350|     46|    return HashElement<hasher, kIsDefaultHash>{hash_ref(),
 3351|     46|                                               common().seed().seed()}(key);
 3352|     46|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE8hash_refEv:
 3769|     74|  const hasher& hash_ref() const { return settings_.template get<1>(); }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE3endEv:
 2577|      2|  iterator end() ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2578|      2|    AssertNotDebugCapacity();
 2579|      2|    return iterator(common().generation_ptr());
 2580|      2|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE8iteratorC2EPKh:
 2257|      2|        : HashSetIteratorGenerationInfo(generation_ptr), ctrl_(nullptr) {}
_ZN4absl12lts_2026052618container_internalneERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE8iteratorESF_:
 2229|     52|    friend bool operator!=(const iterator& a, const iterator& b) {
 2230|     52|      return !(a == b);
 2231|     52|    }
_ZN4absl12lts_2026052618container_internaleqERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE8iteratorESF_:
 2222|     52|    friend bool operator==(const iterator& a, const iterator& b) {
 2223|     52|      AssertIsValidForComparison(a.ctrl_, a.generation(), a.generation_ptr());
 2224|     52|      AssertIsValidForComparison(b.ctrl_, b.generation(), b.generation_ptr());
 2225|     52|      AssertSameContainer(a.ctrl_, b.ctrl_, a.slot_, b.slot_,
 2226|     52|                          a.generation_ptr(), b.generation_ptr());
 2227|     52|      return a.ctrl_ == b.ctrl_;
 2228|     52|    }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE8iterator14assert_is_fullEPKc:
 2259|    100|    void assert_is_full(const char* operation) const {
 2260|    100|      AssertIsFull(ctrl_, generation(), generation_ptr(), operation);
 2261|    100|    }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE6insertINS4_4pairIKS8_SA_EELi0EEENSE_INSC_8iteratorEbEEOT_:
 2653|     50|  std::pair<iterator, bool> insert(T&& value) ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2654|     50|    return emplace(std::forward<T>(value));
 2655|     50|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE7emplaceIJNS4_4pairIKS8_SA_EEETnNS4_9enable_ifIXsr14IsDecomposableIDpT_EE5valueEiE4typeELi0EEENSE_INSC_8iteratorEbEEDpOSI_:
 2799|     50|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2800|     50|    return PolicyTraits::apply(EmplaceDecomposable{*this},
 2801|     50|                               std::forward<Args>(args)...);
 2802|     50|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE19EmplaceDecomposableclIS8_JRKNS4_21piecewise_construct_tENS4_5tupleIJOKS8_EEENSI_IJOSA_EEEEEENS4_4pairINSC_8iteratorEbEERKT_DpOT0_:
 3177|     50|    std::pair<iterator, bool> operator()(const K& key, Args&&... args) const {
 3178|     50|      auto res = s.find_or_prepare_insert(key);
 3179|     50|      if (res.second) {
  ------------------
  |  Branch (3179:11): [True: 50, False: 0]
  ------------------
 3180|     50|        s.emplace_at(res.first, std::forward<Args>(args)...);
 3181|     50|      }
 3182|     50|      return res;
 3183|     50|    }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE22find_or_prepare_insertIS8_EENS4_4pairINSC_8iteratorEbEERKT_:
 3646|     50|  std::pair<iterator, bool> find_or_prepare_insert(const K& key) {
 3647|     50|    AssertOnFind(key);
 3648|     50|    if (is_small()) return find_or_prepare_insert_small(key);
  ------------------
  |  Branch (3648:9): [True: 4, False: 46]
  ------------------
 3649|     46|    return find_or_prepare_insert_large(key);
 3650|     50|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE28find_or_prepare_insert_smallIS8_EENS4_4pairINSC_8iteratorEbEERKT_:
 3497|      4|  std::pair<iterator, bool> find_or_prepare_insert_small(const K& key) {
 3498|      4|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  256|      4|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3499|       |    if constexpr (SooEnabled()) {
 3500|       |      return find_or_prepare_insert_soo(key);
 3501|       |    }
 3502|      4|    if (!empty()) {
  ------------------
  |  Branch (3502:9): [True: 2, False: 2]
  ------------------
 3503|      2|      if (equal_to(key, single_slot())) {
  ------------------
  |  Branch (3503:11): [True: 0, False: 2]
  ------------------
 3504|      0|        return {single_iterator(), false};
 3505|      0|      }
 3506|      2|    }
 3507|      4|    return {iterator_at_ptr(PrepareInsertSmallNonSoo(
 3508|      4|                common(), GetPolicyFunctions(),
 3509|      4|                HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})),
 3510|      4|            true};
 3511|      4|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE15iterator_at_ptrENS4_4pairIPNS1_6ctrl_tEPvEE:
 3678|      4|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3679|      4|    return {ptrs.first, to_slot(ptrs.second), common().generation_ptr()};
 3680|      4|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE7to_slotEPv:
 3361|      8|  static ABSL_ATTRIBUTE_ALWAYS_INLINE slot_type* to_slot(void* buf) {
 3362|      8|    return static_cast<slot_type*>(buf);
 3363|      8|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE18GetPolicyFunctionsEv:
 3851|     52|  static const PolicyFunctions& GetPolicyFunctions() {
 3852|     52|    static_assert(sizeof(slot_type) <= (std::numeric_limits<uint32_t>::max)(),
 3853|     52|                  "Slot size is too large. Use std::unique_ptr for value type "
 3854|     52|                  "or use absl::node_hash_{map,set}.");
 3855|     52|    static_assert(alignof(slot_type) <=
 3856|     52|                  size_t{(std::numeric_limits<uint16_t>::max)()});
 3857|     52|    static_assert(sizeof(key_type) <=
 3858|     52|                  size_t{(std::numeric_limits<uint32_t>::max)()});
 3859|     52|    static_assert(sizeof(value_type) <=
 3860|     52|                  size_t{(std::numeric_limits<uint32_t>::max)()});
 3861|     52|    static constexpr size_t kBackingArrayAlignment =
 3862|     52|        BackingArrayAlignment(alignof(slot_type));
 3863|     52|    static constexpr PolicyFunctions value = {
 3864|     52|        static_cast<uint32_t>(sizeof(key_type)),
 3865|     52|        static_cast<uint32_t>(sizeof(value_type)),
 3866|     52|        static_cast<uint32_t>(sizeof(slot_type)),
 3867|     52|        static_cast<uint16_t>(alignof(slot_type)), SooEnabled(),
 3868|     52|        ShouldSampleHashtablezInfoForAlloc<CharAlloc>(),
 3869|       |        // TODO(b/328722020): try to type erase
 3870|       |        // for standard layout and alignof(Hash) <= alignof(CommonFields).
 3871|     52|        std::is_empty_v<hasher> ? &GetRefForEmptyClass
  ------------------
  |  Branch (3871:9): [True: 0, Folded]
  ------------------
 3872|     52|                                : &raw_hash_set::get_hash_ref_fn,
 3873|     52|        PolicyTraits::template get_hash_slot_fn<hasher, kIsDefaultHash>(),
 3874|     52|        PolicyTraits::transfer_uses_memcpy()
  ------------------
  |  Branch (3874:9): [True: 0, Folded]
  ------------------
 3875|     52|            ? TransferNRelocatable<sizeof(slot_type)>
 3876|     52|            : &raw_hash_set::transfer_n_slots_fn,
 3877|     52|        std::is_empty_v<Alloc> ? &GetRefForEmptyClass
  ------------------
  |  Branch (3877:9): [True: 0, Folded]
  ------------------
 3878|     52|                               : &raw_hash_set::get_char_alloc_ref_fn,
 3879|     52|        &AllocateBackingArray<kBackingArrayAlignment, CharAlloc>,
 3880|     52|        &DeallocateBackingArray<kBackingArrayAlignment, CharAlloc>,
 3881|     52|        &raw_hash_set::transfer_unprobed_elements_to_next_capacity_fn};
 3882|     52|    return value;
 3883|     52|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE46transfer_unprobed_elements_to_next_capacity_fnERNS1_12CommonFieldsEPKNS1_6ctrl_tEPvSI_PFvSI_hmmE:
 3804|      2|                                    size_t source_offset, size_t h1)) {
 3805|      2|    const size_t new_capacity = common.capacity();
 3806|      2|    const size_t old_capacity = PreviousCapacity(new_capacity);
 3807|      2|    ABSL_ASSUME(old_capacity + 1 >= Group::kWidth);
  ------------------
  |  |  271|      2|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 3808|      2|    ABSL_ASSUME((old_capacity + 1) % Group::kWidth == 0);
  ------------------
  |  |  271|      2|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 3809|       |
 3810|      2|    auto* set = reinterpret_cast<raw_hash_set*>(&common);
 3811|      2|    slot_type* old_slots_ptr = to_slot(old_slots);
 3812|      2|    ctrl_t* new_ctrl = common.control();
 3813|      2|    slot_type* new_slots = set->slot_array();
 3814|       |
 3815|      4|    for (size_t group_index = 0; group_index < old_capacity;
  ------------------
  |  Branch (3815:34): [True: 2, False: 2]
  ------------------
 3816|      2|         group_index += Group::kWidth) {
 3817|      2|      GroupFullEmptyOrDeleted old_g(old_ctrl + group_index);
 3818|      2|      std::memset(new_ctrl + group_index, static_cast<int8_t>(ctrl_t::kEmpty),
 3819|      2|                  Group::kWidth);
 3820|      2|      std::memset(new_ctrl + group_index + old_capacity + 1,
 3821|      2|                  static_cast<int8_t>(ctrl_t::kEmpty), Group::kWidth);
 3822|       |      // TODO(b/382423690): try to type erase everything outside of the loop.
 3823|       |      // We will share a lot of code in expense of one function call per group.
 3824|     28|      for (auto in_fixed_group_index : old_g.MaskFull()) {
  ------------------
  |  Branch (3824:38): [True: 28, False: 2]
  ------------------
 3825|     28|        size_t old_index = group_index + in_fixed_group_index;
 3826|     28|        slot_type* old_slot = old_slots_ptr + old_index;
 3827|       |        // TODO(b/382423690): try to avoid entire hash calculation since we need
 3828|       |        // only one new bit of h1.
 3829|     28|        size_t hash = set->hash_of(old_slot);
 3830|     28|        size_t h1 = H1(hash);
 3831|     28|        h2_t h2 = H2(hash);
 3832|     28|        size_t new_index = TryFindNewIndexWithoutProbing(
 3833|     28|            h1, old_index, old_capacity, new_ctrl, new_capacity);
 3834|       |        // Note that encode_probed_element is allowed to use old_ctrl buffer
 3835|       |        // till and included the old_index.
 3836|     28|        if (ABSL_PREDICT_FALSE(new_index == kProbedElementIndexSentinel)) {
  ------------------
  |  |  190|     28|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 28]
  |  |  |  Branch (190:49): [Folded, False: 28]
  |  |  |  Branch (190:58): [True: 0, False: 28]
  |  |  ------------------
  ------------------
 3837|      0|          encode_probed_element(probed_storage, h2, old_index, h1);
 3838|      0|          continue;
 3839|      0|        }
 3840|     28|        ABSL_SWISSTABLE_ASSERT((new_index & old_capacity) <= old_index);
  ------------------
  |  |  256|     28|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3841|       |        ABSL_SWISSTABLE_ASSERT(IsEmpty(new_ctrl[new_index]));
  ------------------
  |  |  256|     28|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3842|     28|        new_ctrl[new_index] = static_cast<ctrl_t>(h2);
 3843|     28|        auto* new_slot = new_slots + new_index;
 3844|     28|        SanitizerUnpoisonMemoryRegion(new_slot, sizeof(slot_type));
 3845|     28|        set->transfer(new_slot, old_slot);
 3846|     28|        SanitizerPoisonMemoryRegion(old_slot, sizeof(slot_type));
 3847|     28|      }
 3848|      2|    }
 3849|      2|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE7hash_ofEPNS1_13map_slot_typeIS8_SA_EE:
 3353|     28|  ABSL_ATTRIBUTE_ALWAYS_INLINE size_t hash_of(slot_type* slot) const {
 3354|     28|    return PolicyTraits::apply(
 3355|     28|        HashElement<hasher, kIsDefaultHash>{hash_ref(), common().seed().seed()},
 3356|     28|        PolicyTraits::element(slot));
 3357|     28|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE8transferEPNS1_13map_slot_typeIS8_SA_EESF_:
 3217|     28|  inline void transfer(slot_type* to, slot_type* from) {
 3218|     28|    common().RunWithReentrancyGuard([&] {
 3219|     28|      allocator_type alloc(char_alloc_ref());
 3220|     28|      PolicyTraits::transfer(&alloc, to, from);
 3221|     28|    });
 3222|     28|  }
_ZN4absl12lts_2026052618container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE8transferEPNS1_13map_slot_typeISA_SC_EESH_EUlvE_EEvT_:
 1322|     28|  void RunWithReentrancyGuard(F f) {
 1323|     28|#ifdef NDEBUG
 1324|     28|    f();
 1325|     28|    return;
 1326|      0|#endif
 1327|      0|    const HashtableCapacity cap = maybe_invalid_capacity();
 1328|      0|    set_capacity(HashtableCapacity::CreateReentrance());
 1329|      0|    f();
 1330|      0|    set_capacity(cap);
 1331|      0|  }
_ZZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE8transferEPNS1_13map_slot_typeIS8_SA_EESF_ENKUlvE_clEv:
 3218|     28|    common().RunWithReentrancyGuard([&] {
 3219|     28|      allocator_type alloc(char_alloc_ref());
 3220|     28|      PolicyTraits::transfer(&alloc, to, from);
 3221|     28|    });
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE8hash_refEv:
 3768|      4|  hasher& hash_ref() { return settings_.template get<1>(); }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE28find_or_prepare_insert_largeIS8_EENS4_4pairINSC_8iteratorEbEERKT_:
 3514|     46|  std::pair<iterator, bool> find_or_prepare_insert_large(const K& key) {
 3515|     46|    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  256|     46|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3516|     46|    prefetch_heap_block();
 3517|     46|    const size_t hash = hash_of(key);
 3518|     46|    auto seq = probe(common(), hash);
 3519|     46|    const h2_t h2 = H2(hash);
 3520|     46|    const ctrl_t* ctrl = control();
 3521|     46|    size_t index;
 3522|     46|    bool inserted;
 3523|       |    // We use a lambda function to be able to exit from the nested loop without
 3524|       |    // duplicating generated code for the return statement (e.g. iterator_at).
 3525|     46|    [&]() ABSL_ATTRIBUTE_ALWAYS_INLINE {
 3526|     46|      while (true) {
 3527|     46|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3528|     46|        absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3529|     46|#endif
 3530|     46|        Group g{ctrl + seq.offset()};
 3531|     46|        for (uint32_t i : g.Match(h2)) {
 3532|     46|          if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i)))) {
 3533|     46|            index = seq.offset(i);
 3534|     46|            inserted = false;
 3535|     46|            return;
 3536|     46|          }
 3537|     46|        }
 3538|     46|        auto mask_empty = g.MaskEmpty();
 3539|     46|        if (ABSL_PREDICT_TRUE(mask_empty)) {
 3540|     46|          size_t target_group_offset = seq.offset();
 3541|     46|          index = SwisstableGenerationsEnabled()
 3542|     46|                      ? PrepareInsertLargeGenerationsEnabled(
 3543|     46|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3544|     46|                            FindInfo{target_group_offset, seq.index()},
 3545|     46|                            HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})
 3546|     46|                      : PrepareInsertLarge(
 3547|     46|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3548|     46|                            FindInfo{target_group_offset, seq.index()});
 3549|     46|          inserted = true;
 3550|     46|          return;
 3551|     46|        }
 3552|     46|        seq.next();
 3553|     46|        ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
 3554|     46|      }
 3555|     46|    }();
 3556|     46|    return {iterator_at(index), inserted};
 3557|     46|  }
_ZZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE28find_or_prepare_insert_largeIS8_EENS4_4pairINSC_8iteratorEbEERKT_ENKUlvE_clEv:
 3525|     46|    [&]() ABSL_ATTRIBUTE_ALWAYS_INLINE {
 3526|     46|      while (true) {
  ------------------
  |  Branch (3526:14): [True: 46, Folded]
  ------------------
 3527|     46|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3528|     46|        absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3529|     46|#endif
 3530|     46|        Group g{ctrl + seq.offset()};
 3531|     46|        for (uint32_t i : g.Match(h2)) {
  ------------------
  |  Branch (3531:25): [True: 2, False: 46]
  ------------------
 3532|      2|          if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i)))) {
  ------------------
  |  |  191|      2|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 0, False: 2]
  |  |  |  Branch (191:48): [Folded, False: 2]
  |  |  |  Branch (191:57): [True: 0, False: 2]
  |  |  ------------------
  ------------------
 3533|      0|            index = seq.offset(i);
 3534|      0|            inserted = false;
 3535|      0|            return;
 3536|      0|          }
 3537|      2|        }
 3538|     46|        auto mask_empty = g.MaskEmpty();
 3539|     46|        if (ABSL_PREDICT_TRUE(mask_empty)) {
  ------------------
  |  |  191|     46|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 46, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 46]
  |  |  |  Branch (191:57): [True: 46, False: 0]
  |  |  ------------------
  ------------------
 3540|     46|          size_t target_group_offset = seq.offset();
 3541|     46|          index = SwisstableGenerationsEnabled()
  ------------------
  |  Branch (3541:19): [Folded, False: 46]
  ------------------
 3542|     46|                      ? PrepareInsertLargeGenerationsEnabled(
 3543|      0|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3544|      0|                            FindInfo{target_group_offset, seq.index()},
 3545|      0|                            HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})
 3546|     46|                      : PrepareInsertLarge(
 3547|     46|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3548|     46|                            FindInfo{target_group_offset, seq.index()});
 3549|     46|          inserted = true;
 3550|     46|          return;
 3551|     46|        }
 3552|      0|        seq.next();
 3553|       |        ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
  ------------------
  |  |  256|      0|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3554|      0|      }
 3555|     46|    }();
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE10emplace_atIJRKNS4_21piecewise_construct_tENS4_5tupleIJOKS8_EEENSH_IJOSA_EEEEEEvNSC_8iteratorEDpOT_:
 3661|     50|  void emplace_at(iterator iter, Args&&... args) {
 3662|     50|    construct(iter.slot(), std::forward<Args>(args)...);
 3663|       |
 3664|       |    // When is_small, find calls find_small and if size is 0, then it will
 3665|       |    // return an end iterator. This can happen in the raw_hash_set copy ctor.
 3666|       |    assert((is_small() ||
 3667|     50|            PolicyTraits::apply(FindElement{*this}, *iter) == iter) &&
 3668|     50|           "constructed value does not match the lookup key");
 3669|     50|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE9constructIJRKNS4_21piecewise_construct_tENS4_5tupleIJOKS8_EEENSH_IJOSA_EEEEEEvPNS1_13map_slot_typeIS8_SA_EEDpOT_:
 3205|     50|  inline void construct(slot_type* slot, Args&&... args) {
 3206|     50|    common().RunWithReentrancyGuard([&] {
 3207|     50|      allocator_type alloc(char_alloc_ref());
 3208|     50|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 3209|     50|    });
 3210|     50|  }
_ZN4absl12lts_2026052618container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE9constructIJRKNS6_21piecewise_construct_tENS6_5tupleIJOKSA_EEENSJ_IJOSC_EEEEEEvPNS1_13map_slot_typeISA_SC_EEDpOT_EUlvE_EEvT_:
 1322|     50|  void RunWithReentrancyGuard(F f) {
 1323|     50|#ifdef NDEBUG
 1324|     50|    f();
 1325|     50|    return;
 1326|      0|#endif
 1327|      0|    const HashtableCapacity cap = maybe_invalid_capacity();
 1328|      0|    set_capacity(HashtableCapacity::CreateReentrance());
 1329|      0|    f();
 1330|      0|    set_capacity(cap);
 1331|      0|  }
_ZZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE9constructIJRKNS4_21piecewise_construct_tENS4_5tupleIJOKS8_EEENSH_IJOSA_EEEEEEvPNS1_13map_slot_typeIS8_SA_EEDpOT_ENKUlvE_clEv:
 3206|     50|    common().RunWithReentrancyGuard([&] {
 3207|     50|      allocator_type alloc(char_alloc_ref());
 3208|     50|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 3209|     50|    });
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE8iterator4slotEv:
 2285|     50|    slot_type* slot() const { return slot_; }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE5beginEv:
 2568|      2|  iterator begin() ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2569|      2|    if (ABSL_PREDICT_FALSE(empty())) return end();
  ------------------
  |  |  190|      2|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 2]
  |  |  |  Branch (190:49): [Folded, False: 2]
  |  |  |  Branch (190:58): [True: 0, False: 2]
  |  |  ------------------
  ------------------
 2570|      2|    if (is_small()) return single_iterator();
  ------------------
  |  Branch (2570:9): [True: 0, False: 2]
  ------------------
 2571|      2|    iterator it = {control(), common().slots_union(),
 2572|      2|                   common().generation_ptr()};
 2573|      2|    it.skip_empty_or_deleted();
 2574|       |    ABSL_SWISSTABLE_ASSERT(IsFull(*it.control()));
  ------------------
  |  |  256|      2|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2575|      2|    return it;
 2576|      2|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE8iteratorC2EPNS1_6ctrl_tENS1_19MaybeInitializedPtrIvEEPKh:
 2248|      2|        : HashSetIteratorGenerationInfo(generation_ptr),
 2249|      2|          ctrl_(ctrl),
 2250|      2|          slot_(to_slot(slot.get())) {
 2251|       |      // This assumption helps the compiler know that any non-end iterator is
 2252|       |      // not equal to any end iterator.
 2253|      2|      ABSL_ASSUME(ctrl != nullptr);
  ------------------
  |  |  271|      2|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2254|      2|    }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE8iterator21skip_empty_or_deletedEv:
 2265|     52|    void skip_empty_or_deleted() {
 2266|     64|      while (IsEmptyOrDeleted(*ctrl_)) {
  ------------------
  |  Branch (2266:14): [True: 12, False: 52]
  ------------------
 2267|     12|        ++ctrl_;
 2268|     12|        ++slot_;
 2269|     12|      }
 2270|     52|    }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE8iteratorppEv:
 2207|     50|    iterator& operator++() {
 2208|     50|      assert_is_full("operator++");
 2209|     50|      ++ctrl_;
 2210|     50|      ++slot_;
 2211|     50|      skip_empty_or_deleted();
 2212|     50|      if (ABSL_PREDICT_FALSE(*ctrl_ == ctrl_t::kSentinel)) ctrl_ = nullptr;
  ------------------
  |  |  190|     50|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 2, False: 48]
  |  |  |  Branch (190:49): [Folded, False: 50]
  |  |  |  Branch (190:58): [True: 2, False: 48]
  |  |  ------------------
  ------------------
 2213|     50|      return *this;
 2214|     50|    }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE8iteratordeEv:
 2195|     50|    reference operator*() const {
 2196|     50|      assert_is_full("operator*()");
 2197|     50|      return unchecked_deref();
 2198|     50|    }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE8iterator15unchecked_derefEv:
 2282|     50|    reference unchecked_deref() const { return PolicyTraits::element(slot_); }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE4sizeEv:
 2594|      8|  size_t size() const {
 2595|      8|    AssertNotDebugCapacity();
 2596|      8|    const size_t size = common().size();
 2597|      8|    [[maybe_unused]] const size_t kMaxValidSize = MaxValidSize();
 2598|      8|    ABSL_ASSUME(size <= kMaxValidSize);
  ------------------
  |  |  271|      8|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2599|      8|    return size;
 2600|      8|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE5clearEv:
 2614|      2|  ABSL_ATTRIBUTE_REINITIALIZES void clear() {
 2615|      2|    if (SwisstableGenerationsEnabled() &&
  ------------------
  |  Branch (2615:9): [Folded, False: 2]
  |  Branch (2615:9): [Folded, False: 2]
  ------------------
 2616|      0|        maybe_invalid_capacity().IsMovedFrom()) {
  ------------------
  |  Branch (2616:9): [True: 0, False: 0]
  ------------------
 2617|      0|      common().set_capacity(DefaultCapacity());
 2618|      0|    }
 2619|      2|    AssertNotDebugCapacity();
 2620|       |    // Iterating over this container is O(bucket_count()). When bucket_count()
 2621|       |    // is much greater than size(), iteration becomes prohibitively expensive.
 2622|       |    // For clear() it is more important to reuse the allocated array when the
 2623|       |    // container is small because allocation takes comparatively long time
 2624|       |    // compared to destruction of the elements of the container. So we pick the
 2625|       |    // largest bucket_count() threshold for which iteration is still fast and
 2626|       |    // past that we simply deallocate the array.
 2627|      2|    const size_t cap = capacity();
 2628|      2|    if (cap == 0) {
  ------------------
  |  Branch (2628:9): [True: 0, False: 2]
  ------------------
 2629|       |      // Already guaranteed to be empty; so nothing to do.
 2630|      2|    } else if (is_small()) {
  ------------------
  |  Branch (2630:16): [True: 0, False: 2]
  ------------------
 2631|      0|      if (!empty()) {
  ------------------
  |  Branch (2631:11): [True: 0, False: 0]
  ------------------
 2632|      0|        destroy(single_slot());
 2633|      0|        decrement_small_size();
 2634|      0|      }
 2635|      2|    } else {
 2636|      2|      destroy_slots();
 2637|      2|      clear_backing_array(/*reuse=*/cap < 128);
 2638|      2|    }
 2639|      2|    common().set_reserved_growth(0);
 2640|      2|    common().set_reservation_size(0);
 2641|      2|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEE19clear_backing_arrayEb:
 3275|      2|  void clear_backing_array(bool reuse) {
 3276|       |    ABSL_SWISSTABLE_ASSERT(capacity() > MaxSmallCapacity());
  ------------------
  |  |  256|      2|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3277|      2|    ClearBackingArray(common(), GetPolicyFunctions(), &char_alloc_ref(), reuse);
 3278|      2|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEJEEC2Ev:
 2352|      2|      std::is_nothrow_default_constructible<allocator_type>::value) {}
_ZN4absl12lts_2026052618container_internal20AllocateBackingArrayILm8ENSt3__19allocatorIcEEEEPvS6_m:
 1722|     10|void* AllocateBackingArray(void* alloc, size_t n) {
 1723|     10|  return Allocate<AlignOfBackingArray>(static_cast<Alloc*>(alloc), n);
 1724|     10|}
_ZN4absl12lts_2026052618container_internal22DeallocateBackingArrayILm8ENSt3__19allocatorIcEEEEvPvmPNS1_6ctrl_tEmmb:
 1731|      8|    size_t slot_align, bool had_infoz) {
 1732|      8|  RawHashSetLayout layout(capacity, slot_size, slot_align, had_infoz);
 1733|      8|  void* backing_array = ctrl - layout.control_offset();
 1734|       |  // Unpoison before returning the memory to the allocator.
 1735|      8|  SanitizerUnpoisonMemoryRegion(backing_array, layout.alloc_size());
 1736|      8|  Deallocate<AlignOfBackingArray>(static_cast<Alloc*>(alloc), backing_array,
 1737|      8|                                  layout.alloc_size());
 1738|      8|}

_ZN4absl12lts_2026052627InstallFailureSignalHandlerERKNS0_27FailureSignalHandlerOptionsE:
  426|      2|void InstallFailureSignalHandler(const FailureSignalHandlerOptions& options) {
  427|      2|  fsh_options = options;
  428|     14|  for (auto& it : failure_signal_data) {
  ------------------
  |  Branch (428:17): [True: 14, False: 2]
  ------------------
  429|     14|    InstallOneFailureHandler(&it, AbslFailureSignalHandler);
  430|     14|  }
  431|      2|}
failure_signal_handler.cc:_ZN4absl12lts_20260526L24InstallOneFailureHandlerEPNS0_17FailureSignalDataEPFviP9siginfo_tPvE:
  231|     14|                                     void (*handler)(int, siginfo_t*, void*)) {
  232|     14|  struct sigaction act;
  233|     14|  memset(&act, 0, sizeof(act));
  234|     14|  sigemptyset(&act.sa_mask);
  235|     14|  act.sa_flags |= SA_SIGINFO;
  236|       |  // SA_NODEFER is required to handle SIGABRT from
  237|       |  // ImmediateAbortSignalHandler().
  238|     14|  act.sa_flags |= SA_NODEFER;
  239|     14|  if (fsh_options.use_alternate_stack) {
  ------------------
  |  Branch (239:7): [True: 14, False: 0]
  ------------------
  240|     14|    act.sa_flags |= MaybeSetupAlternateStack();
  241|     14|  }
  242|     14|  act.sa_sigaction = handler;
  243|       |  ABSL_RAW_CHECK(sigaction(data->signo, &act, &data->previous_action) == 0,
  ------------------
  |  |   60|     14|  do {                                                                 \
  |  |   61|     14|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  190|     14|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 14]
  |  |  |  |  |  Branch (190:49): [Folded, False: 14]
  |  |  |  |  |  Branch (190:58): [True: 0, False: 14]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   62|      0|      ABSL_RAW_LOG(FATAL, "Check %s failed: %s", #condition, message); \
  |  |  ------------------
  |  |  |  |   45|      0|  do {                                                                         \
  |  |  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  |  |  ------------------
  |  |  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  |  |  ------------------
  |  |  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  |  |  ------------------
  |  |  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   52|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|      0|    }                                                                  \
  |  |   64|     14|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 14]
  |  |  ------------------
  ------------------
  244|     14|                 "sigaction() failed");
  245|     14|}
failure_signal_handler.cc:_ZN4absl12lts_20260526L24MaybeSetupAlternateStackEv:
  221|     14|static int MaybeSetupAlternateStack() {
  222|     14|#ifdef ABSL_HAVE_SIGALTSTACK
  223|     14|  ABSL_ATTRIBUTE_UNUSED static const bool kOnce = SetupAlternateStackOnce();
  ------------------
  |  |  582|     14|#define ABSL_ATTRIBUTE_UNUSED __attribute__((__unused__))
  ------------------
  224|     14|  return SA_ONSTACK;
  225|       |#else
  226|       |  return 0;
  227|       |#endif
  228|     14|}
failure_signal_handler.cc:_ZN4absl12lts_20260526L23SetupAlternateStackOnceEv:
  159|      2|static bool SetupAlternateStackOnce() {
  160|       |#if defined(__wasm__) || defined(__asmjs__)
  161|       |  const size_t page_mask = static_cast<size_t>(getpagesize()) - 1;
  162|       |#else
  163|      2|  const size_t page_mask = static_cast<size_t>(sysconf(_SC_PAGESIZE)) - 1;
  164|      2|#endif
  165|      2|  size_t stack_size =
  166|      2|      (std::max(static_cast<size_t>(SIGSTKSZ), size_t{65536}) + page_mask) &
  167|      2|      ~page_mask;
  168|       |#if defined(ABSL_HAVE_ADDRESS_SANITIZER) || \
  169|       |    defined(ABSL_HAVE_MEMORY_SANITIZER) || defined(ABSL_HAVE_THREAD_SANITIZER)
  170|       |  // Account for sanitizer instrumentation requiring additional stack space.
  171|       |  stack_size *= 5;
  172|       |#endif
  173|       |
  174|      2|  stack_t sigstk;
  175|      2|  memset(&sigstk, 0, sizeof(sigstk));
  176|      2|  sigstk.ss_size = stack_size;
  177|       |
  178|      2|#ifdef ABSL_HAVE_MMAP
  179|       |#ifndef MAP_STACK
  180|       |#define MAP_STACK 0
  181|       |#endif
  182|      2|  sigstk.ss_sp = mmap(nullptr, sigstk.ss_size, PROT_READ | PROT_WRITE,
  183|      2|                      MAP_PRIVATE | MAP_ANONYMOUS | MAP_STACK, -1, 0);
  184|      2|  if (sigstk.ss_sp == MAP_FAILED) {
  ------------------
  |  Branch (184:7): [True: 0, False: 2]
  ------------------
  185|      0|    ABSL_RAW_LOG(FATAL, "mmap() for alternate signal stack failed");
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  186|      0|  }
  187|       |#else
  188|       |  sigstk.ss_sp = malloc(sigstk.ss_size);
  189|       |  if (sigstk.ss_sp == nullptr) {
  190|       |    ABSL_RAW_LOG(FATAL, "malloc() for alternate signal stack failed");
  191|       |  }
  192|       |#endif
  193|       |
  194|      2|  if (sigaltstack(&sigstk, nullptr) != 0) {
  ------------------
  |  Branch (194:7): [True: 0, False: 2]
  ------------------
  195|      0|    ABSL_RAW_LOG(FATAL, "sigaltstack() failed with errno=%d", errno);
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  196|      0|  }
  197|       |
  198|      2|#ifdef __linux__
  199|       |#if defined(PR_SET_VMA) && defined(PR_SET_VMA_ANON_NAME)
  200|       |  // Make a best-effort attempt to name the allocated region in
  201|       |  // /proc/$PID/smaps.
  202|       |  //
  203|       |  // The call to prctl() may fail if the kernel was not configured with the
  204|       |  // CONFIG_ANON_VMA_NAME kernel option.  This is OK since the call is
  205|       |  // primarily a debugging aid.
  206|       |  prctl(PR_SET_VMA, PR_SET_VMA_ANON_NAME, sigstk.ss_sp, sigstk.ss_size,
  207|       |        "absl-signalstack");
  208|       |#endif
  209|      2|#endif  // __linux__
  210|       |
  211|      2|  return true;
  212|      2|}

_ZN4absl12lts_2026052618debugging_internal11ElfMemImageC2EPKv:
   87|      2|ElfMemImage::ElfMemImage(const void *base) {
   88|      2|  ABSL_RAW_CHECK(base != kInvalidBase, "bad pointer");
  ------------------
  |  |   60|      2|  do {                                                                 \
  |  |   61|      2|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  190|      2|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 2]
  |  |  |  |  |  Branch (190:49): [Folded, False: 2]
  |  |  |  |  |  Branch (190:58): [True: 0, False: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   62|      0|      ABSL_RAW_LOG(FATAL, "Check %s failed: %s", #condition, message); \
  |  |  ------------------
  |  |  |  |   45|      0|  do {                                                                         \
  |  |  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  |  |  ------------------
  |  |  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  |  |  ------------------
  |  |  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  |  |  ------------------
  |  |  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   52|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|      0|    }                                                                  \
  |  |   64|      2|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 2]
  |  |  ------------------
  ------------------
   89|      2|  Init(base);
   90|      2|}
_ZNK4absl12lts_2026052618debugging_internal11ElfMemImage13GetNumSymbolsEv:
   92|     68|uint32_t ElfMemImage::GetNumSymbols() const { return num_syms_; }
_ZNK4absl12lts_2026052618debugging_internal11ElfMemImage9GetDynsymEj:
   94|     22|const ElfW(Sym) * ElfMemImage::GetDynsym(uint32_t index) const {
   95|     22|  ABSL_RAW_CHECK(index < GetNumSymbols(), "index out of range");
  ------------------
  |  |   60|     22|  do {                                                                 \
  |  |   61|     22|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  190|     22|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 22]
  |  |  |  |  |  Branch (190:49): [Folded, False: 22]
  |  |  |  |  |  Branch (190:58): [True: 0, False: 22]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   62|      0|      ABSL_RAW_LOG(FATAL, "Check %s failed: %s", #condition, message); \
  |  |  ------------------
  |  |  |  |   45|      0|  do {                                                                         \
  |  |  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  |  |  ------------------
  |  |  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  |  |  ------------------
  |  |  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  |  |  ------------------
  |  |  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   52|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|      0|    }                                                                  \
  |  |   64|     22|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 22]
  |  |  ------------------
  ------------------
   96|     22|  return dynsym_ + index;
   97|     22|}
_ZNK4absl12lts_2026052618debugging_internal11ElfMemImage9GetVersymEj:
   99|     22|const ElfW(Versym) *ElfMemImage::GetVersym(uint32_t index) const {
  100|     22|  ABSL_RAW_CHECK(index < GetNumSymbols(), "index out of range");
  ------------------
  |  |   60|     22|  do {                                                                 \
  |  |   61|     22|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  190|     22|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 22]
  |  |  |  |  |  Branch (190:49): [Folded, False: 22]
  |  |  |  |  |  Branch (190:58): [True: 0, False: 22]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   62|      0|      ABSL_RAW_LOG(FATAL, "Check %s failed: %s", #condition, message); \
  |  |  ------------------
  |  |  |  |   45|      0|  do {                                                                         \
  |  |  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  |  |  ------------------
  |  |  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  |  |  ------------------
  |  |  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  |  |  ------------------
  |  |  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   52|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|      0|    }                                                                  \
  |  |   64|     22|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 22]
  |  |  ------------------
  ------------------
  101|     22|  return versym_ + index;
  102|     22|}
_ZNK4absl12lts_2026052618debugging_internal11ElfMemImage7GetPhdrEi:
  104|      8|const ElfW(Phdr) *ElfMemImage::GetPhdr(int index) const {
  105|      8|  ABSL_RAW_CHECK(index >= 0 && index < ehdr_->e_phnum, "index out of range");
  ------------------
  |  |   60|      8|  do {                                                                 \
  |  |   61|      8|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  190|     16|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 8]
  |  |  |  |  |  Branch (190:49): [Folded, False: 8]
  |  |  |  |  |  Branch (190:59): [True: 8, False: 0]
  |  |  |  |  |  Branch (190:59): [True: 8, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   62|      0|      ABSL_RAW_LOG(FATAL, "Check %s failed: %s", #condition, message); \
  |  |  ------------------
  |  |  |  |   45|      0|  do {                                                                         \
  |  |  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  |  |  ------------------
  |  |  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  |  |  ------------------
  |  |  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  |  |  ------------------
  |  |  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   52|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|      0|    }                                                                  \
  |  |   64|      8|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 8]
  |  |  ------------------
  ------------------
  106|      8|  return GetTableElement<ElfW(Phdr)>(ehdr_, ehdr_->e_phoff, ehdr_->e_phentsize,
  107|      8|                                     static_cast<size_t>(index));
  108|      8|}
_ZNK4absl12lts_2026052618debugging_internal11ElfMemImage9GetDynstrEj:
  110|     22|const char *ElfMemImage::GetDynstr(ElfW(Word) offset) const {
  111|     22|  ABSL_RAW_CHECK(offset < strsize_, "offset out of range");
  ------------------
  |  |   60|     22|  do {                                                                 \
  |  |   61|     22|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  190|     22|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 22]
  |  |  |  |  |  Branch (190:49): [Folded, False: 22]
  |  |  |  |  |  Branch (190:58): [True: 0, False: 22]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   62|      0|      ABSL_RAW_LOG(FATAL, "Check %s failed: %s", #condition, message); \
  |  |  ------------------
  |  |  |  |   45|      0|  do {                                                                         \
  |  |  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  |  |  ------------------
  |  |  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  |  |  ------------------
  |  |  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  |  |  ------------------
  |  |  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   52|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|      0|    }                                                                  \
  |  |   64|     22|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 22]
  |  |  ------------------
  ------------------
  112|     22|  return dynstr_ + offset;
  113|     22|}
_ZNK4absl12lts_2026052618debugging_internal11ElfMemImage10GetSymAddrEPK9Elf64_Sym:
  115|     22|const void *ElfMemImage::GetSymAddr(const ElfW(Sym) *sym) const {
  116|     22|  if (sym->st_shndx == SHN_UNDEF || sym->st_shndx >= SHN_LORESERVE) {
  ------------------
  |  Branch (116:7): [True: 2, False: 20]
  |  Branch (116:37): [True: 2, False: 18]
  ------------------
  117|       |    // Symbol corresponds to "special" (e.g. SHN_ABS) section.
  118|      4|    return reinterpret_cast<const void *>(sym->st_value);
  119|      4|  }
  120|     18|  ABSL_RAW_CHECK(link_base_ < sym->st_value, "symbol out of range");
  ------------------
  |  |   60|     18|  do {                                                                 \
  |  |   61|     18|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  190|     18|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 18]
  |  |  |  |  |  Branch (190:49): [Folded, False: 18]
  |  |  |  |  |  Branch (190:58): [True: 0, False: 18]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   62|      0|      ABSL_RAW_LOG(FATAL, "Check %s failed: %s", #condition, message); \
  |  |  ------------------
  |  |  |  |   45|      0|  do {                                                                         \
  |  |  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  |  |  ------------------
  |  |  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  |  |  ------------------
  |  |  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  |  |  ------------------
  |  |  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   52|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|      0|    }                                                                  \
  |  |   64|     18|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 18]
  |  |  ------------------
  ------------------
  121|     18|  return GetTableElement<char>(ehdr_, 0, 1, sym->st_value - link_base_);
  122|     18|}
_ZNK4absl12lts_2026052618debugging_internal11ElfMemImage9GetVerdefEi:
  124|     20|const ElfW(Verdef) *ElfMemImage::GetVerdef(int index) const {
  125|     20|  ABSL_RAW_CHECK(0 <= index && static_cast<size_t>(index) <= verdefnum_,
  ------------------
  |  |   60|     20|  do {                                                                 \
  |  |   61|     20|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  190|     40|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 20]
  |  |  |  |  |  Branch (190:49): [Folded, False: 20]
  |  |  |  |  |  Branch (190:59): [True: 20, False: 0]
  |  |  |  |  |  Branch (190:59): [True: 20, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   62|      0|      ABSL_RAW_LOG(FATAL, "Check %s failed: %s", #condition, message); \
  |  |  ------------------
  |  |  |  |   45|      0|  do {                                                                         \
  |  |  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  |  |  ------------------
  |  |  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  |  |  ------------------
  |  |  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  |  |  ------------------
  |  |  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   52|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|      0|    }                                                                  \
  |  |   64|     20|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 20]
  |  |  ------------------
  ------------------
  126|     20|                 "index out of range");
  127|     20|  const ElfW(Verdef) *version_definition = verdef_;
  128|     40|  while (version_definition->vd_ndx < index && version_definition->vd_next) {
  ------------------
  |  Branch (128:10): [True: 20, False: 20]
  |  Branch (128:48): [True: 20, False: 0]
  ------------------
  129|     20|    const char *const version_definition_as_char =
  130|     20|        reinterpret_cast<const char *>(version_definition);
  131|     20|    version_definition =
  132|     20|        reinterpret_cast<const ElfW(Verdef) *>(version_definition_as_char +
  133|     20|                                               version_definition->vd_next);
  134|     20|  }
  135|     20|  return version_definition->vd_ndx == index ? version_definition : nullptr;
  ------------------
  |  Branch (135:10): [True: 20, False: 0]
  ------------------
  136|     20|}
_ZNK4absl12lts_2026052618debugging_internal11ElfMemImage12GetVerdefAuxEPK12Elf64_Verdef:
  139|     20|    const ElfW(Verdef) *verdef) const {
  140|     20|  return reinterpret_cast<const ElfW(Verdaux) *>(verdef+1);
  141|     20|}
_ZNK4absl12lts_2026052618debugging_internal11ElfMemImage9GetVerstrEj:
  143|     20|const char *ElfMemImage::GetVerstr(ElfW(Word) offset) const {
  144|     20|  ABSL_RAW_CHECK(offset < strsize_, "offset out of range");
  ------------------
  |  |   60|     20|  do {                                                                 \
  |  |   61|     20|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  190|     20|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 20]
  |  |  |  |  |  Branch (190:49): [Folded, False: 20]
  |  |  |  |  |  Branch (190:58): [True: 0, False: 20]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   62|      0|      ABSL_RAW_LOG(FATAL, "Check %s failed: %s", #condition, message); \
  |  |  ------------------
  |  |  |  |   45|      0|  do {                                                                         \
  |  |  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  |  |  ------------------
  |  |  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  |  |  ------------------
  |  |  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  |  |  ------------------
  |  |  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   52|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|      0|    }                                                                  \
  |  |   64|     20|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 20]
  |  |  ------------------
  ------------------
  145|     20|  return dynstr_ + offset;
  146|     20|}
_ZN4absl12lts_2026052618debugging_internal11ElfMemImage4InitEPKv:
  148|      2|void ElfMemImage::Init(const void *base) {
  149|      2|  ehdr_      = nullptr;
  150|      2|  dynsym_    = nullptr;
  151|      2|  dynstr_    = nullptr;
  152|      2|  versym_    = nullptr;
  153|      2|  verdef_    = nullptr;
  154|      2|  num_syms_ = 0;
  155|      2|  strsize_   = 0;
  156|      2|  verdefnum_ = 0;
  157|       |  // Sentinel: PT_LOAD .p_vaddr can't possibly be this.
  158|      2|  link_base_ = ~ElfW(Addr){0};  // NOLINT(readability/braces)
  159|      2|  if (!base) {
  ------------------
  |  Branch (159:7): [True: 0, False: 2]
  ------------------
  160|      0|    return;
  161|      0|  }
  162|      2|  const char *const base_as_char = reinterpret_cast<const char *>(base);
  163|      2|  if (base_as_char[EI_MAG0] != ELFMAG0 || base_as_char[EI_MAG1] != ELFMAG1 ||
  ------------------
  |  Branch (163:7): [True: 0, False: 2]
  |  Branch (163:43): [True: 0, False: 2]
  ------------------
  164|      2|      base_as_char[EI_MAG2] != ELFMAG2 || base_as_char[EI_MAG3] != ELFMAG3) {
  ------------------
  |  Branch (164:7): [True: 0, False: 2]
  |  Branch (164:43): [True: 0, False: 2]
  ------------------
  165|      0|    assert(false);
  166|      0|    return;
  167|      0|  }
  168|      2|  int elf_class = base_as_char[EI_CLASS];
  169|      2|  if (elf_class != kElfClass) {
  ------------------
  |  Branch (169:7): [True: 0, False: 2]
  ------------------
  170|      0|    assert(false);
  171|      0|    return;
  172|      0|  }
  173|      2|  switch (base_as_char[EI_DATA]) {
  174|      2|    case ELFDATA2LSB: {
  ------------------
  |  Branch (174:5): [True: 2, False: 0]
  ------------------
  175|       |#ifndef ABSL_IS_LITTLE_ENDIAN
  176|       |      assert(false);
  177|       |      return;
  178|       |#endif
  179|      2|      break;
  180|      0|    }
  181|      0|    case ELFDATA2MSB: {
  ------------------
  |  Branch (181:5): [True: 0, False: 2]
  ------------------
  182|      0|#ifndef ABSL_IS_BIG_ENDIAN
  183|      0|      assert(false);
  184|      0|      return;
  185|      0|#endif
  186|      0|      break;
  187|      0|    }
  188|      0|    default: {
  ------------------
  |  Branch (188:5): [True: 0, False: 2]
  ------------------
  189|      0|      assert(false);
  190|      0|      return;
  191|      0|    }
  192|      2|  }
  193|       |
  194|      2|  ehdr_ = reinterpret_cast<const ElfW(Ehdr) *>(base);
  195|      2|  const ElfW(Phdr) *dynamic_program_header = nullptr;
  196|     10|  for (int i = 0; i < ehdr_->e_phnum; ++i) {
  ------------------
  |  Branch (196:19): [True: 8, False: 2]
  ------------------
  197|      8|    const ElfW(Phdr) *const program_header = GetPhdr(i);
  198|      8|    switch (program_header->p_type) {
  ------------------
  |  Branch (198:13): [True: 4, False: 4]
  ------------------
  199|      2|      case PT_LOAD:
  ------------------
  |  Branch (199:7): [True: 2, False: 6]
  ------------------
  200|      2|        if (!~link_base_) {
  ------------------
  |  Branch (200:13): [True: 2, False: 0]
  ------------------
  201|      2|          link_base_ = program_header->p_vaddr;
  202|      2|        }
  203|      2|        break;
  204|      2|      case PT_DYNAMIC:
  ------------------
  |  Branch (204:7): [True: 2, False: 6]
  ------------------
  205|      2|        dynamic_program_header = program_header;
  206|      2|        break;
  207|      8|    }
  208|      8|  }
  209|      2|  if (!~link_base_ || !dynamic_program_header) {
  ------------------
  |  Branch (209:7): [True: 0, False: 2]
  |  Branch (209:23): [True: 0, False: 2]
  ------------------
  210|      0|    assert(false);
  211|       |    // Mark this image as not present. Can not recur infinitely.
  212|      0|    Init(nullptr);
  213|      0|    return;
  214|      0|  }
  215|      2|  ptrdiff_t relocation =
  216|      2|      base_as_char - reinterpret_cast<const char *>(link_base_);
  217|      2|  ElfW(Dyn)* dynamic_entry = reinterpret_cast<ElfW(Dyn)*>(
  218|      2|      static_cast<intptr_t>(dynamic_program_header->p_vaddr) + relocation);
  219|      2|  uint32_t *sysv_hash = nullptr;
  220|      2|  uint32_t *gnu_hash = nullptr;
  221|     26|  for (; dynamic_entry->d_tag != DT_NULL; ++dynamic_entry) {
  ------------------
  |  Branch (221:10): [True: 24, False: 2]
  ------------------
  222|     24|    const auto value =
  223|     24|        static_cast<intptr_t>(dynamic_entry->d_un.d_val) + relocation;
  224|     24|    switch (dynamic_entry->d_tag) {
  225|      2|      case DT_HASH:
  ------------------
  |  Branch (225:7): [True: 2, False: 22]
  ------------------
  226|      2|        sysv_hash = reinterpret_cast<uint32_t *>(value);
  227|      2|        break;
  228|      2|      case DT_GNU_HASH:
  ------------------
  |  Branch (228:7): [True: 2, False: 22]
  ------------------
  229|      2|        gnu_hash = reinterpret_cast<uint32_t *>(value);
  230|      2|        break;
  231|      2|      case DT_SYMTAB:
  ------------------
  |  Branch (231:7): [True: 2, False: 22]
  ------------------
  232|      2|        dynsym_ = reinterpret_cast<ElfW(Sym) *>(value);
  233|      2|        break;
  234|      2|      case DT_STRTAB:
  ------------------
  |  Branch (234:7): [True: 2, False: 22]
  ------------------
  235|      2|        dynstr_ = reinterpret_cast<const char *>(value);
  236|      2|        break;
  237|      2|      case DT_VERSYM:
  ------------------
  |  Branch (237:7): [True: 2, False: 22]
  ------------------
  238|      2|        versym_ = reinterpret_cast<ElfW(Versym) *>(value);
  239|      2|        break;
  240|      2|      case DT_VERDEF:
  ------------------
  |  Branch (240:7): [True: 2, False: 22]
  ------------------
  241|      2|        verdef_ = reinterpret_cast<ElfW(Verdef) *>(value);
  242|      2|        break;
  243|      2|      case DT_VERDEFNUM:
  ------------------
  |  Branch (243:7): [True: 2, False: 22]
  ------------------
  244|      2|        verdefnum_ = static_cast<size_t>(dynamic_entry->d_un.d_val);
  245|      2|        break;
  246|      2|      case DT_STRSZ:
  ------------------
  |  Branch (246:7): [True: 2, False: 22]
  ------------------
  247|      2|        strsize_ = static_cast<size_t>(dynamic_entry->d_un.d_val);
  248|      2|        break;
  249|      8|      default:
  ------------------
  |  Branch (249:7): [True: 8, False: 16]
  ------------------
  250|       |        // Unrecognized entries explicitly ignored.
  251|      8|        break;
  252|     24|    }
  253|     24|  }
  254|      2|  if ((!sysv_hash && !gnu_hash) || !dynsym_ || !dynstr_ || !versym_ ||
  ------------------
  |  Branch (254:8): [True: 0, False: 2]
  |  Branch (254:22): [True: 0, False: 0]
  |  Branch (254:36): [True: 0, False: 2]
  |  Branch (254:48): [True: 0, False: 2]
  |  Branch (254:60): [True: 0, False: 2]
  ------------------
  255|      2|      !verdef_ || !verdefnum_ || !strsize_) {
  ------------------
  |  Branch (255:7): [True: 0, False: 2]
  |  Branch (255:19): [True: 0, False: 2]
  |  Branch (255:34): [True: 0, False: 2]
  ------------------
  256|      0|    assert(false);  // invalid VDSO
  257|       |    // Mark this image as not present. Can not recur infinitely.
  258|      0|    Init(nullptr);
  259|      0|    return;
  260|      0|  }
  261|      2|  if (sysv_hash) {
  ------------------
  |  Branch (261:7): [True: 2, False: 0]
  ------------------
  262|      2|    num_syms_ = sysv_hash[1];
  263|      2|  } else {
  264|      0|    assert(gnu_hash);
  265|       |    // Compute the number of symbols for DT_GNU_HASH, which is specified by
  266|       |    // https://sourceware.org/gnu-gabi/program-loading-and-dynamic-linking.txt
  267|      0|    uint32_t nbuckets = gnu_hash[0];
  268|       |    // The buckets array is located after the header (4 uint32) and the bloom
  269|       |    // filter (size_t array of gnu_hash[2] elements).
  270|      0|    uint32_t *buckets = gnu_hash + 4 + sizeof(size_t) / 4 * gnu_hash[2];
  271|       |    // Find the chain of the last non-empty bucket.
  272|      0|    uint32_t idx = 0;
  273|      0|    for (uint32_t i = nbuckets; i > 0;) {
  ------------------
  |  Branch (273:33): [True: 0, False: 0]
  ------------------
  274|      0|      idx = buckets[--i];
  275|      0|      if (idx != 0) break;
  ------------------
  |  Branch (275:11): [True: 0, False: 0]
  ------------------
  276|      0|    }
  277|      0|    if (idx != 0) {
  ------------------
  |  Branch (277:9): [True: 0, False: 0]
  ------------------
  278|       |      // Find the last element of the chain, which has an odd value.
  279|       |      // Add one to get the number of symbols.
  280|      0|      uint32_t *chain = buckets + nbuckets - gnu_hash[1];
  281|      0|      while (chain[idx++] % 2 == 0) {
  ------------------
  |  Branch (281:14): [True: 0, False: 0]
  ------------------
  282|      0|      }
  283|      0|    }
  284|      0|    num_syms_ = idx;
  285|      0|  }
  286|      2|}
_ZNK4absl12lts_2026052618debugging_internal11ElfMemImage12LookupSymbolEPKcS4_iPNS2_10SymbolInfoE:
  291|      2|                               SymbolInfo *info_out) const {
  292|     22|  for (const SymbolInfo& info : *this) {
  ------------------
  |  Branch (292:31): [True: 22, False: 0]
  ------------------
  293|     22|    if (strcmp(info.name, name) == 0 && strcmp(info.version, version) == 0 &&
  ------------------
  |  Branch (293:9): [True: 2, False: 20]
  |  Branch (293:41): [True: 2, False: 0]
  ------------------
  294|      2|        ElfType(info.symbol) == type) {
  ------------------
  |  Branch (294:9): [True: 2, False: 0]
  ------------------
  295|      2|      if (info_out) {
  ------------------
  |  Branch (295:11): [True: 2, False: 0]
  ------------------
  296|      2|        *info_out = info;
  297|      2|      }
  298|      2|      return true;
  299|      2|    }
  300|     22|  }
  301|      0|  return false;
  302|      2|}
_ZN4absl12lts_2026052618debugging_internal11ElfMemImage14SymbolIteratorC2EPKvj:
  332|      4|    : index_(index), image_(image) {}
_ZNK4absl12lts_2026052618debugging_internal11ElfMemImage14SymbolIteratordeEv:
  338|     22|const ElfMemImage::SymbolInfo& ElfMemImage::SymbolIterator::operator*() const {
  339|     22|  return info_;
  340|     22|}
_ZNK4absl12lts_2026052618debugging_internal11ElfMemImage14SymbolIteratoreqERKS3_:
  342|     22|bool ElfMemImage::SymbolIterator::operator==(const SymbolIterator &rhs) const {
  343|     22|  return this->image_ == rhs.image_ && this->index_ == rhs.index_;
  ------------------
  |  Branch (343:10): [True: 22, False: 0]
  |  Branch (343:40): [True: 0, False: 22]
  ------------------
  344|     22|}
_ZNK4absl12lts_2026052618debugging_internal11ElfMemImage14SymbolIteratorneERKS3_:
  346|     22|bool ElfMemImage::SymbolIterator::operator!=(const SymbolIterator &rhs) const {
  347|     22|  return !(*this == rhs);
  348|     22|}
_ZN4absl12lts_2026052618debugging_internal11ElfMemImage14SymbolIteratorppEv:
  350|     20|ElfMemImage::SymbolIterator &ElfMemImage::SymbolIterator::operator++() {
  351|     20|  this->Update(1);
  352|     20|  return *this;
  353|     20|}
_ZNK4absl12lts_2026052618debugging_internal11ElfMemImage5beginEv:
  355|      2|ElfMemImage::SymbolIterator ElfMemImage::begin() const {
  356|      2|  SymbolIterator it(this, 0);
  357|      2|  it.Update(0);
  358|      2|  return it;
  359|      2|}
_ZNK4absl12lts_2026052618debugging_internal11ElfMemImage3endEv:
  361|      2|ElfMemImage::SymbolIterator ElfMemImage::end() const {
  362|      2|  return SymbolIterator(this, GetNumSymbols());
  363|      2|}
_ZN4absl12lts_2026052618debugging_internal11ElfMemImage14SymbolIterator6UpdateEj:
  365|     22|void ElfMemImage::SymbolIterator::Update(uint32_t increment) {
  366|     22|  const ElfMemImage *image = reinterpret_cast<const ElfMemImage *>(image_);
  367|     22|  ABSL_RAW_CHECK(image->IsPresent() || increment == 0, "");
  ------------------
  |  |   60|     22|  do {                                                                 \
  |  |   61|     22|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  190|     22|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 22]
  |  |  |  |  |  Branch (190:49): [Folded, False: 22]
  |  |  |  |  |  Branch (190:59): [True: 22, False: 0]
  |  |  |  |  |  Branch (190:59): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   62|      0|      ABSL_RAW_LOG(FATAL, "Check %s failed: %s", #condition, message); \
  |  |  ------------------
  |  |  |  |   45|      0|  do {                                                                         \
  |  |  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  |  |  ------------------
  |  |  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  |  |  ------------------
  |  |  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  |  |  ------------------
  |  |  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   52|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|      0|    }                                                                  \
  |  |   64|     22|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 22]
  |  |  ------------------
  ------------------
  368|     22|  if (!image->IsPresent()) {
  ------------------
  |  Branch (368:7): [True: 0, False: 22]
  ------------------
  369|      0|    return;
  370|      0|  }
  371|     22|  index_ += increment;
  372|     22|  if (index_ >= image->GetNumSymbols()) {
  ------------------
  |  Branch (372:7): [True: 0, False: 22]
  ------------------
  373|      0|    index_ = image->GetNumSymbols();
  374|      0|    return;
  375|      0|  }
  376|     22|  const ElfW(Sym)    *symbol = image->GetDynsym(index_);
  377|     22|  const ElfW(Versym) *version_symbol = image->GetVersym(index_);
  378|     22|  ABSL_RAW_CHECK(symbol && version_symbol, "");
  ------------------
  |  |   60|     22|  do {                                                                 \
  |  |   61|     22|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  190|     44|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 22]
  |  |  |  |  |  Branch (190:49): [Folded, False: 22]
  |  |  |  |  |  Branch (190:59): [True: 22, False: 0]
  |  |  |  |  |  Branch (190:59): [True: 22, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   62|      0|      ABSL_RAW_LOG(FATAL, "Check %s failed: %s", #condition, message); \
  |  |  ------------------
  |  |  |  |   45|      0|  do {                                                                         \
  |  |  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  |  |  ------------------
  |  |  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  |  |  ------------------
  |  |  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  |  |  ------------------
  |  |  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   52|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|      0|    }                                                                  \
  |  |   64|     22|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 22]
  |  |  ------------------
  ------------------
  379|     22|  const char *const symbol_name = image->GetDynstr(symbol->st_name);
  380|       |#if defined(__NetBSD__)
  381|       |  const int version_index = version_symbol->vs_vers & VERSYM_VERSION;
  382|       |#else
  383|     22|  const ElfW(Versym) version_index = version_symbol[0] & VERSYM_VERSION;
  ------------------
  |  |   42|     22|#define VERSYM_VERSION 0x7fff
  ------------------
  384|     22|#endif
  385|     22|  const ElfW(Verdef) *version_definition = nullptr;
  386|     22|  const char *version_name = "";
  387|     22|  if (symbol->st_shndx == SHN_UNDEF) {
  ------------------
  |  Branch (387:7): [True: 2, False: 20]
  ------------------
  388|       |    // Undefined symbols reference DT_VERNEED, not DT_VERDEF, and
  389|       |    // version_index could well be greater than verdefnum_, so calling
  390|       |    // GetVerdef(version_index) may trigger assertion.
  391|     20|  } else {
  392|     20|    version_definition = image->GetVerdef(version_index);
  393|     20|  }
  394|     22|  if (version_definition) {
  ------------------
  |  Branch (394:7): [True: 20, False: 2]
  ------------------
  395|       |    // I am expecting 1 or 2 auxiliary entries: 1 for the version itself,
  396|       |    // optional 2nd if the version has a parent.
  397|     20|    ABSL_RAW_CHECK(
  ------------------
  |  |   60|     20|  do {                                                                 \
  |  |   61|     20|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  190|     20|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 20]
  |  |  |  |  |  Branch (190:49): [Folded, False: 20]
  |  |  |  |  |  Branch (190:59): [True: 20, False: 0]
  |  |  |  |  |  Branch (190:59): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   62|      0|      ABSL_RAW_LOG(FATAL, "Check %s failed: %s", #condition, message); \
  |  |  ------------------
  |  |  |  |   45|      0|  do {                                                                         \
  |  |  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  |  |  ------------------
  |  |  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  |  |  ------------------
  |  |  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  |  |  ------------------
  |  |  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   52|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|      0|    }                                                                  \
  |  |   64|     20|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 20]
  |  |  ------------------
  ------------------
  398|     20|        version_definition->vd_cnt == 1 || version_definition->vd_cnt == 2,
  399|     20|        "wrong number of entries");
  400|     20|    const ElfW(Verdaux) *version_aux = image->GetVerdefAux(version_definition);
  401|     20|    version_name = image->GetVerstr(version_aux->vda_name);
  402|     20|  }
  403|     22|  info_.name    = symbol_name;
  404|     22|  info_.version = version_name;
  405|     22|  info_.address = image->GetSymAddr(symbol);
  406|     22|  info_.symbol  = symbol;
  407|     22|}
elf_mem_image.cc:_ZN4absl12lts_2026052618debugging_internal12_GLOBAL__N_17ElfTypeEPK9Elf64_Sym:
   57|      2|int ElfType(const ElfW(Sym) *symbol) { return ELF64_ST_TYPE(symbol->st_info); }
elf_mem_image.cc:_ZN4absl12lts_2026052618debugging_internal12_GLOBAL__N_115GetTableElementI10Elf64_PhdrEEPKT_PK10Elf64_Ehdrmjm:
   75|      8|                         ElfW(Word) element_size, size_t index) {
   76|      8|  return reinterpret_cast<const T*>(reinterpret_cast<const char *>(ehdr)
   77|      8|                                    + table_offset
   78|      8|                                    + index * element_size);
   79|      8|}
elf_mem_image.cc:_ZN4absl12lts_2026052618debugging_internal12_GLOBAL__N_115GetTableElementIcEEPKT_PK10Elf64_Ehdrmjm:
   75|     18|                         ElfW(Word) element_size, size_t index) {
   76|     18|  return reinterpret_cast<const T*>(reinterpret_cast<const char *>(ehdr)
   77|     18|                                    + table_offset
   78|     18|                                    + index * element_size);
   79|     18|}

_ZNK4absl12lts_2026052618debugging_internal11ElfMemImage9IsPresentEv:
   96|     44|  bool                 IsPresent() const { return ehdr_ != nullptr; }

_ZN4absl12lts_2026052618debugging_internal11VDSOSupportC2Ev:
   79|      2|    : image_(vdso_base_.load(std::memory_order_relaxed) ==
  ------------------
  |  Branch (79:14): [True: 0, False: 2]
  ------------------
   80|      2|                     debugging_internal::ElfMemImage::kInvalidBase
   81|      2|                 ? Init()
   82|      2|                 : vdso_base_.load(std::memory_order_relaxed)) {}
_ZN4absl12lts_2026052618debugging_internal11VDSOSupport4InitEv:
   93|      2|const void *VDSOSupport::Init() {
   94|      2|  const auto kInvalidBase = debugging_internal::ElfMemImage::kInvalidBase;
   95|      2|#ifdef ABSL_HAVE_GETAUXVAL
   96|      2|  if (vdso_base_.load(std::memory_order_relaxed) == kInvalidBase) {
  ------------------
  |  Branch (96:7): [True: 2, False: 0]
  ------------------
   97|      2|    errno = 0;
   98|      2|    const void *const sysinfo_ehdr =
   99|      2|        reinterpret_cast<const void *>(getauxval(AT_SYSINFO_EHDR));
  100|      2|    if (errno == 0) {
  ------------------
  |  Branch (100:9): [True: 2, False: 0]
  ------------------
  101|      2|      vdso_base_.store(sysinfo_ehdr, std::memory_order_relaxed);
  102|      2|    }
  103|      2|  }
  104|      2|#endif  // ABSL_HAVE_GETAUXVAL
  105|      2|  if (vdso_base_.load(std::memory_order_relaxed) == kInvalidBase) {
  ------------------
  |  Branch (105:7): [True: 0, False: 2]
  ------------------
  106|      0|    int fd = open("/proc/self/auxv", O_RDONLY);
  107|      0|    if (fd == -1) {
  ------------------
  |  Branch (107:9): [True: 0, False: 0]
  ------------------
  108|       |      // Kernel too old to have a VDSO.
  109|      0|      vdso_base_.store(nullptr, std::memory_order_relaxed);
  110|      0|      getcpu_fn_.store(&GetCPUViaSyscall, std::memory_order_relaxed);
  111|      0|      return nullptr;
  112|      0|    }
  113|      0|    ElfW(auxv_t) aux;
  114|      0|    while (read(fd, &aux, sizeof(aux)) == sizeof(aux)) {
  ------------------
  |  Branch (114:12): [True: 0, False: 0]
  ------------------
  115|      0|      if (aux.a_type == AT_SYSINFO_EHDR) {
  ------------------
  |  Branch (115:11): [True: 0, False: 0]
  ------------------
  116|       |#if defined(__NetBSD__)
  117|       |        vdso_base_.store(reinterpret_cast<void *>(aux.a_v),
  118|       |                         std::memory_order_relaxed);
  119|       |#else
  120|      0|        vdso_base_.store(reinterpret_cast<void *>(aux.a_un.a_val),
  121|      0|                         std::memory_order_relaxed);
  122|      0|#endif
  123|      0|        break;
  124|      0|      }
  125|      0|    }
  126|      0|    close(fd);
  127|      0|    if (vdso_base_.load(std::memory_order_relaxed) == kInvalidBase) {
  ------------------
  |  Branch (127:9): [True: 0, False: 0]
  ------------------
  128|       |      // Didn't find AT_SYSINFO_EHDR in auxv[].
  129|      0|      vdso_base_.store(nullptr, std::memory_order_relaxed);
  130|      0|    }
  131|      0|  }
  132|      2|  GetCpuFn fn = &GetCPUViaSyscall;  // default if VDSO not present.
  133|      2|  if (vdso_base_.load(std::memory_order_relaxed)) {
  ------------------
  |  Branch (133:7): [True: 2, False: 0]
  ------------------
  134|      2|    VDSOSupport vdso;
  135|      2|    SymbolInfo info;
  136|      2|    if (vdso.LookupSymbol("__vdso_getcpu", "LINUX_2.6", STT_FUNC, &info)) {
  ------------------
  |  Branch (136:9): [True: 2, False: 0]
  ------------------
  137|      2|      fn = reinterpret_cast<GetCpuFn>(const_cast<void *>(info.address));
  138|      2|    }
  139|      2|  }
  140|       |  // Subtle: this code runs outside of any locks; prevent compiler
  141|       |  // from assigning to getcpu_fn_ more than once.
  142|      2|  getcpu_fn_.store(fn, std::memory_order_relaxed);
  143|      2|  return vdso_base_.load(std::memory_order_relaxed);
  144|      2|}
_ZNK4absl12lts_2026052618debugging_internal11VDSOSupport12LookupSymbolEPKcS4_iPNS1_11ElfMemImage10SymbolInfoE:
  160|      2|                               SymbolInfo *info) const {
  161|      2|  return image_.LookupSymbol(name, version, type, info);
  162|      2|}

_ZN4absl12lts_2026052620InitializeSymbolizerEPKc:
   92|      2|void InitializeSymbolizer(const char *argv0) {
   93|      2|#ifdef ABSL_HAVE_VDSO_SUPPORT
   94|       |  // We need to make sure VDSOSupport::Init() is called before any setuid or
   95|       |  // chroot calls, so InitializeSymbolizer() should be called very early in the
   96|       |  // life of a program.
   97|      2|  absl::debugging_internal::VDSOSupport::Init();
   98|      2|#endif
   99|      2|  if (argv0_value != nullptr) {
  ------------------
  |  Branch (99:7): [True: 0, False: 2]
  ------------------
  100|      0|    free(argv0_value);
  101|      0|    argv0_value = nullptr;
  102|      0|  }
  103|      2|  if (argv0 != nullptr && argv0[0] != '\0') {
  ------------------
  |  Branch (103:7): [True: 2, False: 0]
  |  Branch (103:27): [True: 2, False: 0]
  ------------------
  104|      2|    argv0_value = strdup(argv0);
  105|      2|  }
  106|      2|}

_ZNK4absl12lts_2026052615CommandLineFlag8IsOfTypeIbEEbv:
   84|      2|  inline bool IsOfType() const {
   85|      2|    return TypeId() == FastTypeId<T>();
   86|      2|  }

_ZN25AbslFlagDefaultGenForfuzz3GenEPv:
  258|      4|    static void Gen(void* absl_flag_default_loc) {                            \
  259|      4|      new (absl_flag_default_loc) Type(AbslFlagDefaultGenFor##name{}.value);  \
  260|      4|    }                                                                         \
_ZN29AbslFlagDefaultGenForfuzz_for3GenEPv:
  258|      2|    static void Gen(void* absl_flag_default_loc) {                            \
  259|      2|      new (absl_flag_default_loc) Type(AbslFlagDefaultGenFor##name{}.value);  \
  260|      2|    }                                                                         \
_ZN36AbslFlagDefaultGenForcorpus_database3GenEPv:
  258|      2|    static void Gen(void* absl_flag_default_loc) {                            \
  259|      2|      new (absl_flag_default_loc) Type(AbslFlagDefaultGenFor##name{}.value);  \
  260|      2|    }                                                                         \
_ZN34AbslFlagDefaultGenForreplay_corpus3GenEPv:
  258|      2|    static void Gen(void* absl_flag_default_loc) {                            \
  259|      2|      new (absl_flag_default_loc) Type(AbslFlagDefaultGenFor##name{}.value);  \
  260|      2|    }                                                                         \
_ZN38AbslFlagDefaultGenForreplay_corpus_for3GenEPv:
  258|      2|    static void Gen(void* absl_flag_default_loc) {                            \
  259|      2|      new (absl_flag_default_loc) Type(AbslFlagDefaultGenFor##name{}.value);  \
  260|      2|    }                                                                         \
_ZN37AbslFlagDefaultGenFortime_budget_type3GenEPv:
  258|      2|    static void Gen(void* absl_flag_default_loc) {                            \
  259|      2|      new (absl_flag_default_loc) Type(AbslFlagDefaultGenFor##name{}.value);  \
  260|      2|    }                                                                         \
_ZN33AbslFlagDefaultGenForexecution_id3GenEPv:
  258|      2|    static void Gen(void* absl_flag_default_loc) {                            \
  259|      2|      new (absl_flag_default_loc) Type(AbslFlagDefaultGenFor##name{}.value);  \
  260|      2|    }                                                                         \
_ZN41AbslFlagDefaultGenFortime_limit_per_input3GenEPv:
  258|      2|    static void Gen(void* absl_flag_default_loc) {                            \
  259|      2|      new (absl_flag_default_loc) Type(AbslFlagDefaultGenFor##name{}.value);  \
  260|      2|    }                                                                         \
_ZN25AbslFlagDefaultGenForjobs3GenEPv:
  258|      2|    static void Gen(void* absl_flag_default_loc) {                            \
  259|      2|      new (absl_flag_default_loc) Type(AbslFlagDefaultGenFor##name{}.value);  \
  260|      2|    }                                                                         \
_ZN47AbslFlagDefaultGenForsubprocess_cleanup_timeout3GenEPv:
  258|      2|    static void Gen(void* absl_flag_default_loc) {                            \
  259|      2|      new (absl_flag_default_loc) Type(AbslFlagDefaultGenFor##name{}.value);  \
  260|      2|    }                                                                         \
_ZN47AbslFlagDefaultGenForinternal_centipede_command3GenEPv:
  258|      2|    static void Gen(void* absl_flag_default_loc) {                            \
  259|      2|      new (absl_flag_default_loc) Type(AbslFlagDefaultGenFor##name{}.value);  \
  260|      2|    }                                                                         \
_ZN48AbslFlagDefaultGenForinternal_override_fuzz_test3GenEPv:
  258|      2|    static void Gen(void* absl_flag_default_loc) {                            \
  259|      2|      new (absl_flag_default_loc) Type(AbslFlagDefaultGenFor##name{}.value);  \
  260|      2|    }                                                                         \
_ZN4absl12lts_202605267GetFlagINSt3__18optionalINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEET_RKNS0_14flags_internal4FlagISB_EE:
   98|     14|[[nodiscard]] T GetFlag(const absl::Flag<T>& flag) {
   99|     14|  return flags_internal::FlagImplPeer::InvokeGet<T>(flag);
  100|     14|}
_ZN55AbslFlagDefaultGenForinternal_override_total_time_limit3GenEPv:
  258|      2|    static void Gen(void* absl_flag_default_loc) {                            \
  259|      2|      new (absl_flag_default_loc) Type(AbslFlagDefaultGenFor##name{}.value);  \
  260|      2|    }                                                                         \
_ZN4absl12lts_202605267GetFlagINS0_8DurationEEET_RKNS0_14flags_internal4FlagIS3_EE:
   98|     14|[[nodiscard]] T GetFlag(const absl::Flag<T>& flag) {
   99|     14|  return flags_internal::FlagImplPeer::InvokeGet<T>(flag);
  100|     14|}
_ZN57AbslFlagDefaultGenForinternal_crashing_input_to_reproduce3GenEPv:
  258|      2|    static void Gen(void* absl_flag_default_loc) {                            \
  259|      2|      new (absl_flag_default_loc) Type(AbslFlagDefaultGenFor##name{}.value);  \
  260|      2|    }                                                                         \
_ZN4absl12lts_202605267GetFlagIN8fuzztest8internal14TimeBudgetTypeEEET_RKNS0_14flags_internal4FlagIS5_EE:
   98|      2|[[nodiscard]] T GetFlag(const absl::Flag<T>& flag) {
   99|      2|  return flags_internal::FlagImplPeer::InvokeGet<T>(flag);
  100|      2|}
_ZN4absl12lts_202605267GetFlagINSt3__18optionalImEEEET_RKNS0_14flags_internal4FlagIS5_EE:
   98|      2|[[nodiscard]] T GetFlag(const absl::Flag<T>& flag) {
   99|      2|  return flags_internal::FlagImplPeer::InvokeGet<T>(flag);
  100|      2|}
_ZN4absl12lts_202605267GetFlagImEET_RKNS0_14flags_internal4FlagIS2_EE:
   98|      4|[[nodiscard]] T GetFlag(const absl::Flag<T>& flag) {
   99|      4|  return flags_internal::FlagImplPeer::InvokeGet<T>(flag);
  100|      4|}
_ZN4absl12lts_202605267GetFlagIbEET_RKNS0_14flags_internal4FlagIS2_EE:
   98|     12|[[nodiscard]] T GetFlag(const absl::Flag<T>& flag) {
   99|     12|  return flags_internal::FlagImplPeer::InvokeGet<T>(flag);
  100|     12|}
_ZN4absl12lts_202605267GetFlagINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEET_RKNS0_14flags_internal4FlagIS9_EE:
   98|     16|[[nodiscard]] T GetFlag(const absl::Flag<T>& flag) {
   99|     16|  return flags_internal::FlagImplPeer::InvokeGet<T>(flag);
  100|     16|}
_ZN29AbslFlagDefaultGenForflagfile3GenEPv:
  258|      2|    static void Gen(void* absl_flag_default_loc) {                            \
  259|      2|      new (absl_flag_default_loc) Type(AbslFlagDefaultGenFor##name{}.value);  \
  260|      2|    }                                                                         \
_ZN28AbslFlagDefaultGenForfromenv3GenEPv:
  258|      2|    static void Gen(void* absl_flag_default_loc) {                            \
  259|      2|      new (absl_flag_default_loc) Type(AbslFlagDefaultGenFor##name{}.value);  \
  260|      2|    }                                                                         \
_ZN31AbslFlagDefaultGenFortryfromenv3GenEPv:
  258|      2|    static void Gen(void* absl_flag_default_loc) {                            \
  259|      2|      new (absl_flag_default_loc) Type(AbslFlagDefaultGenFor##name{}.value);  \
  260|      2|    }                                                                         \
_ZN4absl12lts_202605267GetFlagINSt3__16vectorINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS7_IS9_EEEEEET_RKNS0_14flags_internal4FlagISC_EE:
   98|     10|[[nodiscard]] T GetFlag(const absl::Flag<T>& flag) {
   99|     10|  return flags_internal::FlagImplPeer::InvokeGet<T>(flag);
  100|     10|}

_ZN4absl12lts_2026052614flags_internal15DynValueDeleterC2EPFPvNS1_6FlagOpEPKvS3_S3_E:
  168|      2|DynValueDeleter::DynValueDeleter(FlagOpFn op_arg) : op(op_arg) {}
_ZNK4absl12lts_2026052614flags_internal15DynValueDeleterclEPv:
  170|      2|void DynValueDeleter::operator()(void* ptr) const {
  171|      2|  if (op == nullptr) return;
  ------------------
  |  Branch (171:7): [True: 0, False: 2]
  ------------------
  172|       |
  173|      2|  Delete(op, ptr);
  174|      2|}
_ZN4absl12lts_2026052614flags_internal13MaskedPointerC2EPvb:
  176|     20|MaskedPointer::MaskedPointer(ptr_t rhs, bool is_candidate) : ptr_(rhs) {
  177|     20|  if (is_candidate) {
  ------------------
  |  Branch (177:7): [True: 20, False: 0]
  ------------------
  178|     20|    ApplyMask(kUnprotectedReadCandidate);
  179|     20|  }
  180|     20|}
_ZNK4absl12lts_2026052614flags_internal13MaskedPointer26IsUnprotectedReadCandidateEv:
  182|     22|bool MaskedPointer::IsUnprotectedReadCandidate() const {
  183|     22|  return CheckMask(kUnprotectedReadCandidate);
  184|     22|}
_ZNK4absl12lts_2026052614flags_internal13MaskedPointer11HasBeenReadEv:
  186|     22|bool MaskedPointer::HasBeenRead() const { return CheckMask(kHasBeenRead); }
_ZN4absl12lts_2026052614flags_internal13MaskedPointer3SetEPFPvNS1_6FlagOpEPKvS3_S3_ES6_b:
  188|      2|void MaskedPointer::Set(FlagOpFn op, const void* src, bool is_candidate) {
  189|      2|  flags_internal::Copy(op, src, Ptr());
  190|      2|  if (is_candidate) {
  ------------------
  |  Branch (190:7): [True: 2, False: 0]
  ------------------
  191|      2|    ApplyMask(kUnprotectedReadCandidate);
  192|      2|  }
  193|      2|}
_ZN4absl12lts_2026052614flags_internal13MaskedPointer10MarkAsReadEv:
  194|     20|void MaskedPointer::MarkAsRead() { ApplyMask(kHasBeenRead); }
_ZN4absl12lts_2026052614flags_internal13MaskedPointer9ApplyMaskEm:
  196|     42|void MaskedPointer::ApplyMask(mask_t mask) {
  197|     42|  ptr_ = reinterpret_cast<ptr_t>(reinterpret_cast<mask_t>(ptr_) | mask);
  198|     42|}
_ZNK4absl12lts_2026052614flags_internal13MaskedPointer9CheckMaskEm:
  199|     44|bool MaskedPointer::CheckMask(mask_t mask) const {
  200|     44|  return (reinterpret_cast<mask_t>(ptr_) & mask) != 0;
  201|     44|}
_ZN4absl12lts_2026052614flags_internal8FlagImpl4InitEv:
  203|     48|void FlagImpl::Init() {
  204|     48|  new (&data_guard_) absl::Mutex;
  205|       |
  206|     48|  auto def_kind = static_cast<FlagDefaultKind>(def_kind_);
  207|       |
  208|     48|  switch (ValueStorageKind()) {
  ------------------
  |  Branch (208:11): [True: 48, False: 0]
  ------------------
  209|     12|    case FlagValueStorageKind::kValueAndInitBit:
  ------------------
  |  Branch (209:5): [True: 12, False: 36]
  ------------------
  210|     16|    case FlagValueStorageKind::kOneWordAtomic: {
  ------------------
  |  Branch (210:5): [True: 4, False: 44]
  ------------------
  211|     16|      alignas(int64_t) std::array<char, sizeof(int64_t)> buf{};
  212|     16|      if (def_kind == FlagDefaultKind::kGenFunc) {
  ------------------
  |  Branch (212:11): [True: 2, False: 14]
  ------------------
  213|      2|        (*default_value_.gen_func)(buf.data());
  214|     14|      } else {
  215|     14|        assert(def_kind != FlagDefaultKind::kDynamicValue);
  216|     14|        std::memcpy(buf.data(), &default_value_, Sizeof(op_));
  217|     14|      }
  218|     16|      if (ValueStorageKind() == FlagValueStorageKind::kValueAndInitBit) {
  ------------------
  |  Branch (218:11): [True: 12, False: 4]
  ------------------
  219|       |        // We presume here the memory layout of FlagValueAndInitBit struct.
  220|     12|        uint8_t initialized = 1;
  221|     12|        std::memcpy(buf.data() + Sizeof(op_), &initialized,
  222|     12|                    sizeof(initialized));
  223|     12|      }
  224|       |      // Type can contain valid uninitialized bits, e.g. padding.
  225|     16|      ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(buf.data(), buf.size());
  226|     16|      OneWordValue().store(absl::bit_cast<int64_t>(buf),
  227|     16|                           std::memory_order_release);
  228|     16|      break;
  229|     12|    }
  230|     12|    case FlagValueStorageKind::kSequenceLocked: {
  ------------------
  |  Branch (230:5): [True: 12, False: 36]
  ------------------
  231|       |      // For this storage kind the default_value_ always points to gen_func
  232|       |      // during initialization.
  233|     12|      assert(def_kind == FlagDefaultKind::kGenFunc);
  234|     12|      (*default_value_.gen_func)(AtomicBufferValue());
  235|     12|      break;
  236|     12|    }
  237|     20|    case FlagValueStorageKind::kHeapAllocated:
  ------------------
  |  Branch (237:5): [True: 20, False: 28]
  ------------------
  238|       |      // For this storage kind the default_value_ always points to gen_func
  239|       |      // during initialization.
  240|     20|      assert(def_kind == FlagDefaultKind::kGenFunc);
  241|       |      // Flag value initially points to the internal buffer.
  242|     20|      MaskedPointer ptr_value = PtrStorage().load(std::memory_order_acquire);
  243|     20|      (*default_value_.gen_func)(ptr_value.Ptr());
  244|       |      // Default value is a candidate for an unprotected read.
  245|     20|      PtrStorage().store(MaskedPointer(ptr_value.Ptr(), true),
  246|     20|                         std::memory_order_release);
  247|     20|      break;
  248|     48|  }
  249|     48|  seq_lock_.MarkInitialized();
  250|     48|}
_ZNK4absl12lts_2026052614flags_internal8FlagImpl9DataGuardEv:
  252|     74|absl::Mutex& FlagImpl::DataGuard() const {
  253|     74|  absl::call_once(const_cast<FlagImpl*>(this)->init_control_, &FlagImpl::Init,
  254|     74|                  const_cast<FlagImpl*>(this));
  255|       |
  256|       |  // data_guard_ is initialized inside Init.
  257|     74|  return *reinterpret_cast<absl::Mutex*>(&data_guard_);
  258|     74|}
_ZNK4absl12lts_2026052614flags_internal8FlagImpl13MakeInitValueEv:
  285|      2|std::unique_ptr<void, DynValueDeleter> FlagImpl::MakeInitValue() const {
  286|      2|  void* res = nullptr;
  287|      2|  switch (DefaultKind()) {
  288|      0|    case FlagDefaultKind::kDynamicValue:
  ------------------
  |  Branch (288:5): [True: 0, False: 2]
  ------------------
  289|      0|      res = flags_internal::Clone(op_, default_value_.dynamic_value);
  290|      0|      break;
  291|      2|    case FlagDefaultKind::kGenFunc:
  ------------------
  |  Branch (291:5): [True: 2, False: 0]
  ------------------
  292|      2|      res = flags_internal::Alloc(op_);
  293|      2|      (*default_value_.gen_func)(res);
  294|      2|      break;
  295|      0|    default:
  ------------------
  |  Branch (295:5): [True: 0, False: 2]
  ------------------
  296|      0|      res = flags_internal::Clone(op_, &default_value_);
  297|      0|      break;
  298|      2|  }
  299|      2|  return {res, DynValueDeleter{op_}};
  300|      2|}
_ZN4absl12lts_2026052614flags_internal8FlagImpl10StoreValueEPKvNS1_11ValueSourceE:
  302|      2|void FlagImpl::StoreValue(const void* src, ValueSource source) {
  303|      2|  switch (ValueStorageKind()) {
  ------------------
  |  Branch (303:11): [True: 2, False: 0]
  ------------------
  304|      0|    case FlagValueStorageKind::kValueAndInitBit:
  ------------------
  |  Branch (304:5): [True: 0, False: 2]
  ------------------
  305|      0|    case FlagValueStorageKind::kOneWordAtomic: {
  ------------------
  |  Branch (305:5): [True: 0, False: 2]
  ------------------
  306|       |      // Load the current value to avoid setting 'init' bit manually.
  307|      0|      int64_t one_word_val = OneWordValue().load(std::memory_order_acquire);
  308|      0|      std::memcpy(&one_word_val, src, Sizeof(op_));
  309|      0|      OneWordValue().store(one_word_val, std::memory_order_release);
  310|      0|      seq_lock_.IncrementModificationCount();
  311|      0|      break;
  312|      0|    }
  313|      0|    case FlagValueStorageKind::kSequenceLocked: {
  ------------------
  |  Branch (313:5): [True: 0, False: 2]
  ------------------
  314|      0|      seq_lock_.Write(AtomicBufferValue(), src, Sizeof(op_));
  315|      0|      break;
  316|      0|    }
  317|      2|    case FlagValueStorageKind::kHeapAllocated:
  ------------------
  |  Branch (317:5): [True: 2, False: 0]
  ------------------
  318|      2|      MaskedPointer ptr_value = PtrStorage().load(std::memory_order_acquire);
  319|       |
  320|      2|      if (ptr_value.IsUnprotectedReadCandidate() && ptr_value.HasBeenRead()) {
  ------------------
  |  Branch (320:11): [True: 2, False: 0]
  |  Branch (320:53): [True: 0, False: 2]
  ------------------
  321|       |        // If current value is a candidate for an unprotected read and if it was
  322|       |        // already read at least once, follow up reads (if any) are done without
  323|       |        // mutex protection. We can't guarantee it is safe to reuse this memory
  324|       |        // since it may have been accessed by another thread concurrently, so
  325|       |        // instead we move the memory to a freelist so it can still be safely
  326|       |        // accessed, and allocate a new one for the new value.
  327|      0|        AddToFreelist(ptr_value.Ptr());
  328|      0|        ptr_value = MaskedPointer(Clone(op_, src), source == kCommandLine);
  329|      2|      } else {
  330|       |        // Current value either was set programmatically or was never read.
  331|       |        // We can reuse the memory since all accesses to this value (if any)
  332|       |        // were protected by mutex. That said, if a new value comes from command
  333|       |        // line it now becomes a candidate for an unprotected read.
  334|      2|        ptr_value.Set(op_, src, source == kCommandLine);
  335|      2|      }
  336|       |
  337|      2|      PtrStorage().store(ptr_value, std::memory_order_release);
  338|      2|      seq_lock_.IncrementModificationCount();
  339|      2|      break;
  340|      2|  }
  341|      2|  modified_ = true;
  342|      2|  InvokeCallback();
  343|      2|}
_ZNK4absl12lts_2026052614flags_internal8FlagImpl4NameEv:
  345|    582|absl::string_view FlagImpl::Name() const { return name_; }
_ZNK4absl12lts_2026052614flags_internal8FlagImpl8FilenameEv:
  349|     50|std::string FlagImpl::Filename() const {
  350|     50|  return flags_internal::GetUsageConfig().normalize_filename(filename_);
  351|     50|}
_ZNK4absl12lts_2026052614flags_internal8FlagImpl6TypeIdEv:
  358|      2|FlagFastTypeId FlagImpl::TypeId() const {
  359|      2|  return flags_internal::FastTypeId(op_);
  360|      2|}
_ZN4absl12lts_2026052614flags_internal8FlagImpl11SetCallbackEPFvvE:
  404|     14|void FlagImpl::SetCallback(const FlagCallbackFunc mutation_callback) {
  405|     14|  absl::MutexLock l(DataGuard());
  406|       |
  407|     14|  if (callback_ == nullptr) {
  ------------------
  |  Branch (407:7): [True: 14, False: 0]
  ------------------
  408|     14|    callback_ = new FlagCallback;
  409|     14|  }
  410|     14|  callback_->func = mutation_callback;
  411|       |
  412|     14|  InvokeCallback();
  413|     14|}
_ZNK4absl12lts_2026052614flags_internal8FlagImpl14InvokeCallbackEv:
  415|     16|void FlagImpl::InvokeCallback() const {
  416|     16|  if (!callback_) return;
  ------------------
  |  Branch (416:7): [True: 2, False: 14]
  ------------------
  417|       |
  418|       |  // Make a copy of the C-style function pointer that we are about to invoke
  419|       |  // before we release the lock guarding it.
  420|     14|  FlagCallbackFunc cb = callback_->func;
  421|       |
  422|       |  // If the flag has a mutation callback this function invokes it. While the
  423|       |  // callback is being invoked the primary flag's mutex is unlocked and it is
  424|       |  // re-locked back after call to callback is completed. Callback invocation is
  425|       |  // guarded by flag's secondary mutex instead which prevents concurrent
  426|       |  // callback invocation. Note that it is possible for other thread to grab the
  427|       |  // primary lock and update flag's value at any time during the callback
  428|       |  // invocation. This is by design. Callback can get a value of the flag if
  429|       |  // necessary, but it might be different from the value initiated the callback
  430|       |  // and it also can be different by the time the callback invocation is
  431|       |  // completed. Requires that *primary_lock be held in exclusive mode; it may be
  432|       |  // released and reacquired by the implementation.
  433|     14|  MutexRelock relock(DataGuard());
  434|     14|  absl::MutexLock lock(callback_->guard);
  435|     14|  cb();
  436|     14|}
_ZNK4absl12lts_2026052614flags_internal8FlagImpl17AtomicBufferValueEv:
  503|     22|std::atomic<uint64_t>* FlagImpl::AtomicBufferValue() const {
  504|       |  assert(ValueStorageKind() == FlagValueStorageKind::kSequenceLocked);
  505|     22|  return OffsetValue<std::atomic<uint64_t>>();
  506|     22|}
_ZNK4absl12lts_2026052614flags_internal8FlagImpl12OneWordValueEv:
  508|     30|std::atomic<int64_t>& FlagImpl::OneWordValue() const {
  509|       |  assert(ValueStorageKind() == FlagValueStorageKind::kOneWordAtomic ||
  510|     30|         ValueStorageKind() == FlagValueStorageKind::kValueAndInitBit);
  511|     30|  return OffsetValue<FlagOneWordValue>()->value;
  512|     30|}
_ZNK4absl12lts_2026052614flags_internal8FlagImpl10PtrStorageEv:
  514|     84|std::atomic<MaskedPointer>& FlagImpl::PtrStorage() const {
  515|       |  assert(ValueStorageKind() == FlagValueStorageKind::kHeapAllocated);
  516|     84|  return OffsetValue<FlagMaskedPointerValue>()->value;
  517|     84|}
_ZNK4absl12lts_2026052614flags_internal8FlagImpl8TryParseENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEERNS3_12basic_stringIcS6_NS3_9allocatorIcEEEE:
  524|      2|    absl::string_view value, std::string& err) const {
  525|      2|  std::unique_ptr<void, DynValueDeleter> tentative_value = MakeInitValue();
  526|       |
  527|      2|  std::string parse_err;
  528|      2|  if (!flags_internal::Parse(op_, value, tentative_value.get(), &parse_err)) {
  ------------------
  |  Branch (528:7): [True: 0, False: 2]
  ------------------
  529|      0|    absl::string_view err_sep = parse_err.empty() ? "" : "; ";
  ------------------
  |  Branch (529:33): [True: 0, False: 0]
  ------------------
  530|      0|    err = absl::StrCat("Illegal value '", value, "' specified for flag '",
  531|      0|                       Name(), "'", err_sep, parse_err);
  532|      0|    return nullptr;
  533|      0|  }
  534|       |
  535|      2|  return tentative_value;
  536|      2|}
_ZNK4absl12lts_2026052614flags_internal8FlagImpl4ReadEPv:
  538|     30|void FlagImpl::Read(void* dst) const {
  539|     30|  auto& guard = DataGuard();  // Make sure flag initialized
  540|     30|  switch (ValueStorageKind()) {
  ------------------
  |  Branch (540:11): [True: 30, False: 0]
  ------------------
  541|      0|    case FlagValueStorageKind::kValueAndInitBit:
  ------------------
  |  Branch (541:5): [True: 0, False: 30]
  ------------------
  542|      0|    case FlagValueStorageKind::kOneWordAtomic: {
  ------------------
  |  Branch (542:5): [True: 0, False: 30]
  ------------------
  543|      0|      const int64_t one_word_val =
  544|      0|          OneWordValue().load(std::memory_order_acquire);
  545|      0|      std::memcpy(dst, &one_word_val, Sizeof(op_));
  546|      0|      break;
  547|      0|    }
  548|     10|    case FlagValueStorageKind::kSequenceLocked: {
  ------------------
  |  Branch (548:5): [True: 10, False: 20]
  ------------------
  549|     10|      ReadSequenceLockedData(dst);
  550|     10|      break;
  551|      0|    }
  552|     20|    case FlagValueStorageKind::kHeapAllocated: {
  ------------------
  |  Branch (552:5): [True: 20, False: 10]
  ------------------
  553|     20|      absl::MutexLock l(guard);
  554|     20|      MaskedPointer ptr_value = PtrStorage().load(std::memory_order_acquire);
  555|       |
  556|     20|      flags_internal::CopyConstruct(op_, ptr_value.Ptr(), dst);
  557|       |
  558|       |      // For unprotected read candidates, mark that the value as has been read.
  559|     20|      if (ptr_value.IsUnprotectedReadCandidate() && !ptr_value.HasBeenRead()) {
  ------------------
  |  Branch (559:11): [True: 20, False: 0]
  |  Branch (559:53): [True: 20, False: 0]
  ------------------
  560|     20|        ptr_value.MarkAsRead();
  561|     20|        PtrStorage().store(ptr_value, std::memory_order_release);
  562|     20|      }
  563|     20|      break;
  564|      0|    }
  565|     30|  }
  566|     30|}
_ZNK4absl12lts_2026052614flags_internal8FlagImpl11ReadOneWordEv:
  568|      6|int64_t FlagImpl::ReadOneWord() const {
  569|       |  assert(ValueStorageKind() == FlagValueStorageKind::kOneWordAtomic ||
  570|      6|         ValueStorageKind() == FlagValueStorageKind::kValueAndInitBit);
  571|      6|  auto& guard = DataGuard();  // Make sure flag initialized
  572|      6|  (void)guard;
  573|      6|  return OneWordValue().load(std::memory_order_acquire);
  574|      6|}
_ZNK4absl12lts_2026052614flags_internal8FlagImpl11ReadOneBoolEv:
  576|      8|bool FlagImpl::ReadOneBool() const {
  577|       |  assert(ValueStorageKind() == FlagValueStorageKind::kValueAndInitBit);
  578|      8|  auto& guard = DataGuard();  // Make sure flag initialized
  579|      8|  (void)guard;
  580|      8|  return absl::bit_cast<FlagValueAndInitBit<bool>>(
  581|      8|             OneWordValue().load(std::memory_order_acquire))
  582|      8|      .value;
  583|      8|}
_ZNK4absl12lts_2026052614flags_internal8FlagImpl22ReadSequenceLockedDataEPv:
  585|     10|void FlagImpl::ReadSequenceLockedData(void* dst) const {
  586|     10|  size_t size = Sizeof(op_);
  587|       |  // Attempt to read using the sequence lock.
  588|     10|  if (ABSL_PREDICT_TRUE(seq_lock_.TryRead(dst, AtomicBufferValue(), size))) {
  ------------------
  |  |  191|     10|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 10, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 10]
  |  |  |  Branch (191:57): [True: 10, False: 0]
  |  |  ------------------
  ------------------
  589|     10|    return;
  590|     10|  }
  591|       |  // We failed due to contention. Acquire the lock to prevent contention
  592|       |  // and try again.
  593|      0|  absl::ReaderMutexLock l(DataGuard());
  594|      0|  bool success = seq_lock_.TryRead(dst, AtomicBufferValue(), size);
  595|       |  assert(success);
  596|      0|  static_cast<void>(success);
  597|      0|}
_ZN4absl12lts_2026052614flags_internal8FlagImpl9ParseFromENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEENS1_15FlagSettingModeENS1_11ValueSourceERNS3_12basic_stringIcS6_NS3_9allocatorIcEEEE:
  625|      2|                         ValueSource source, std::string& err) {
  626|      2|  absl::MutexLock l(DataGuard());
  627|       |
  628|      2|  switch (set_mode) {
  ------------------
  |  Branch (628:11): [True: 2, False: 0]
  ------------------
  629|      2|    case SET_FLAGS_VALUE: {
  ------------------
  |  Branch (629:5): [True: 2, False: 0]
  ------------------
  630|       |      // set or modify the flag's value
  631|      2|      auto tentative_value = TryParse(value, err);
  632|      2|      if (!tentative_value) return false;
  ------------------
  |  Branch (632:11): [True: 0, False: 2]
  ------------------
  633|       |
  634|      2|      StoreValue(tentative_value.get(), source);
  635|       |
  636|      2|      if (source == kCommandLine) {
  ------------------
  |  Branch (636:11): [True: 2, False: 0]
  ------------------
  637|      2|        on_command_line_ = true;
  638|      2|      }
  639|      2|      break;
  640|      2|    }
  641|      0|    case SET_FLAG_IF_DEFAULT: {
  ------------------
  |  Branch (641:5): [True: 0, False: 2]
  ------------------
  642|       |      // set the flag's value, but only if it hasn't been set by someone else
  643|      0|      if (modified_) {
  ------------------
  |  Branch (643:11): [True: 0, False: 0]
  ------------------
  644|       |        // TODO(rogeeff): review and fix this semantic. Currently we do not fail
  645|       |        // in this case if flag is modified. This is misleading since the flag's
  646|       |        // value is not updated even though we return true.
  647|       |        // *err = absl::StrCat(Name(), " is already set to ",
  648|       |        //                     CurrentValue(), "\n");
  649|       |        // return false;
  650|      0|        return true;
  651|      0|      }
  652|      0|      auto tentative_value = TryParse(value, err);
  653|      0|      if (!tentative_value) return false;
  ------------------
  |  Branch (653:11): [True: 0, False: 0]
  ------------------
  654|       |
  655|      0|      StoreValue(tentative_value.get(), source);
  656|      0|      break;
  657|      0|    }
  658|      0|    case SET_FLAGS_DEFAULT: {
  ------------------
  |  Branch (658:5): [True: 0, False: 2]
  ------------------
  659|      0|      auto tentative_value = TryParse(value, err);
  660|      0|      if (!tentative_value) return false;
  ------------------
  |  Branch (660:11): [True: 0, False: 0]
  ------------------
  661|       |
  662|      0|      if (DefaultKind() == FlagDefaultKind::kDynamicValue) {
  ------------------
  |  Branch (662:11): [True: 0, False: 0]
  ------------------
  663|      0|        void* old_value = default_value_.dynamic_value;
  664|      0|        default_value_.dynamic_value = tentative_value.release();
  665|      0|        tentative_value.reset(old_value);
  666|      0|      } else {
  667|      0|        default_value_.dynamic_value = tentative_value.release();
  668|      0|        def_kind_ = static_cast<uint8_t>(FlagDefaultKind::kDynamicValue);
  669|      0|      }
  670|       |
  671|      0|      if (!modified_) {
  ------------------
  |  Branch (671:11): [True: 0, False: 0]
  ------------------
  672|       |        // Need to set both default value *and* current, in this case.
  673|      0|        StoreValue(default_value_.dynamic_value, source);
  674|      0|        modified_ = false;
  675|      0|      }
  676|      0|      break;
  677|      0|    }
  678|      2|  }
  679|       |
  680|      2|  return true;
  681|      2|}
flag.cc:_ZN4absl12lts_2026052614flags_internal12_GLOBAL__N_111MutexRelockC2ERNS0_5MutexE:
   77|     14|  explicit MutexRelock(absl::Mutex& mu) : mu_(mu) { mu_.unlock(); }
flag.cc:_ZN4absl12lts_2026052614flags_internal12_GLOBAL__N_111MutexRelockD2Ev:
   78|     14|  ~MutexRelock() { mu_.lock(); }
_ZNK4absl12lts_2026052614flags_internal8FlagImpl11OffsetValueINSt3__16atomicImEEEEPT_v:
  495|     22|StorageT* FlagImpl::OffsetValue() const {
  496|     22|  char* p = reinterpret_cast<char*>(const_cast<FlagImpl*>(this));
  497|       |  // The offset is deduced via Flag value type specific op_.
  498|     22|  ptrdiff_t offset = flags_internal::ValueOffset(op_);
  499|       |
  500|     22|  return reinterpret_cast<StorageT*>(p + offset);
  501|     22|}
_ZNK4absl12lts_2026052614flags_internal8FlagImpl11OffsetValueINS1_16FlagOneWordValueEEEPT_v:
  495|     30|StorageT* FlagImpl::OffsetValue() const {
  496|     30|  char* p = reinterpret_cast<char*>(const_cast<FlagImpl*>(this));
  497|       |  // The offset is deduced via Flag value type specific op_.
  498|     30|  ptrdiff_t offset = flags_internal::ValueOffset(op_);
  499|       |
  500|     30|  return reinterpret_cast<StorageT*>(p + offset);
  501|     30|}
_ZNK4absl12lts_2026052614flags_internal8FlagImpl11OffsetValueINS1_22FlagMaskedPointerValueEEEPT_v:
  495|     84|StorageT* FlagImpl::OffsetValue() const {
  496|     84|  char* p = reinterpret_cast<char*>(const_cast<FlagImpl*>(this));
  497|       |  // The offset is deduced via Flag value type specific op_.
  498|     84|  ptrdiff_t offset = flags_internal::ValueOffset(op_);
  499|       |
  500|     84|  return reinterpret_cast<StorageT*>(p + offset);
  501|     84|}

_ZN4absl12lts_2026052614flags_internal13FlagRegistrarIbLb1EEC2ERNS1_4FlagIbEEPKc:
  942|     10|      : flag_(flag) {
  943|     10|    if (do_register)
  ------------------
  |  Branch (943:9): [True: 10, Folded]
  ------------------
  944|     10|      flags_internal::RegisterCommandLineFlag(flag_.impl_, filename);
  945|     10|  }
_ZNK4absl12lts_2026052614flags_internal13FlagRegistrarIbLb1EEcvNS1_18FlagRegistrarEmptyEEv:
  955|     10|  constexpr operator FlagRegistrarEmpty() const { return {}; }  // NOLINT
_ZN4absl12lts_2026052614flags_internal16InitDefaultValueINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEET_SA_:
  276|      8|constexpr T InitDefaultValue(T t) {
  277|      8|  return t;
  278|      8|}
_ZN4absl12lts_2026052614flags_internal13FlagRegistrarINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEELb1EEC2ERNS1_4FlagIS9_EEPKc:
  942|      6|      : flag_(flag) {
  943|      6|    if (do_register)
  ------------------
  |  Branch (943:9): [True: 6, Folded]
  ------------------
  944|      6|      flags_internal::RegisterCommandLineFlag(flag_.impl_, filename);
  945|      6|  }
_ZNK4absl12lts_2026052614flags_internal13FlagRegistrarINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEELb1EEcvNS1_18FlagRegistrarEmptyEEv:
  955|      6|  constexpr operator FlagRegistrarEmpty() const { return {}; }  // NOLINT
_ZN4absl12lts_2026052614flags_internal16InitDefaultValueINS0_8DurationEEET_S4_:
  276|     10|constexpr T InitDefaultValue(T t) {
  277|     10|  return t;
  278|     10|}
_ZN4absl12lts_2026052614flags_internal13FlagRegistrarINS0_8DurationELb1EEC2ERNS1_4FlagIS3_EEPKc:
  942|     10|      : flag_(flag) {
  943|     10|    if (do_register)
  ------------------
  |  Branch (943:9): [True: 10, Folded]
  ------------------
  944|     10|      flags_internal::RegisterCommandLineFlag(flag_.impl_, filename);
  945|     10|  }
_ZNK4absl12lts_2026052614flags_internal13FlagRegistrarINS0_8DurationELb1EEcvNS1_18FlagRegistrarEmptyEEv:
  955|     10|  constexpr operator FlagRegistrarEmpty() const { return {}; }  // NOLINT
_ZN4absl12lts_2026052614flags_internal16InitDefaultValueIN8fuzztest8internal14TimeBudgetTypeEEET_S6_:
  276|      2|constexpr T InitDefaultValue(T t) {
  277|      2|  return t;
  278|      2|}
_ZN4absl12lts_2026052614flags_internal13FlagRegistrarIN8fuzztest8internal14TimeBudgetTypeELb1EEC2ERNS1_4FlagIS5_EEPKc:
  942|      2|      : flag_(flag) {
  943|      2|    if (do_register)
  ------------------
  |  Branch (943:9): [True: 2, Folded]
  ------------------
  944|      2|      flags_internal::RegisterCommandLineFlag(flag_.impl_, filename);
  945|      2|  }
_ZNK4absl12lts_2026052614flags_internal13FlagRegistrarIN8fuzztest8internal14TimeBudgetTypeELb1EEcvNS1_18FlagRegistrarEmptyEEv:
  955|      2|  constexpr operator FlagRegistrarEmpty() const { return {}; }  // NOLINT
_ZN4absl12lts_2026052614flags_internal16InitDefaultValueINSt3__18optionalINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEET_SC_:
  276|      8|constexpr T InitDefaultValue(T t) {
  277|      8|  return t;
  278|      8|}
_ZN4absl12lts_2026052614flags_internal13FlagRegistrarINSt3__18optionalINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEELb1EEC2ERNS1_4FlagISB_EEPKc:
  942|      8|      : flag_(flag) {
  943|      8|    if (do_register)
  ------------------
  |  Branch (943:9): [True: 8, Folded]
  ------------------
  944|      8|      flags_internal::RegisterCommandLineFlag(flag_.impl_, filename);
  945|      8|  }
_ZNK4absl12lts_2026052614flags_internal13FlagRegistrarINSt3__18optionalINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEELb1EEcvNS1_18FlagRegistrarEmptyEEv:
  955|      8|  constexpr operator FlagRegistrarEmpty() const { return {}; }  // NOLINT
_ZN4absl12lts_2026052614flags_internal13FlagRegistrarImLb1EEC2ERNS1_4FlagImEEPKc:
  942|      4|      : flag_(flag) {
  943|      4|    if (do_register)
  ------------------
  |  Branch (943:9): [True: 4, Folded]
  ------------------
  944|      4|      flags_internal::RegisterCommandLineFlag(flag_.impl_, filename);
  945|      4|  }
_ZNK4absl12lts_2026052614flags_internal13FlagRegistrarImLb1EEcvNS1_18FlagRegistrarEmptyEEv:
  955|      4|  constexpr operator FlagRegistrarEmpty() const { return {}; }  // NOLINT
_ZN4absl12lts_2026052614flags_internal16InitDefaultValueINSt3__18optionalImEEEET_S6_:
  276|      2|constexpr T InitDefaultValue(T t) {
  277|      2|  return t;
  278|      2|}
_ZN4absl12lts_2026052614flags_internal13FlagRegistrarINSt3__18optionalImEELb1EEC2ERNS1_4FlagIS5_EEPKc:
  942|      2|      : flag_(flag) {
  943|      2|    if (do_register)
  ------------------
  |  Branch (943:9): [True: 2, Folded]
  ------------------
  944|      2|      flags_internal::RegisterCommandLineFlag(flag_.impl_, filename);
  945|      2|  }
_ZNK4absl12lts_2026052614flags_internal13FlagRegistrarINSt3__18optionalImEELb1EEcvNS1_18FlagRegistrarEmptyEEv:
  955|      2|  constexpr operator FlagRegistrarEmpty() const { return {}; }  // NOLINT
_ZN4absl12lts_2026052614flags_internal12FlagImplPeer9InvokeGetINSt3__18optionalINS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEENS1_4FlagISC_EEEET_RKT0_:
  860|     14|  static T InvokeGet(const FlagType& flag) {
  861|     14|    return flag.Get();
  862|     14|  }
_ZNK4absl12lts_2026052614flags_internal4FlagINSt3__18optionalINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEE3GetEv:
  820|     14|  T Get() const {
  821|       |    // See implementation notes in CommandLineFlag::Get().
  822|     14|    union U {
  823|     14|      T value;
  824|     14|      U() {}
  825|     14|      ~U() { value.~T(); }
  826|     14|    };
  827|     14|    U u;
  828|       |
  829|       |#if !defined(NDEBUG)
  830|       |    impl_.AssertValidType(absl::FastTypeId<T>(), &GenRuntimeTypeId<T>);
  831|       |#endif
  832|       |
  833|     14|    if (ABSL_PREDICT_FALSE(!value_.Get(impl_.seq_lock_, u.value))) {
  ------------------
  |  |  190|     14|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 8, False: 6]
  |  |  |  Branch (190:49): [Folded, False: 14]
  |  |  |  Branch (190:58): [True: 8, False: 6]
  |  |  ------------------
  ------------------
  834|      8|      impl_.Read(&u.value);
  835|      8|    }
  836|     14|    return std::move(u.value);
  837|     14|  }
_ZZNK4absl12lts_2026052614flags_internal4FlagINSt3__18optionalINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEE3GetEvEN1UC2Ev:
  824|     14|      U() {}
_ZNK4absl12lts_2026052614flags_internal9FlagValueINSt3__18optionalINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEELNS1_20FlagValueStorageKindE3EE3GetERKNS1_12SequenceLockERSB_:
  536|     14|  bool Get(const SequenceLock&, T& dst) const {
  537|     14|    MaskedPointer ptr_value = value.load(std::memory_order_acquire);
  538|       |
  539|     14|    if (ABSL_PREDICT_TRUE(ptr_value.AllowsUnprotectedRead())) {
  ------------------
  |  |  191|     14|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 6, False: 8]
  |  |  |  Branch (191:48): [Folded, False: 14]
  |  |  |  Branch (191:57): [True: 6, False: 8]
  |  |  ------------------
  ------------------
  540|      6|      ::new (static_cast<void*>(&dst)) T(*static_cast<T*>(ptr_value.Ptr()));
  541|      6|      return true;
  542|      6|    }
  543|      8|    return false;
  544|     14|  }
_ZNK4absl12lts_2026052614flags_internal13MaskedPointer21AllowsUnprotectedReadEv:
  387|     40|  bool AllowsUnprotectedRead() const {
  388|     40|    return (reinterpret_cast<mask_t>(ptr_) & kAllowsUnprotectedRead) ==
  389|     40|           kAllowsUnprotectedRead;
  390|     40|  }
_ZNK4absl12lts_2026052614flags_internal13MaskedPointer3PtrEv:
  383|     82|  void* Ptr() const {
  384|     82|    return reinterpret_cast<void*>(reinterpret_cast<mask_t>(ptr_) &
  385|     82|                                   kPtrValueMask);
  386|     82|  }
_ZZNK4absl12lts_2026052614flags_internal4FlagINSt3__18optionalINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEE3GetEvEN1UD2Ev:
  825|     14|      ~U() { value.~T(); }
_ZN4absl12lts_2026052614flags_internal12FlagImplPeer9InvokeGetINS0_8DurationENS1_4FlagIS4_EEEET_RKT0_:
  860|     14|  static T InvokeGet(const FlagType& flag) {
  861|     14|    return flag.Get();
  862|     14|  }
_ZNK4absl12lts_2026052614flags_internal4FlagINS0_8DurationEE3GetEv:
  820|     14|  T Get() const {
  821|       |    // See implementation notes in CommandLineFlag::Get().
  822|     14|    union U {
  823|     14|      T value;
  824|     14|      U() {}
  825|     14|      ~U() { value.~T(); }
  826|     14|    };
  827|     14|    U u;
  828|       |
  829|       |#if !defined(NDEBUG)
  830|       |    impl_.AssertValidType(absl::FastTypeId<T>(), &GenRuntimeTypeId<T>);
  831|       |#endif
  832|       |
  833|     14|    if (ABSL_PREDICT_FALSE(!value_.Get(impl_.seq_lock_, u.value))) {
  ------------------
  |  |  190|     14|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 8, False: 6]
  |  |  |  Branch (190:49): [Folded, False: 14]
  |  |  |  Branch (190:58): [True: 8, False: 6]
  |  |  ------------------
  ------------------
  834|      8|      impl_.Read(&u.value);
  835|      8|    }
  836|     14|    return std::move(u.value);
  837|     14|  }
_ZZNK4absl12lts_2026052614flags_internal4FlagINS0_8DurationEE3GetEvEN1UC2Ev:
  824|     14|      U() {}
_ZNK4absl12lts_2026052614flags_internal9FlagValueINS0_8DurationELNS1_20FlagValueStorageKindE2EE3GetERKNS1_12SequenceLockERS3_:
  481|     14|  bool Get(const SequenceLock& lock, T& dst) const {
  482|     14|    return lock.TryRead(&dst, value_words, sizeof(T));
  483|     14|  }
_ZZNK4absl12lts_2026052614flags_internal4FlagINS0_8DurationEE3GetEvEN1UD2Ev:
  825|     14|      ~U() { value.~T(); }
_ZN4absl12lts_2026052614flags_internal12FlagImplPeer9InvokeGetIN8fuzztest8internal14TimeBudgetTypeENS1_4FlagIS6_EEEET_RKT0_:
  860|      2|  static T InvokeGet(const FlagType& flag) {
  861|      2|    return flag.Get();
  862|      2|  }
_ZNK4absl12lts_2026052614flags_internal4FlagIN8fuzztest8internal14TimeBudgetTypeEE3GetEv:
  820|      2|  T Get() const {
  821|       |    // See implementation notes in CommandLineFlag::Get().
  822|      2|    union U {
  823|      2|      T value;
  824|      2|      U() {}
  825|      2|      ~U() { value.~T(); }
  826|      2|    };
  827|      2|    U u;
  828|       |
  829|       |#if !defined(NDEBUG)
  830|       |    impl_.AssertValidType(absl::FastTypeId<T>(), &GenRuntimeTypeId<T>);
  831|       |#endif
  832|       |
  833|      2|    if (ABSL_PREDICT_FALSE(!value_.Get(impl_.seq_lock_, u.value))) {
  ------------------
  |  |  190|      2|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 2, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 2]
  |  |  |  Branch (190:58): [True: 2, False: 0]
  |  |  ------------------
  ------------------
  834|      2|      impl_.Read(&u.value);
  835|      2|    }
  836|      2|    return std::move(u.value);
  837|      2|  }
_ZZNK4absl12lts_2026052614flags_internal4FlagIN8fuzztest8internal14TimeBudgetTypeEE3GetEvEN1UC2Ev:
  824|      2|      U() {}
_ZNK4absl12lts_2026052614flags_internal9FlagValueIN8fuzztest8internal14TimeBudgetTypeELNS1_20FlagValueStorageKindE0EE3GetERKNS1_12SequenceLockERS5_:
  442|      2|  bool Get(const SequenceLock&, T& dst) const {
  443|      2|    int64_t storage = value.load(std::memory_order_acquire);
  444|      2|    if (ABSL_PREDICT_FALSE(storage == 0)) {
  ------------------
  |  |  190|      2|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 2, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 2]
  |  |  |  Branch (190:58): [True: 2, False: 0]
  |  |  ------------------
  ------------------
  445|       |      // This assert is to ensure that the initialization inside FlagImpl::Init
  446|       |      // is able to set init member correctly.
  447|      2|      static_assert(offsetof(FlagValueAndInitBit<T>, init) == sizeof(T),
  448|      2|                    "Unexpected memory layout of FlagValueAndInitBit");
  449|      2|      return false;
  450|      2|    }
  451|      0|    dst = absl::bit_cast<FlagValueAndInitBit<T>>(storage).value;
  452|      0|    return true;
  453|      2|  }
_ZNK4absl12lts_2026052614flags_internal8FlagImpl4ReadIN8fuzztest8internal14TimeBudgetTypeETnNSt3__19enable_ifIXeqclsr14flags_internalE11StorageKindIT_EELNS1_20FlagValueStorageKindE0EEiE4typeELi0EEEvPS9_:
  622|      2|  void Read(T* value) const ABSL_LOCKS_EXCLUDED(DataGuard()) {
  623|      2|    *value = absl::bit_cast<FlagValueAndInitBit<T>>(ReadOneWord()).value;
  624|      2|  }
_ZZNK4absl12lts_2026052614flags_internal4FlagIN8fuzztest8internal14TimeBudgetTypeEE3GetEvEN1UD2Ev:
  825|      2|      ~U() { value.~T(); }
_ZN4absl12lts_2026052614flags_internal12FlagImplPeer9InvokeGetINSt3__18optionalImEENS1_4FlagIS6_EEEET_RKT0_:
  860|      2|  static T InvokeGet(const FlagType& flag) {
  861|      2|    return flag.Get();
  862|      2|  }
_ZNK4absl12lts_2026052614flags_internal4FlagINSt3__18optionalImEEE3GetEv:
  820|      2|  T Get() const {
  821|       |    // See implementation notes in CommandLineFlag::Get().
  822|      2|    union U {
  823|      2|      T value;
  824|      2|      U() {}
  825|      2|      ~U() { value.~T(); }
  826|      2|    };
  827|      2|    U u;
  828|       |
  829|       |#if !defined(NDEBUG)
  830|       |    impl_.AssertValidType(absl::FastTypeId<T>(), &GenRuntimeTypeId<T>);
  831|       |#endif
  832|       |
  833|      2|    if (ABSL_PREDICT_FALSE(!value_.Get(impl_.seq_lock_, u.value))) {
  ------------------
  |  |  190|      2|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 2, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 2]
  |  |  |  Branch (190:58): [True: 2, False: 0]
  |  |  ------------------
  ------------------
  834|      2|      impl_.Read(&u.value);
  835|      2|    }
  836|      2|    return std::move(u.value);
  837|      2|  }
_ZZNK4absl12lts_2026052614flags_internal4FlagINSt3__18optionalImEEE3GetEvEN1UC2Ev:
  824|      2|      U() {}
_ZNK4absl12lts_2026052614flags_internal9FlagValueINSt3__18optionalImEELNS1_20FlagValueStorageKindE2EE3GetERKNS1_12SequenceLockERS5_:
  481|      2|  bool Get(const SequenceLock& lock, T& dst) const {
  482|      2|    return lock.TryRead(&dst, value_words, sizeof(T));
  483|      2|  }
_ZZNK4absl12lts_2026052614flags_internal4FlagINSt3__18optionalImEEE3GetEvEN1UD2Ev:
  825|      2|      ~U() { value.~T(); }
_ZN4absl12lts_2026052614flags_internal12FlagImplPeer9InvokeGetImNS1_4FlagImEEEET_RKT0_:
  860|      4|  static T InvokeGet(const FlagType& flag) {
  861|      4|    return flag.Get();
  862|      4|  }
_ZNK4absl12lts_2026052614flags_internal4FlagImE3GetEv:
  820|      4|  T Get() const {
  821|       |    // See implementation notes in CommandLineFlag::Get().
  822|      4|    union U {
  823|      4|      T value;
  824|      4|      U() {}
  825|      4|      ~U() { value.~T(); }
  826|      4|    };
  827|      4|    U u;
  828|       |
  829|       |#if !defined(NDEBUG)
  830|       |    impl_.AssertValidType(absl::FastTypeId<T>(), &GenRuntimeTypeId<T>);
  831|       |#endif
  832|       |
  833|      4|    if (ABSL_PREDICT_FALSE(!value_.Get(impl_.seq_lock_, u.value))) {
  ------------------
  |  |  190|      4|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 4, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 4]
  |  |  |  Branch (190:58): [True: 4, False: 0]
  |  |  ------------------
  ------------------
  834|      4|      impl_.Read(&u.value);
  835|      4|    }
  836|      4|    return std::move(u.value);
  837|      4|  }
_ZZNK4absl12lts_2026052614flags_internal4FlagImE3GetEvEN1UC2Ev:
  824|      4|      U() {}
_ZNK4absl12lts_2026052614flags_internal9FlagValueImLNS1_20FlagValueStorageKindE1EE3GetERKNS1_12SequenceLockERm:
  463|      4|  bool Get(const SequenceLock&, T& dst) const {
  464|      4|    int64_t one_word_val = value.load(std::memory_order_acquire);
  465|      4|    if (ABSL_PREDICT_FALSE(one_word_val == FlagOneWordValue::Uninitialized())) {
  ------------------
  |  |  190|      4|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 4, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 4]
  |  |  |  Branch (190:58): [True: 4, False: 0]
  |  |  ------------------
  ------------------
  466|      4|      return false;
  467|      4|    }
  468|      0|    std::memcpy(&dst, static_cast<const void*>(&one_word_val), sizeof(T));
  469|      0|    return true;
  470|      4|  }
_ZN4absl12lts_2026052614flags_internal16FlagOneWordValue13UninitializedEv:
  342|      4|  constexpr static int64_t Uninitialized() {
  343|      4|    return static_cast<int64_t>(0xababababababababll);
  344|      4|  }
_ZNK4absl12lts_2026052614flags_internal8FlagImpl4ReadImTnNSt3__19enable_ifIXeqclsr14flags_internalE11StorageKindIT_EELNS1_20FlagValueStorageKindE1EEiE4typeELi0EEEvPS6_:
  614|      4|  void Read(T* value) const ABSL_LOCKS_EXCLUDED(DataGuard()) {
  615|      4|    int64_t v = ReadOneWord();
  616|      4|    std::memcpy(value, static_cast<const void*>(&v), sizeof(T));
  617|      4|  }
_ZZNK4absl12lts_2026052614flags_internal4FlagImE3GetEvEN1UD2Ev:
  825|      4|      ~U() { value.~T(); }
_ZN4absl12lts_2026052614flags_internal7FlagOpsIbEEPvNS1_6FlagOpEPKvS3_S3_:
  876|     38|void* FlagOps(FlagOp op, const void* v1, void* v2, void* v3) {
  877|     38|  struct AlignedSpace {
  878|     38|    alignas(MaskedPointer::RequiredAlignment()) alignas(
  879|     38|        T) unsigned char buf[sizeof(T)];
  880|     38|  };
  881|     38|  using Allocator = std::allocator<AlignedSpace>;
  882|     38|  switch (op) {
  ------------------
  |  Branch (882:11): [True: 38, False: 0]
  ------------------
  883|      0|    case FlagOp::kAlloc: {
  ------------------
  |  Branch (883:5): [True: 0, False: 38]
  ------------------
  884|      0|      Allocator alloc;
  885|      0|      return std::allocator_traits<Allocator>::allocate(alloc, 1);
  886|      0|    }
  887|      0|    case FlagOp::kDelete: {
  ------------------
  |  Branch (887:5): [True: 0, False: 38]
  ------------------
  888|      0|      T* p = static_cast<T*>(v2);
  889|      0|      p->~T();
  890|      0|      Allocator alloc;
  891|      0|      std::allocator_traits<Allocator>::deallocate(
  892|      0|          alloc, reinterpret_cast<AlignedSpace*>(p), 1);
  893|      0|      return nullptr;
  894|      0|    }
  895|      0|    case FlagOp::kCopy:
  ------------------
  |  Branch (895:5): [True: 0, False: 38]
  ------------------
  896|      0|      *static_cast<T*>(v2) = *static_cast<const T*>(v1);
  897|      0|      return nullptr;
  898|      0|    case FlagOp::kCopyConstruct:
  ------------------
  |  Branch (898:5): [True: 0, False: 38]
  ------------------
  899|      0|      new (v2) T(*static_cast<const T*>(v1));
  900|      0|      return nullptr;
  901|     20|    case FlagOp::kSizeof:
  ------------------
  |  Branch (901:5): [True: 20, False: 18]
  ------------------
  902|     20|      return reinterpret_cast<void*>(static_cast<uintptr_t>(sizeof(T)));
  903|      0|    case FlagOp::kFastTypeId:
  ------------------
  |  Branch (903:5): [True: 0, False: 38]
  ------------------
  904|      0|      return absl::bit_cast<void*>(absl::FastTypeId<T>());
  905|      0|    case FlagOp::kRuntimeTypeId:
  ------------------
  |  Branch (905:5): [True: 0, False: 38]
  ------------------
  906|      0|      return const_cast<std::type_info*>(GenRuntimeTypeId<T>());
  907|      0|    case FlagOp::kParse: {
  ------------------
  |  Branch (907:5): [True: 0, False: 38]
  ------------------
  908|       |      // Initialize the temporary instance of type T based on current value in
  909|       |      // destination (which is going to be flag's default value).
  910|      0|      T temp(*static_cast<T*>(v2));
  911|      0|      if (!absl::ParseFlag<T>(*static_cast<const absl::string_view*>(v1), &temp,
  ------------------
  |  Branch (911:11): [True: 0, False: 0]
  ------------------
  912|      0|                              static_cast<std::string*>(v3))) {
  913|      0|        return nullptr;
  914|      0|      }
  915|      0|      *static_cast<T*>(v2) = std::move(temp);
  916|      0|      return v2;
  917|      0|    }
  918|      0|    case FlagOp::kUnparse:
  ------------------
  |  Branch (918:5): [True: 0, False: 38]
  ------------------
  919|      0|      *static_cast<std::string*>(v2) =
  920|      0|          absl::UnparseFlag<T>(*static_cast<const T*>(v1));
  921|      0|      return nullptr;
  922|     18|    case FlagOp::kValueOffset: {
  ------------------
  |  Branch (922:5): [True: 18, False: 20]
  ------------------
  923|       |      // Round sizeof(FlagImp) to a multiple of alignof(FlagValue<T>) to get the
  924|       |      // offset of the data.
  925|     18|      size_t round_to = alignof(FlagValue<T>);
  926|     18|      size_t offset = (sizeof(FlagImpl) + round_to - 1) / round_to * round_to;
  927|     18|      return reinterpret_cast<void*>(offset);
  928|      0|    }
  929|     38|  }
  930|      0|  return nullptr;
  931|     38|}
_ZNO4absl12lts_2026052614flags_internal13FlagRegistrarIbLb1EE8OnUpdateEPFvvE:
  947|      2|  FlagRegistrar OnUpdate(FlagCallbackFunc cb) && {
  948|      2|    flag_.impl_.SetCallback(cb);
  949|      2|    return *this;
  950|      2|  }
_ZN4absl12lts_2026052614flags_internal12FlagImplPeer9InvokeGetIbNS1_4FlagIbEEEET_RKT0_:
  860|     12|  static T InvokeGet(const FlagType& flag) {
  861|     12|    return flag.Get();
  862|     12|  }
_ZNK4absl12lts_2026052614flags_internal4FlagIbE3GetEv:
  820|     12|  T Get() const {
  821|       |    // See implementation notes in CommandLineFlag::Get().
  822|     12|    union U {
  823|     12|      T value;
  824|     12|      U() {}
  825|     12|      ~U() { value.~T(); }
  826|     12|    };
  827|     12|    U u;
  828|       |
  829|       |#if !defined(NDEBUG)
  830|       |    impl_.AssertValidType(absl::FastTypeId<T>(), &GenRuntimeTypeId<T>);
  831|       |#endif
  832|       |
  833|     12|    if (ABSL_PREDICT_FALSE(!value_.Get(impl_.seq_lock_, u.value))) {
  ------------------
  |  |  190|     12|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 8, False: 4]
  |  |  |  Branch (190:49): [Folded, False: 12]
  |  |  |  Branch (190:58): [True: 8, False: 4]
  |  |  ------------------
  ------------------
  834|      8|      impl_.Read(&u.value);
  835|      8|    }
  836|     12|    return std::move(u.value);
  837|     12|  }
_ZZNK4absl12lts_2026052614flags_internal4FlagIbE3GetEvEN1UC2Ev:
  824|     12|      U() {}
_ZNK4absl12lts_2026052614flags_internal9FlagValueIbLNS1_20FlagValueStorageKindE0EE3GetERKNS1_12SequenceLockERb:
  442|     12|  bool Get(const SequenceLock&, T& dst) const {
  443|     12|    int64_t storage = value.load(std::memory_order_acquire);
  444|     12|    if (ABSL_PREDICT_FALSE(storage == 0)) {
  ------------------
  |  |  190|     12|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 8, False: 4]
  |  |  |  Branch (190:49): [Folded, False: 12]
  |  |  |  Branch (190:58): [True: 8, False: 4]
  |  |  ------------------
  ------------------
  445|       |      // This assert is to ensure that the initialization inside FlagImpl::Init
  446|       |      // is able to set init member correctly.
  447|      8|      static_assert(offsetof(FlagValueAndInitBit<T>, init) == sizeof(T),
  448|      8|                    "Unexpected memory layout of FlagValueAndInitBit");
  449|      8|      return false;
  450|      8|    }
  451|      4|    dst = absl::bit_cast<FlagValueAndInitBit<T>>(storage).value;
  452|      4|    return true;
  453|     12|  }
_ZNK4absl12lts_2026052614flags_internal8FlagImpl4ReadEPb:
  607|      8|  void Read(bool* value) const ABSL_LOCKS_EXCLUDED(DataGuard()) {
  608|      8|    *value = ReadOneBool();
  609|      8|  }
_ZZNK4absl12lts_2026052614flags_internal4FlagIbE3GetEvEN1UD2Ev:
  825|     12|      ~U() { value.~T(); }
_ZN4absl12lts_2026052614flags_internal7FlagOpsINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEPvNS1_6FlagOpEPKvSA_SA_:
  876|     44|void* FlagOps(FlagOp op, const void* v1, void* v2, void* v3) {
  877|     44|  struct AlignedSpace {
  878|     44|    alignas(MaskedPointer::RequiredAlignment()) alignas(
  879|     44|        T) unsigned char buf[sizeof(T)];
  880|     44|  };
  881|     44|  using Allocator = std::allocator<AlignedSpace>;
  882|     44|  switch (op) {
  ------------------
  |  Branch (882:11): [True: 44, False: 0]
  ------------------
  883|      2|    case FlagOp::kAlloc: {
  ------------------
  |  Branch (883:5): [True: 2, False: 42]
  ------------------
  884|      2|      Allocator alloc;
  885|      2|      return std::allocator_traits<Allocator>::allocate(alloc, 1);
  886|      0|    }
  887|      2|    case FlagOp::kDelete: {
  ------------------
  |  Branch (887:5): [True: 2, False: 42]
  ------------------
  888|      2|      T* p = static_cast<T*>(v2);
  889|      2|      p->~T();
  890|      2|      Allocator alloc;
  891|      2|      std::allocator_traits<Allocator>::deallocate(
  892|      2|          alloc, reinterpret_cast<AlignedSpace*>(p), 1);
  893|      2|      return nullptr;
  894|      0|    }
  895|      2|    case FlagOp::kCopy:
  ------------------
  |  Branch (895:5): [True: 2, False: 42]
  ------------------
  896|      2|      *static_cast<T*>(v2) = *static_cast<const T*>(v1);
  897|      2|      return nullptr;
  898|      6|    case FlagOp::kCopyConstruct:
  ------------------
  |  Branch (898:5): [True: 6, False: 38]
  ------------------
  899|      6|      new (v2) T(*static_cast<const T*>(v1));
  900|      6|      return nullptr;
  901|      0|    case FlagOp::kSizeof:
  ------------------
  |  Branch (901:5): [True: 0, False: 44]
  ------------------
  902|      0|      return reinterpret_cast<void*>(static_cast<uintptr_t>(sizeof(T)));
  903|      2|    case FlagOp::kFastTypeId:
  ------------------
  |  Branch (903:5): [True: 2, False: 42]
  ------------------
  904|      2|      return absl::bit_cast<void*>(absl::FastTypeId<T>());
  905|      0|    case FlagOp::kRuntimeTypeId:
  ------------------
  |  Branch (905:5): [True: 0, False: 44]
  ------------------
  906|      0|      return const_cast<std::type_info*>(GenRuntimeTypeId<T>());
  907|      2|    case FlagOp::kParse: {
  ------------------
  |  Branch (907:5): [True: 2, False: 42]
  ------------------
  908|       |      // Initialize the temporary instance of type T based on current value in
  909|       |      // destination (which is going to be flag's default value).
  910|      2|      T temp(*static_cast<T*>(v2));
  911|      2|      if (!absl::ParseFlag<T>(*static_cast<const absl::string_view*>(v1), &temp,
  ------------------
  |  Branch (911:11): [True: 0, False: 2]
  ------------------
  912|      2|                              static_cast<std::string*>(v3))) {
  913|      0|        return nullptr;
  914|      0|      }
  915|      2|      *static_cast<T*>(v2) = std::move(temp);
  916|      2|      return v2;
  917|      2|    }
  918|      0|    case FlagOp::kUnparse:
  ------------------
  |  Branch (918:5): [True: 0, False: 44]
  ------------------
  919|      0|      *static_cast<std::string*>(v2) =
  920|      0|          absl::UnparseFlag<T>(*static_cast<const T*>(v1));
  921|      0|      return nullptr;
  922|     28|    case FlagOp::kValueOffset: {
  ------------------
  |  Branch (922:5): [True: 28, False: 16]
  ------------------
  923|       |      // Round sizeof(FlagImp) to a multiple of alignof(FlagValue<T>) to get the
  924|       |      // offset of the data.
  925|     28|      size_t round_to = alignof(FlagValue<T>);
  926|     28|      size_t offset = (sizeof(FlagImpl) + round_to - 1) / round_to * round_to;
  927|     28|      return reinterpret_cast<void*>(offset);
  928|      2|    }
  929|     44|  }
  930|      0|  return nullptr;
  931|     44|}
_ZN4absl12lts_2026052614flags_internal7FlagOpsINS0_8DurationEEEPvNS1_6FlagOpEPKvS4_S4_:
  876|     26|void* FlagOps(FlagOp op, const void* v1, void* v2, void* v3) {
  877|     26|  struct AlignedSpace {
  878|     26|    alignas(MaskedPointer::RequiredAlignment()) alignas(
  879|     26|        T) unsigned char buf[sizeof(T)];
  880|     26|  };
  881|     26|  using Allocator = std::allocator<AlignedSpace>;
  882|     26|  switch (op) {
  ------------------
  |  Branch (882:11): [True: 26, False: 0]
  ------------------
  883|      0|    case FlagOp::kAlloc: {
  ------------------
  |  Branch (883:5): [True: 0, False: 26]
  ------------------
  884|      0|      Allocator alloc;
  885|      0|      return std::allocator_traits<Allocator>::allocate(alloc, 1);
  886|      0|    }
  887|      0|    case FlagOp::kDelete: {
  ------------------
  |  Branch (887:5): [True: 0, False: 26]
  ------------------
  888|      0|      T* p = static_cast<T*>(v2);
  889|      0|      p->~T();
  890|      0|      Allocator alloc;
  891|      0|      std::allocator_traits<Allocator>::deallocate(
  892|      0|          alloc, reinterpret_cast<AlignedSpace*>(p), 1);
  893|      0|      return nullptr;
  894|      0|    }
  895|      0|    case FlagOp::kCopy:
  ------------------
  |  Branch (895:5): [True: 0, False: 26]
  ------------------
  896|      0|      *static_cast<T*>(v2) = *static_cast<const T*>(v1);
  897|      0|      return nullptr;
  898|      0|    case FlagOp::kCopyConstruct:
  ------------------
  |  Branch (898:5): [True: 0, False: 26]
  ------------------
  899|      0|      new (v2) T(*static_cast<const T*>(v1));
  900|      0|      return nullptr;
  901|      8|    case FlagOp::kSizeof:
  ------------------
  |  Branch (901:5): [True: 8, False: 18]
  ------------------
  902|      8|      return reinterpret_cast<void*>(static_cast<uintptr_t>(sizeof(T)));
  903|      0|    case FlagOp::kFastTypeId:
  ------------------
  |  Branch (903:5): [True: 0, False: 26]
  ------------------
  904|      0|      return absl::bit_cast<void*>(absl::FastTypeId<T>());
  905|      0|    case FlagOp::kRuntimeTypeId:
  ------------------
  |  Branch (905:5): [True: 0, False: 26]
  ------------------
  906|      0|      return const_cast<std::type_info*>(GenRuntimeTypeId<T>());
  907|      0|    case FlagOp::kParse: {
  ------------------
  |  Branch (907:5): [True: 0, False: 26]
  ------------------
  908|       |      // Initialize the temporary instance of type T based on current value in
  909|       |      // destination (which is going to be flag's default value).
  910|      0|      T temp(*static_cast<T*>(v2));
  911|      0|      if (!absl::ParseFlag<T>(*static_cast<const absl::string_view*>(v1), &temp,
  ------------------
  |  Branch (911:11): [True: 0, False: 0]
  ------------------
  912|      0|                              static_cast<std::string*>(v3))) {
  913|      0|        return nullptr;
  914|      0|      }
  915|      0|      *static_cast<T*>(v2) = std::move(temp);
  916|      0|      return v2;
  917|      0|    }
  918|      0|    case FlagOp::kUnparse:
  ------------------
  |  Branch (918:5): [True: 0, False: 26]
  ------------------
  919|      0|      *static_cast<std::string*>(v2) =
  920|      0|          absl::UnparseFlag<T>(*static_cast<const T*>(v1));
  921|      0|      return nullptr;
  922|     18|    case FlagOp::kValueOffset: {
  ------------------
  |  Branch (922:5): [True: 18, False: 8]
  ------------------
  923|       |      // Round sizeof(FlagImp) to a multiple of alignof(FlagValue<T>) to get the
  924|       |      // offset of the data.
  925|     18|      size_t round_to = alignof(FlagValue<T>);
  926|     18|      size_t offset = (sizeof(FlagImpl) + round_to - 1) / round_to * round_to;
  927|     18|      return reinterpret_cast<void*>(offset);
  928|      0|    }
  929|     26|  }
  930|      0|  return nullptr;
  931|     26|}
_ZN4absl12lts_2026052614flags_internal7FlagOpsIN8fuzztest8internal14TimeBudgetTypeEEEPvNS1_6FlagOpEPKvS6_S6_:
  876|      6|void* FlagOps(FlagOp op, const void* v1, void* v2, void* v3) {
  877|      6|  struct AlignedSpace {
  878|      6|    alignas(MaskedPointer::RequiredAlignment()) alignas(
  879|      6|        T) unsigned char buf[sizeof(T)];
  880|      6|  };
  881|      6|  using Allocator = std::allocator<AlignedSpace>;
  882|      6|  switch (op) {
  ------------------
  |  Branch (882:11): [True: 6, False: 0]
  ------------------
  883|      0|    case FlagOp::kAlloc: {
  ------------------
  |  Branch (883:5): [True: 0, False: 6]
  ------------------
  884|      0|      Allocator alloc;
  885|      0|      return std::allocator_traits<Allocator>::allocate(alloc, 1);
  886|      0|    }
  887|      0|    case FlagOp::kDelete: {
  ------------------
  |  Branch (887:5): [True: 0, False: 6]
  ------------------
  888|      0|      T* p = static_cast<T*>(v2);
  889|      0|      p->~T();
  890|      0|      Allocator alloc;
  891|      0|      std::allocator_traits<Allocator>::deallocate(
  892|      0|          alloc, reinterpret_cast<AlignedSpace*>(p), 1);
  893|      0|      return nullptr;
  894|      0|    }
  895|      0|    case FlagOp::kCopy:
  ------------------
  |  Branch (895:5): [True: 0, False: 6]
  ------------------
  896|      0|      *static_cast<T*>(v2) = *static_cast<const T*>(v1);
  897|      0|      return nullptr;
  898|      0|    case FlagOp::kCopyConstruct:
  ------------------
  |  Branch (898:5): [True: 0, False: 6]
  ------------------
  899|      0|      new (v2) T(*static_cast<const T*>(v1));
  900|      0|      return nullptr;
  901|      2|    case FlagOp::kSizeof:
  ------------------
  |  Branch (901:5): [True: 2, False: 4]
  ------------------
  902|      2|      return reinterpret_cast<void*>(static_cast<uintptr_t>(sizeof(T)));
  903|      0|    case FlagOp::kFastTypeId:
  ------------------
  |  Branch (903:5): [True: 0, False: 6]
  ------------------
  904|      0|      return absl::bit_cast<void*>(absl::FastTypeId<T>());
  905|      0|    case FlagOp::kRuntimeTypeId:
  ------------------
  |  Branch (905:5): [True: 0, False: 6]
  ------------------
  906|      0|      return const_cast<std::type_info*>(GenRuntimeTypeId<T>());
  907|      0|    case FlagOp::kParse: {
  ------------------
  |  Branch (907:5): [True: 0, False: 6]
  ------------------
  908|       |      // Initialize the temporary instance of type T based on current value in
  909|       |      // destination (which is going to be flag's default value).
  910|      0|      T temp(*static_cast<T*>(v2));
  911|      0|      if (!absl::ParseFlag<T>(*static_cast<const absl::string_view*>(v1), &temp,
  ------------------
  |  Branch (911:11): [True: 0, False: 0]
  ------------------
  912|      0|                              static_cast<std::string*>(v3))) {
  913|      0|        return nullptr;
  914|      0|      }
  915|      0|      *static_cast<T*>(v2) = std::move(temp);
  916|      0|      return v2;
  917|      0|    }
  918|      0|    case FlagOp::kUnparse:
  ------------------
  |  Branch (918:5): [True: 0, False: 6]
  ------------------
  919|      0|      *static_cast<std::string*>(v2) =
  920|      0|          absl::UnparseFlag<T>(*static_cast<const T*>(v1));
  921|      0|      return nullptr;
  922|      4|    case FlagOp::kValueOffset: {
  ------------------
  |  Branch (922:5): [True: 4, False: 2]
  ------------------
  923|       |      // Round sizeof(FlagImp) to a multiple of alignof(FlagValue<T>) to get the
  924|       |      // offset of the data.
  925|      4|      size_t round_to = alignof(FlagValue<T>);
  926|      4|      size_t offset = (sizeof(FlagImpl) + round_to - 1) / round_to * round_to;
  927|      4|      return reinterpret_cast<void*>(offset);
  928|      0|    }
  929|      6|  }
  930|      0|  return nullptr;
  931|      6|}
_ZN4absl12lts_2026052614flags_internal7FlagOpsINSt3__18optionalINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEPvNS1_6FlagOpEPKvSC_SC_:
  876|     40|void* FlagOps(FlagOp op, const void* v1, void* v2, void* v3) {
  877|     40|  struct AlignedSpace {
  878|     40|    alignas(MaskedPointer::RequiredAlignment()) alignas(
  879|     40|        T) unsigned char buf[sizeof(T)];
  880|     40|  };
  881|     40|  using Allocator = std::allocator<AlignedSpace>;
  882|     40|  switch (op) {
  ------------------
  |  Branch (882:11): [True: 40, False: 0]
  ------------------
  883|      0|    case FlagOp::kAlloc: {
  ------------------
  |  Branch (883:5): [True: 0, False: 40]
  ------------------
  884|      0|      Allocator alloc;
  885|      0|      return std::allocator_traits<Allocator>::allocate(alloc, 1);
  886|      0|    }
  887|      0|    case FlagOp::kDelete: {
  ------------------
  |  Branch (887:5): [True: 0, False: 40]
  ------------------
  888|      0|      T* p = static_cast<T*>(v2);
  889|      0|      p->~T();
  890|      0|      Allocator alloc;
  891|      0|      std::allocator_traits<Allocator>::deallocate(
  892|      0|          alloc, reinterpret_cast<AlignedSpace*>(p), 1);
  893|      0|      return nullptr;
  894|      0|    }
  895|      0|    case FlagOp::kCopy:
  ------------------
  |  Branch (895:5): [True: 0, False: 40]
  ------------------
  896|      0|      *static_cast<T*>(v2) = *static_cast<const T*>(v1);
  897|      0|      return nullptr;
  898|      8|    case FlagOp::kCopyConstruct:
  ------------------
  |  Branch (898:5): [True: 8, False: 32]
  ------------------
  899|      8|      new (v2) T(*static_cast<const T*>(v1));
  900|      8|      return nullptr;
  901|      0|    case FlagOp::kSizeof:
  ------------------
  |  Branch (901:5): [True: 0, False: 40]
  ------------------
  902|      0|      return reinterpret_cast<void*>(static_cast<uintptr_t>(sizeof(T)));
  903|      0|    case FlagOp::kFastTypeId:
  ------------------
  |  Branch (903:5): [True: 0, False: 40]
  ------------------
  904|      0|      return absl::bit_cast<void*>(absl::FastTypeId<T>());
  905|      0|    case FlagOp::kRuntimeTypeId:
  ------------------
  |  Branch (905:5): [True: 0, False: 40]
  ------------------
  906|      0|      return const_cast<std::type_info*>(GenRuntimeTypeId<T>());
  907|      0|    case FlagOp::kParse: {
  ------------------
  |  Branch (907:5): [True: 0, False: 40]
  ------------------
  908|       |      // Initialize the temporary instance of type T based on current value in
  909|       |      // destination (which is going to be flag's default value).
  910|      0|      T temp(*static_cast<T*>(v2));
  911|      0|      if (!absl::ParseFlag<T>(*static_cast<const absl::string_view*>(v1), &temp,
  ------------------
  |  Branch (911:11): [True: 0, False: 0]
  ------------------
  912|      0|                              static_cast<std::string*>(v3))) {
  913|      0|        return nullptr;
  914|      0|      }
  915|      0|      *static_cast<T*>(v2) = std::move(temp);
  916|      0|      return v2;
  917|      0|    }
  918|      0|    case FlagOp::kUnparse:
  ------------------
  |  Branch (918:5): [True: 0, False: 40]
  ------------------
  919|      0|      *static_cast<std::string*>(v2) =
  920|      0|          absl::UnparseFlag<T>(*static_cast<const T*>(v1));
  921|      0|      return nullptr;
  922|     32|    case FlagOp::kValueOffset: {
  ------------------
  |  Branch (922:5): [True: 32, False: 8]
  ------------------
  923|       |      // Round sizeof(FlagImp) to a multiple of alignof(FlagValue<T>) to get the
  924|       |      // offset of the data.
  925|     32|      size_t round_to = alignof(FlagValue<T>);
  926|     32|      size_t offset = (sizeof(FlagImpl) + round_to - 1) / round_to * round_to;
  927|     32|      return reinterpret_cast<void*>(offset);
  928|      0|    }
  929|     40|  }
  930|      0|  return nullptr;
  931|     40|}
_ZN4absl12lts_2026052614flags_internal7FlagOpsImEEPvNS1_6FlagOpEPKvS3_S3_:
  876|     12|void* FlagOps(FlagOp op, const void* v1, void* v2, void* v3) {
  877|     12|  struct AlignedSpace {
  878|     12|    alignas(MaskedPointer::RequiredAlignment()) alignas(
  879|     12|        T) unsigned char buf[sizeof(T)];
  880|     12|  };
  881|     12|  using Allocator = std::allocator<AlignedSpace>;
  882|     12|  switch (op) {
  ------------------
  |  Branch (882:11): [True: 12, False: 0]
  ------------------
  883|      0|    case FlagOp::kAlloc: {
  ------------------
  |  Branch (883:5): [True: 0, False: 12]
  ------------------
  884|      0|      Allocator alloc;
  885|      0|      return std::allocator_traits<Allocator>::allocate(alloc, 1);
  886|      0|    }
  887|      0|    case FlagOp::kDelete: {
  ------------------
  |  Branch (887:5): [True: 0, False: 12]
  ------------------
  888|      0|      T* p = static_cast<T*>(v2);
  889|      0|      p->~T();
  890|      0|      Allocator alloc;
  891|      0|      std::allocator_traits<Allocator>::deallocate(
  892|      0|          alloc, reinterpret_cast<AlignedSpace*>(p), 1);
  893|      0|      return nullptr;
  894|      0|    }
  895|      0|    case FlagOp::kCopy:
  ------------------
  |  Branch (895:5): [True: 0, False: 12]
  ------------------
  896|      0|      *static_cast<T*>(v2) = *static_cast<const T*>(v1);
  897|      0|      return nullptr;
  898|      0|    case FlagOp::kCopyConstruct:
  ------------------
  |  Branch (898:5): [True: 0, False: 12]
  ------------------
  899|      0|      new (v2) T(*static_cast<const T*>(v1));
  900|      0|      return nullptr;
  901|      4|    case FlagOp::kSizeof:
  ------------------
  |  Branch (901:5): [True: 4, False: 8]
  ------------------
  902|      4|      return reinterpret_cast<void*>(static_cast<uintptr_t>(sizeof(T)));
  903|      0|    case FlagOp::kFastTypeId:
  ------------------
  |  Branch (903:5): [True: 0, False: 12]
  ------------------
  904|      0|      return absl::bit_cast<void*>(absl::FastTypeId<T>());
  905|      0|    case FlagOp::kRuntimeTypeId:
  ------------------
  |  Branch (905:5): [True: 0, False: 12]
  ------------------
  906|      0|      return const_cast<std::type_info*>(GenRuntimeTypeId<T>());
  907|      0|    case FlagOp::kParse: {
  ------------------
  |  Branch (907:5): [True: 0, False: 12]
  ------------------
  908|       |      // Initialize the temporary instance of type T based on current value in
  909|       |      // destination (which is going to be flag's default value).
  910|      0|      T temp(*static_cast<T*>(v2));
  911|      0|      if (!absl::ParseFlag<T>(*static_cast<const absl::string_view*>(v1), &temp,
  ------------------
  |  Branch (911:11): [True: 0, False: 0]
  ------------------
  912|      0|                              static_cast<std::string*>(v3))) {
  913|      0|        return nullptr;
  914|      0|      }
  915|      0|      *static_cast<T*>(v2) = std::move(temp);
  916|      0|      return v2;
  917|      0|    }
  918|      0|    case FlagOp::kUnparse:
  ------------------
  |  Branch (918:5): [True: 0, False: 12]
  ------------------
  919|      0|      *static_cast<std::string*>(v2) =
  920|      0|          absl::UnparseFlag<T>(*static_cast<const T*>(v1));
  921|      0|      return nullptr;
  922|      8|    case FlagOp::kValueOffset: {
  ------------------
  |  Branch (922:5): [True: 8, False: 4]
  ------------------
  923|       |      // Round sizeof(FlagImp) to a multiple of alignof(FlagValue<T>) to get the
  924|       |      // offset of the data.
  925|      8|      size_t round_to = alignof(FlagValue<T>);
  926|      8|      size_t offset = (sizeof(FlagImpl) + round_to - 1) / round_to * round_to;
  927|      8|      return reinterpret_cast<void*>(offset);
  928|      0|    }
  929|     12|  }
  930|      0|  return nullptr;
  931|     12|}
_ZN4absl12lts_2026052614flags_internal7FlagOpsINSt3__18optionalImEEEEPvNS1_6FlagOpEPKvS6_S6_:
  876|      6|void* FlagOps(FlagOp op, const void* v1, void* v2, void* v3) {
  877|      6|  struct AlignedSpace {
  878|      6|    alignas(MaskedPointer::RequiredAlignment()) alignas(
  879|      6|        T) unsigned char buf[sizeof(T)];
  880|      6|  };
  881|      6|  using Allocator = std::allocator<AlignedSpace>;
  882|      6|  switch (op) {
  ------------------
  |  Branch (882:11): [True: 6, False: 0]
  ------------------
  883|      0|    case FlagOp::kAlloc: {
  ------------------
  |  Branch (883:5): [True: 0, False: 6]
  ------------------
  884|      0|      Allocator alloc;
  885|      0|      return std::allocator_traits<Allocator>::allocate(alloc, 1);
  886|      0|    }
  887|      0|    case FlagOp::kDelete: {
  ------------------
  |  Branch (887:5): [True: 0, False: 6]
  ------------------
  888|      0|      T* p = static_cast<T*>(v2);
  889|      0|      p->~T();
  890|      0|      Allocator alloc;
  891|      0|      std::allocator_traits<Allocator>::deallocate(
  892|      0|          alloc, reinterpret_cast<AlignedSpace*>(p), 1);
  893|      0|      return nullptr;
  894|      0|    }
  895|      0|    case FlagOp::kCopy:
  ------------------
  |  Branch (895:5): [True: 0, False: 6]
  ------------------
  896|      0|      *static_cast<T*>(v2) = *static_cast<const T*>(v1);
  897|      0|      return nullptr;
  898|      0|    case FlagOp::kCopyConstruct:
  ------------------
  |  Branch (898:5): [True: 0, False: 6]
  ------------------
  899|      0|      new (v2) T(*static_cast<const T*>(v1));
  900|      0|      return nullptr;
  901|      2|    case FlagOp::kSizeof:
  ------------------
  |  Branch (901:5): [True: 2, False: 4]
  ------------------
  902|      2|      return reinterpret_cast<void*>(static_cast<uintptr_t>(sizeof(T)));
  903|      0|    case FlagOp::kFastTypeId:
  ------------------
  |  Branch (903:5): [True: 0, False: 6]
  ------------------
  904|      0|      return absl::bit_cast<void*>(absl::FastTypeId<T>());
  905|      0|    case FlagOp::kRuntimeTypeId:
  ------------------
  |  Branch (905:5): [True: 0, False: 6]
  ------------------
  906|      0|      return const_cast<std::type_info*>(GenRuntimeTypeId<T>());
  907|      0|    case FlagOp::kParse: {
  ------------------
  |  Branch (907:5): [True: 0, False: 6]
  ------------------
  908|       |      // Initialize the temporary instance of type T based on current value in
  909|       |      // destination (which is going to be flag's default value).
  910|      0|      T temp(*static_cast<T*>(v2));
  911|      0|      if (!absl::ParseFlag<T>(*static_cast<const absl::string_view*>(v1), &temp,
  ------------------
  |  Branch (911:11): [True: 0, False: 0]
  ------------------
  912|      0|                              static_cast<std::string*>(v3))) {
  913|      0|        return nullptr;
  914|      0|      }
  915|      0|      *static_cast<T*>(v2) = std::move(temp);
  916|      0|      return v2;
  917|      0|    }
  918|      0|    case FlagOp::kUnparse:
  ------------------
  |  Branch (918:5): [True: 0, False: 6]
  ------------------
  919|      0|      *static_cast<std::string*>(v2) =
  920|      0|          absl::UnparseFlag<T>(*static_cast<const T*>(v1));
  921|      0|      return nullptr;
  922|      4|    case FlagOp::kValueOffset: {
  ------------------
  |  Branch (922:5): [True: 4, False: 2]
  ------------------
  923|       |      // Round sizeof(FlagImp) to a multiple of alignof(FlagValue<T>) to get the
  924|       |      // offset of the data.
  925|      4|      size_t round_to = alignof(FlagValue<T>);
  926|      4|      size_t offset = (sizeof(FlagImpl) + round_to - 1) / round_to * round_to;
  927|      4|      return reinterpret_cast<void*>(offset);
  928|      0|    }
  929|      6|  }
  930|      0|  return nullptr;
  931|      6|}
_ZNO4absl12lts_2026052614flags_internal13FlagRegistrarINSt3__18optionalINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEELb1EE8OnUpdateEPFvvE:
  947|      4|  FlagRegistrar OnUpdate(FlagCallbackFunc cb) && {
  948|      4|    flag_.impl_.SetCallback(cb);
  949|      4|    return *this;
  950|      4|  }
_ZNO4absl12lts_2026052614flags_internal13FlagRegistrarINS0_8DurationELb1EE8OnUpdateEPFvvE:
  947|      2|  FlagRegistrar OnUpdate(FlagCallbackFunc cb) && {
  948|      2|    flag_.impl_.SetCallback(cb);
  949|      2|    return *this;
  950|      2|  }
_ZN4absl12lts_2026052614flags_internal12FlagImplPeer9InvokeGetINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS1_4FlagISA_EEEET_RKT0_:
  860|     16|  static T InvokeGet(const FlagType& flag) {
  861|     16|    return flag.Get();
  862|     16|  }
_ZNK4absl12lts_2026052614flags_internal4FlagINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE3GetEv:
  820|     16|  T Get() const {
  821|       |    // See implementation notes in CommandLineFlag::Get().
  822|     16|    union U {
  823|     16|      T value;
  824|     16|      U() {}
  825|     16|      ~U() { value.~T(); }
  826|     16|    };
  827|     16|    U u;
  828|       |
  829|       |#if !defined(NDEBUG)
  830|       |    impl_.AssertValidType(absl::FastTypeId<T>(), &GenRuntimeTypeId<T>);
  831|       |#endif
  832|       |
  833|     16|    if (ABSL_PREDICT_FALSE(!value_.Get(impl_.seq_lock_, u.value))) {
  ------------------
  |  |  190|     16|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 6, False: 10]
  |  |  |  Branch (190:49): [Folded, False: 16]
  |  |  |  Branch (190:58): [True: 6, False: 10]
  |  |  ------------------
  ------------------
  834|      6|      impl_.Read(&u.value);
  835|      6|    }
  836|     16|    return std::move(u.value);
  837|     16|  }
_ZZNK4absl12lts_2026052614flags_internal4FlagINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE3GetEvEN1UC2Ev:
  824|     16|      U() {}
_ZNK4absl12lts_2026052614flags_internal9FlagValueINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEELNS1_20FlagValueStorageKindE3EE3GetERKNS1_12SequenceLockERS9_:
  536|     16|  bool Get(const SequenceLock&, T& dst) const {
  537|     16|    MaskedPointer ptr_value = value.load(std::memory_order_acquire);
  538|       |
  539|     16|    if (ABSL_PREDICT_TRUE(ptr_value.AllowsUnprotectedRead())) {
  ------------------
  |  |  191|     16|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 10, False: 6]
  |  |  |  Branch (191:48): [Folded, False: 16]
  |  |  |  Branch (191:57): [True: 10, False: 6]
  |  |  ------------------
  ------------------
  540|     10|      ::new (static_cast<void*>(&dst)) T(*static_cast<T*>(ptr_value.Ptr()));
  541|     10|      return true;
  542|     10|    }
  543|      6|    return false;
  544|     16|  }
_ZZNK4absl12lts_2026052614flags_internal4FlagINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE3GetEvEN1UD2Ev:
  825|     16|      ~U() { value.~T(); }
_ZNK4absl12lts_2026052614flags_internal8FlagImpl16ValueStorageKindEv:
  692|     96|  FlagValueStorageKind ValueStorageKind() const {
  693|     96|    return static_cast<FlagValueStorageKind>(value_storage_kind_);
  694|     96|  }
_ZNK4absl12lts_2026052614flags_internal8FlagImpl11DefaultKindEv:
  696|      2|      ABSL_EXCLUSIVE_LOCKS_REQUIRED(DataGuard()) {
  697|      2|    return static_cast<FlagDefaultKind>(def_kind_);
  698|      2|  }
_ZN4absl12lts_2026052614flags_internal5AllocEPFPvNS1_6FlagOpEPKvS2_S2_E:
   96|      2|inline void* Alloc(FlagOpFn op) {
   97|      2|  return op(FlagOp::kAlloc, nullptr, nullptr, nullptr);
   98|      2|}
_ZN4absl12lts_2026052614flags_internal6DeleteEPFPvNS1_6FlagOpEPKvS2_S2_ES2_:
  100|      2|inline void Delete(FlagOpFn op, void* obj) {
  101|      2|  op(FlagOp::kDelete, nullptr, obj, nullptr);
  102|      2|}
_ZN4absl12lts_2026052614flags_internal4CopyEPFPvNS1_6FlagOpEPKvS2_S2_ES5_S2_:
  104|      2|inline void Copy(FlagOpFn op, const void* src, void* dst) {
  105|      2|  op(FlagOp::kCopy, src, dst, nullptr);
  106|      2|}
_ZN4absl12lts_2026052614flags_internal13CopyConstructEPFPvNS1_6FlagOpEPKvS2_S2_ES5_S2_:
  109|     20|inline void CopyConstruct(FlagOpFn op, const void* src, void* dst) {
  110|     20|  op(FlagOp::kCopyConstruct, src, dst, nullptr);
  111|     20|}
_ZN4absl12lts_2026052614flags_internal5ParseEPFPvNS1_6FlagOpEPKvS2_S2_ENSt3__117basic_string_viewIcNS8_11char_traitsIcEEEES2_PNS8_12basic_stringIcSB_NS8_9allocatorIcEEEE:
  120|      2|                  std::string* error) {
  121|      2|  return op(FlagOp::kParse, &text, dst, error) != nullptr;
  122|      2|}
_ZN4absl12lts_2026052614flags_internal6SizeofEPFPvNS1_6FlagOpEPKvS2_S2_E:
  130|     36|inline size_t Sizeof(FlagOpFn op) {
  131|       |  // This sequence of casts reverses the sequence from
  132|       |  // `flags_internal::FlagOps()`
  133|     36|  return static_cast<size_t>(reinterpret_cast<intptr_t>(
  134|     36|      op(FlagOp::kSizeof, nullptr, nullptr, nullptr)));
  135|     36|}
_ZN4absl12lts_2026052614flags_internal10FastTypeIdEPFPvNS1_6FlagOpEPKvS2_S2_E:
  137|      2|inline FlagFastTypeId FastTypeId(FlagOpFn op) {
  138|      2|  return absl::bit_cast<FlagFastTypeId>(
  139|      2|      op(FlagOp::kFastTypeId, nullptr, nullptr, nullptr));
  140|      2|}
_ZN4absl12lts_2026052614flags_internal11ValueOffsetEPFPvNS1_6FlagOpEPKvS2_S2_E:
  150|    136|inline ptrdiff_t ValueOffset(FlagOpFn op) {
  151|       |  // This sequence of casts reverses the sequence from
  152|       |  // `flags_internal::FlagOps()`
  153|    136|  return static_cast<ptrdiff_t>(reinterpret_cast<intptr_t>(
  154|    136|      op(FlagOp::kValueOffset, nullptr, nullptr, nullptr)));
  155|    136|}
_ZN4absl12lts_2026052614flags_internal16InitDefaultValueINSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEEEET_NS1_11EmptyBracesE:
  281|      6|constexpr T InitDefaultValue(EmptyBraces) {
  282|      6|  return T{};
  283|      6|}
_ZN4absl12lts_2026052614flags_internal13FlagRegistrarINSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEELb1EEC2ERNS1_4FlagISC_EEPKc:
  942|      8|      : flag_(flag) {
  943|      8|    if (do_register)
  ------------------
  |  Branch (943:9): [True: 8, Folded]
  ------------------
  944|      8|      flags_internal::RegisterCommandLineFlag(flag_.impl_, filename);
  945|      8|  }
_ZNK4absl12lts_2026052614flags_internal13FlagRegistrarINSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEELb1EEcvNS1_18FlagRegistrarEmptyEEv:
  955|      8|  constexpr operator FlagRegistrarEmpty() const { return {}; }  // NOLINT
_ZN4absl12lts_2026052614flags_internal7FlagOpsINSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEEEEPvNS1_6FlagOpEPKvSD_SD_:
  876|     30|void* FlagOps(FlagOp op, const void* v1, void* v2, void* v3) {
  877|     30|  struct AlignedSpace {
  878|     30|    alignas(MaskedPointer::RequiredAlignment()) alignas(
  879|     30|        T) unsigned char buf[sizeof(T)];
  880|     30|  };
  881|     30|  using Allocator = std::allocator<AlignedSpace>;
  882|     30|  switch (op) {
  ------------------
  |  Branch (882:11): [True: 30, False: 0]
  ------------------
  883|      0|    case FlagOp::kAlloc: {
  ------------------
  |  Branch (883:5): [True: 0, False: 30]
  ------------------
  884|      0|      Allocator alloc;
  885|      0|      return std::allocator_traits<Allocator>::allocate(alloc, 1);
  886|      0|    }
  887|      0|    case FlagOp::kDelete: {
  ------------------
  |  Branch (887:5): [True: 0, False: 30]
  ------------------
  888|      0|      T* p = static_cast<T*>(v2);
  889|      0|      p->~T();
  890|      0|      Allocator alloc;
  891|      0|      std::allocator_traits<Allocator>::deallocate(
  892|      0|          alloc, reinterpret_cast<AlignedSpace*>(p), 1);
  893|      0|      return nullptr;
  894|      0|    }
  895|      0|    case FlagOp::kCopy:
  ------------------
  |  Branch (895:5): [True: 0, False: 30]
  ------------------
  896|      0|      *static_cast<T*>(v2) = *static_cast<const T*>(v1);
  897|      0|      return nullptr;
  898|      6|    case FlagOp::kCopyConstruct:
  ------------------
  |  Branch (898:5): [True: 6, False: 24]
  ------------------
  899|      6|      new (v2) T(*static_cast<const T*>(v1));
  900|      6|      return nullptr;
  901|      0|    case FlagOp::kSizeof:
  ------------------
  |  Branch (901:5): [True: 0, False: 30]
  ------------------
  902|      0|      return reinterpret_cast<void*>(static_cast<uintptr_t>(sizeof(T)));
  903|      0|    case FlagOp::kFastTypeId:
  ------------------
  |  Branch (903:5): [True: 0, False: 30]
  ------------------
  904|      0|      return absl::bit_cast<void*>(absl::FastTypeId<T>());
  905|      0|    case FlagOp::kRuntimeTypeId:
  ------------------
  |  Branch (905:5): [True: 0, False: 30]
  ------------------
  906|      0|      return const_cast<std::type_info*>(GenRuntimeTypeId<T>());
  907|      0|    case FlagOp::kParse: {
  ------------------
  |  Branch (907:5): [True: 0, False: 30]
  ------------------
  908|       |      // Initialize the temporary instance of type T based on current value in
  909|       |      // destination (which is going to be flag's default value).
  910|      0|      T temp(*static_cast<T*>(v2));
  911|      0|      if (!absl::ParseFlag<T>(*static_cast<const absl::string_view*>(v1), &temp,
  ------------------
  |  Branch (911:11): [True: 0, False: 0]
  ------------------
  912|      0|                              static_cast<std::string*>(v3))) {
  913|      0|        return nullptr;
  914|      0|      }
  915|      0|      *static_cast<T*>(v2) = std::move(temp);
  916|      0|      return v2;
  917|      0|    }
  918|      0|    case FlagOp::kUnparse:
  ------------------
  |  Branch (918:5): [True: 0, False: 30]
  ------------------
  919|      0|      *static_cast<std::string*>(v2) =
  920|      0|          absl::UnparseFlag<T>(*static_cast<const T*>(v1));
  921|      0|      return nullptr;
  922|     24|    case FlagOp::kValueOffset: {
  ------------------
  |  Branch (922:5): [True: 24, False: 6]
  ------------------
  923|       |      // Round sizeof(FlagImp) to a multiple of alignof(FlagValue<T>) to get the
  924|       |      // offset of the data.
  925|     24|      size_t round_to = alignof(FlagValue<T>);
  926|     24|      size_t offset = (sizeof(FlagImpl) + round_to - 1) / round_to * round_to;
  927|     24|      return reinterpret_cast<void*>(offset);
  928|      0|    }
  929|     30|  }
  930|      0|  return nullptr;
  931|     30|}
_ZNO4absl12lts_2026052614flags_internal13FlagRegistrarINSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEELb1EE8OnUpdateEPFvvE:
  947|      6|  FlagRegistrar OnUpdate(FlagCallbackFunc cb) && {
  948|      6|    flag_.impl_.SetCallback(cb);
  949|      6|    return *this;
  950|      6|  }
_ZN4absl12lts_2026052614flags_internal12FlagImplPeer9InvokeGetINSt3__16vectorINS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS9_ISB_EEEENS1_4FlagISD_EEEET_RKT0_:
  860|     10|  static T InvokeGet(const FlagType& flag) {
  861|     10|    return flag.Get();
  862|     10|  }
_ZNK4absl12lts_2026052614flags_internal4FlagINSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEEE3GetEv:
  820|     10|  T Get() const {
  821|       |    // See implementation notes in CommandLineFlag::Get().
  822|     10|    union U {
  823|     10|      T value;
  824|     10|      U() {}
  825|     10|      ~U() { value.~T(); }
  826|     10|    };
  827|     10|    U u;
  828|       |
  829|       |#if !defined(NDEBUG)
  830|       |    impl_.AssertValidType(absl::FastTypeId<T>(), &GenRuntimeTypeId<T>);
  831|       |#endif
  832|       |
  833|     10|    if (ABSL_PREDICT_FALSE(!value_.Get(impl_.seq_lock_, u.value))) {
  ------------------
  |  |  190|     10|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 6, False: 4]
  |  |  |  Branch (190:49): [Folded, False: 10]
  |  |  |  Branch (190:58): [True: 6, False: 4]
  |  |  ------------------
  ------------------
  834|      6|      impl_.Read(&u.value);
  835|      6|    }
  836|     10|    return std::move(u.value);
  837|     10|  }
_ZZNK4absl12lts_2026052614flags_internal4FlagINSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEEE3GetEvEN1UC2Ev:
  824|     10|      U() {}
_ZNK4absl12lts_2026052614flags_internal9FlagValueINSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEELNS1_20FlagValueStorageKindE3EE3GetERKNS1_12SequenceLockERSC_:
  536|     10|  bool Get(const SequenceLock&, T& dst) const {
  537|     10|    MaskedPointer ptr_value = value.load(std::memory_order_acquire);
  538|       |
  539|     10|    if (ABSL_PREDICT_TRUE(ptr_value.AllowsUnprotectedRead())) {
  ------------------
  |  |  191|     10|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 4, False: 6]
  |  |  |  Branch (191:48): [Folded, False: 10]
  |  |  |  Branch (191:57): [True: 4, False: 6]
  |  |  ------------------
  ------------------
  540|      4|      ::new (static_cast<void*>(&dst)) T(*static_cast<T*>(ptr_value.Ptr()));
  541|      4|      return true;
  542|      4|    }
  543|      6|    return false;
  544|     10|  }
_ZZNK4absl12lts_2026052614flags_internal4FlagINSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEEE3GetEvEN1UD2Ev:
  825|     10|      ~U() { value.~T(); }

_ZN4absl12lts_2026052614flags_internal21PrivateHandleAccessor9ParseFromERNS0_15CommandLineFlagENSt3__117basic_string_viewIcNS5_11char_traitsIcEEEENS1_15FlagSettingModeENS1_11ValueSourceERNS5_12basic_stringIcS8_NS5_9allocatorIcEEEE:
   58|      2|                                      std::string& error) {
   59|      2|  return flag.ParseFrom(value, set_mode, source, error);
   60|      2|}

_ZN4absl12lts_2026052614flags_internal21ProgramInvocationNameEv:
   39|      2|std::string ProgramInvocationName() {
   40|      2|  absl::MutexLock l(ProgramNameMutex());
   41|      2|  return program_name ? *program_name : "UNKNOWN";
  ------------------
  |  Branch (41:10): [True: 0, False: 2]
  ------------------
   42|      2|}
_ZN4absl12lts_2026052614flags_internal24SetProgramInvocationNameENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
   50|      2|void SetProgramInvocationName(absl::string_view prog_name_str) {
   51|      2|  absl::MutexLock l(ProgramNameMutex());
   52|      2|  if (!program_name) {
  ------------------
  |  Branch (52:7): [True: 2, False: 0]
  ------------------
   53|      2|    program_name = new std::string(prog_name_str);
   54|      2|  } else {
   55|      0|    program_name->assign(prog_name_str.data(), prog_name_str.size());
   56|      0|  }
   57|      2|}
program_name.cc:_ZN4absl12lts_2026052614flags_internalL16ProgramNameMutexEv:
   32|      4|static absl::Mutex& ProgramNameMutex() {
   33|      4|  static absl::NoDestructor<absl::Mutex> mutex;
   34|      4|  return *mutex;
   35|      4|}

_ZNK4absl12lts_2026052614flags_internal12SequenceLock7TryReadEPvPKNSt3__16atomicImEEm:
   80|     26|  bool TryRead(void* dst, const std::atomic<uint64_t>* src, size_t size) const {
   81|       |    // Acquire barrier ensures that no loads done by f() are reordered
   82|       |    // above the first load of the sequence counter.
   83|     26|    int64_t seq_before = lock_.load(std::memory_order_acquire);
   84|     26|    if (ABSL_PREDICT_FALSE(seq_before & 1) == 1) return false;
  ------------------
  |  |  190|     26|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:49): [Folded, False: 26]
  |  |  |  Branch (190:58): [True: 10, False: 16]
  |  |  ------------------
  ------------------
  |  Branch (84:9): [True: 10, False: 16]
  ------------------
   85|     16|    RelaxedCopyFromAtomic(dst, src, size);
   86|       |    // Another acquire fence ensures that the load of 'lock_' below is
   87|       |    // strictly ordered after the RelaxedCopyToAtomic call above.
   88|     16|    std::atomic_thread_fence(std::memory_order_acquire);
   89|     16|    int64_t seq_after = lock_.load(std::memory_order_relaxed);
   90|     16|    return ABSL_PREDICT_TRUE(seq_before == seq_after);
  ------------------
  |  |  191|     16|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:48): [Folded, False: 16]
  |  |  |  Branch (191:57): [True: 16, False: 0]
  |  |  ------------------
  ------------------
   91|     26|  }
_ZN4absl12lts_2026052614flags_internal12SequenceLock21RelaxedCopyFromAtomicEPvPKNSt3__16atomicImEEm:
  144|     16|                                    size_t size) {
  145|     16|    char* dst_byte = static_cast<char*>(dst);
  146|     34|    while (size >= sizeof(uint64_t)) {
  ------------------
  |  Branch (146:12): [True: 18, False: 16]
  ------------------
  147|     18|      uint64_t word = src->load(std::memory_order_relaxed);
  148|     18|      std::memcpy(dst_byte, &word, sizeof(word));
  149|     18|      dst_byte += sizeof(word);
  150|     18|      src++;
  151|     18|      size -= sizeof(word);
  152|     18|    }
  153|     16|    if (size > 0) {
  ------------------
  |  Branch (153:9): [True: 14, False: 2]
  ------------------
  154|     14|      uint64_t word = src->load(std::memory_order_relaxed);
  155|     14|      std::memcpy(dst_byte, &word, size);
  156|     14|    }
  157|     16|  }
_ZN4absl12lts_2026052614flags_internal12SequenceLock15MarkInitializedEv:
   63|     48|  void MarkInitialized() {
   64|       |    assert(lock_.load(std::memory_order_relaxed) == kUninitialized);
   65|     48|    lock_.store(0, std::memory_order_release);
   66|     48|  }
_ZN4absl12lts_2026052614flags_internal12SequenceLock26IncrementModificationCountEv:
  134|      2|  void IncrementModificationCount() {
  135|      2|    int64_t val = lock_.load(std::memory_order_relaxed);
  136|       |    assert(val != kUninitialized);
  137|      2|    lock_.store(val + 2, std::memory_order_relaxed);
  138|      2|  }

_ZN4absl12lts_2026052614flags_internal16HandleUsageFlagsERNSt3__113basic_ostreamIcNS2_11char_traitsIcEEEENS2_17basic_string_viewIcS5_EE:
  373|      2|                          absl::string_view program_usage_message) {
  374|      2|  switch (GetFlagsHelpMode()) {
  ------------------
  |  Branch (374:11): [True: 2, False: 0]
  ------------------
  375|      2|    case HelpMode::kNone:
  ------------------
  |  Branch (375:5): [True: 2, False: 0]
  ------------------
  376|      2|      break;
  377|      0|    case HelpMode::kImportant:
  ------------------
  |  Branch (377:5): [True: 0, False: 2]
  ------------------
  378|      0|      flags_internal::FlagsHelpImpl(
  379|      0|          out, flags_internal::GetUsageConfig().contains_help_flags,
  380|      0|          GetFlagsHelpFormat(), program_usage_message);
  381|      0|      break;
  382|       |
  383|      0|    case HelpMode::kShort:
  ------------------
  |  Branch (383:5): [True: 0, False: 2]
  ------------------
  384|      0|      flags_internal::FlagsHelpImpl(
  385|      0|          out, flags_internal::GetUsageConfig().contains_helpshort_flags,
  386|      0|          GetFlagsHelpFormat(), program_usage_message);
  387|      0|      break;
  388|       |
  389|      0|    case HelpMode::kFull:
  ------------------
  |  Branch (389:5): [True: 0, False: 2]
  ------------------
  390|      0|      flags_internal::FlagsHelp(out, "", GetFlagsHelpFormat(),
  391|      0|                                program_usage_message);
  392|      0|      break;
  393|       |
  394|      0|    case HelpMode::kPackage:
  ------------------
  |  Branch (394:5): [True: 0, False: 2]
  ------------------
  395|      0|      flags_internal::FlagsHelpImpl(
  396|      0|          out, flags_internal::GetUsageConfig().contains_helppackage_flags,
  397|      0|          GetFlagsHelpFormat(), program_usage_message);
  398|      0|      break;
  399|       |
  400|      0|    case HelpMode::kMatch: {
  ------------------
  |  Branch (400:5): [True: 0, False: 2]
  ------------------
  401|      0|      std::string substr = GetFlagsHelpMatchSubstr();
  402|      0|      if (substr.empty()) {
  ------------------
  |  Branch (402:11): [True: 0, False: 0]
  ------------------
  403|       |        // show all options
  404|      0|        flags_internal::FlagsHelp(out, substr, GetFlagsHelpFormat(),
  405|      0|                                  program_usage_message);
  406|      0|      } else {
  407|      0|        auto filter_cb = [&substr](const absl::CommandLineFlag& flag) {
  408|      0|          if (absl::StrContains(flag.Name(), substr)) return true;
  409|      0|          if (absl::StrContains(flag.Filename(), substr)) return true;
  410|      0|          if (absl::StrContains(flag.Help(), substr)) return true;
  411|       |
  412|      0|          return false;
  413|      0|        };
  414|      0|        flags_internal::FlagsHelpImpl(
  415|      0|            out, filter_cb, HelpFormat::kHumanReadable, program_usage_message);
  416|      0|      }
  417|      0|      break;
  418|      0|    }
  419|      0|    case HelpMode::kVersion:
  ------------------
  |  Branch (419:5): [True: 0, False: 2]
  ------------------
  420|      0|      if (flags_internal::GetUsageConfig().version_string)
  ------------------
  |  Branch (420:11): [True: 0, False: 0]
  ------------------
  421|      0|        out << flags_internal::GetUsageConfig().version_string();
  422|       |      // Unlike help, we may be asking for version in a script, so return 0
  423|      0|      break;
  424|       |
  425|      0|    case HelpMode::kOnlyCheckArgs:
  ------------------
  |  Branch (425:5): [True: 0, False: 2]
  ------------------
  426|      0|      break;
  427|      2|  }
  428|       |
  429|      2|  return GetFlagsHelpMode();
  430|      2|}
_ZN4absl12lts_2026052614flags_internal16GetFlagsHelpModeEv:
  462|      4|HelpMode GetFlagsHelpMode() {
  463|      4|  absl::MutexLock l(HelpAttributesMutex());
  464|      4|  return help_mode;
  465|      4|}
_ZN4absl12lts_2026052614flags_internal9MaybeExitENS1_8HelpModeE:
  542|      2|void MaybeExit(HelpMode mode) {
  543|      2|  switch (mode) {
  544|      2|    case flags_internal::HelpMode::kNone:
  ------------------
  |  Branch (544:5): [True: 2, False: 0]
  ------------------
  545|      2|      return;
  546|      0|    case flags_internal::HelpMode::kOnlyCheckArgs:
  ------------------
  |  Branch (546:5): [True: 0, False: 2]
  ------------------
  547|      0|    case flags_internal::HelpMode::kVersion:
  ------------------
  |  Branch (547:5): [True: 0, False: 2]
  ------------------
  548|      0|      std::exit(0);
  549|      0|    default:  // For all the other modes we exit with 1
  ------------------
  |  Branch (549:5): [True: 0, False: 2]
  ------------------
  550|      0|      std::exit(1);
  551|      2|  }
  552|      2|}
usage.cc:_ZN4absl12lts_2026052614flags_internal12_GLOBAL__N_119HelpAttributesMutexEv:
  437|      4|absl::Mutex& HelpAttributesMutex() {
  438|      4|  static absl::NoDestructor<absl::Mutex> mutex;
  439|      4|  return *mutex;
  440|      4|}

_ZN4absl12lts_2026052614flags_internal13AbslParseFlagENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPNS2_12basic_stringIcS5_NS2_9allocatorIcEEEESB_:
  157|      2|bool AbslParseFlag(absl::string_view text, std::string* dst, std::string*) {
  158|      2|  dst->assign(text.data(), text.size());
  159|      2|  return true;
  160|      2|}

_ZN4absl12lts_202605269ParseFlagINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEbNS2_17basic_string_viewIcS5_EEPT_PS8_:
  307|      2|inline bool ParseFlag(absl::string_view input, T* dst, std::string* error) {
  308|      2|  return flags_internal::InvokeParseFlag(input, dst, error);
  309|      2|}
_ZN4absl12lts_2026052614flags_internal15InvokeParseFlagINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEbNS3_17basic_string_viewIcS6_EEPT_PS9_:
  256|      2|bool InvokeParseFlag(absl::string_view input, T* dst, std::string* err) {
  257|       |  // Comment on next line provides a good compiler error message if T
  258|       |  // does not have AbslParseFlag(absl::string_view, T*, std::string*).
  259|      2|  return AbslParseFlag(input, dst, err);  // Is T missing AbslParseFlag?
  260|      2|}

_ZN4absl12lts_2026052614flags_internal24ParseAbseilFlagsOnlyImplEiPPcRNSt3__16vectorIS2_NS4_9allocatorIS2_EEEERNS5_INS0_16UnrecognizedFlagENS6_ISA_EEEENS1_16UsageFlagsActionE:
  753|      2|    UsageFlagsAction usage_flag_action) {
  754|      2|  ABSL_INTERNAL_CHECK(argc > 0, "Missing argv[0]");
  ------------------
  |  |   85|      2|  do {                                                             \
  |  |   86|      2|    if (ABSL_PREDICT_FALSE(!(condition))) {                        \
  |  |  ------------------
  |  |  |  |  190|      2|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 2]
  |  |  |  |  |  Branch (190:49): [Folded, False: 2]
  |  |  |  |  |  Branch (190:58): [True: 0, False: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   87|      0|      std::string death_message = "Check " #condition " failed: "; \
  |  |   88|      0|      death_message += std::string(message);                       \
  |  |   89|      0|      ABSL_INTERNAL_LOG(FATAL, death_message);                     \
  |  |  ------------------
  |  |  |  |   76|      0|  do {                                                                    \
  |  |  |  |   77|      0|    constexpr const char* absl_raw_log_internal_filename = __FILE__;      \
  |  |  |  |   78|      0|    ::absl::raw_log_internal::internal_log_function(                      \
  |  |  |  |   79|      0|        ABSL_RAW_LOG_INTERNAL_##severity, absl_raw_log_internal_filename, \
  |  |  |  |  ------------------
  |  |  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  |  |  ------------------
  |  |  |  |   80|      0|        __LINE__, message);                                               \
  |  |  |  |   81|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                   \
  |  |  |  |  ------------------
  |  |  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   82|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (82:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   90|      0|    }                                                              \
  |  |   91|      2|  } while (0)
  |  |  ------------------
  |  |  |  Branch (91:12): [Folded, False: 2]
  |  |  ------------------
  ------------------
  755|       |
  756|      2|  using flags_internal::ArgsList;
  757|      2|  using flags_internal::specified_flags;
  758|       |
  759|      2|  std::vector<std::string> flagfile_value;
  760|      2|  std::vector<ArgsList> input_args;
  761|       |
  762|       |  // Once parsing has started we will not allow more flag registrations.
  763|      2|  flags_internal::FinalizeRegistry();
  764|       |
  765|       |  // This routine does not return anything since we abort on failure.
  766|      2|  flags_internal::CheckDefaultValuesParsingRoundtrip();
  767|       |
  768|      2|  input_args.push_back(ArgsList(argc, argv));
  769|       |
  770|       |  // Set program invocation name if it is not set before.
  771|      2|  if (flags_internal::ProgramInvocationName() == "UNKNOWN") {
  ------------------
  |  Branch (771:7): [True: 2, False: 0]
  ------------------
  772|      2|    flags_internal::SetProgramInvocationName(argv[0]);
  773|      2|  }
  774|      2|  positional_args.push_back(argv[0]);
  775|       |
  776|      2|  absl::MutexLock l(flags_internal::SpecifiedFlagsMutex());
  777|      2|  if (specified_flags == nullptr) {
  ------------------
  |  Branch (777:7): [True: 2, False: 0]
  ------------------
  778|      2|    specified_flags = new std::vector<const CommandLineFlag*>;
  779|      2|  } else {
  780|      0|    specified_flags->clear();
  781|      0|  }
  782|       |
  783|       |  // Iterate through the list of the input arguments. First level are
  784|       |  // arguments originated from argc/argv. Following levels are arguments
  785|       |  // originated from recursive parsing of flagfile(s).
  786|      2|  bool success = true;
  787|      4|  while (!input_args.empty()) {
  ------------------
  |  Branch (787:10): [True: 4, False: 0]
  ------------------
  788|       |    // First we process the built-in generator flags.
  789|      4|    success &= flags_internal::HandleGeneratorFlags(input_args, flagfile_value);
  790|       |
  791|       |    // Select top-most (most recent) arguments list. If it is empty drop it
  792|       |    // and re-try.
  793|      4|    ArgsList& curr_list = input_args.back();
  794|       |
  795|       |    // Every ArgsList starts with real or fake program name, so we can always
  796|       |    // start by skipping it.
  797|      4|    curr_list.PopFront();
  798|       |
  799|      4|    if (curr_list.Size() == 0) {
  ------------------
  |  Branch (799:9): [True: 0, False: 4]
  ------------------
  800|      0|      input_args.pop_back();
  801|      0|      continue;
  802|      0|    }
  803|       |
  804|       |    // Handle the next argument in the current list. If the stack of argument
  805|       |    // lists contains only one element - we are processing an argument from
  806|       |    // the original argv.
  807|      4|    absl::string_view arg(curr_list.Front());
  808|      4|    bool arg_from_argv = input_args.size() == 1;
  809|       |
  810|       |    // If argument does not start with '-' or is just "-" - this is
  811|       |    // positional argument.
  812|      4|    if (!absl::ConsumePrefix(&arg, "-") || arg.empty()) {
  ------------------
  |  Branch (812:9): [True: 0, False: 4]
  |  Branch (812:44): [True: 0, False: 4]
  ------------------
  813|      0|      ABSL_INTERNAL_CHECK(arg_from_argv,
  ------------------
  |  |   85|      0|  do {                                                             \
  |  |   86|      0|    if (ABSL_PREDICT_FALSE(!(condition))) {                        \
  |  |  ------------------
  |  |  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   87|      0|      std::string death_message = "Check " #condition " failed: "; \
  |  |   88|      0|      death_message += std::string(message);                       \
  |  |   89|      0|      ABSL_INTERNAL_LOG(FATAL, death_message);                     \
  |  |  ------------------
  |  |  |  |   76|      0|  do {                                                                    \
  |  |  |  |   77|      0|    constexpr const char* absl_raw_log_internal_filename = __FILE__;      \
  |  |  |  |   78|      0|    ::absl::raw_log_internal::internal_log_function(                      \
  |  |  |  |   79|      0|        ABSL_RAW_LOG_INTERNAL_##severity, absl_raw_log_internal_filename, \
  |  |  |  |  ------------------
  |  |  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  |  |  ------------------
  |  |  |  |   80|      0|        __LINE__, message);                                               \
  |  |  |  |   81|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                   \
  |  |  |  |  ------------------
  |  |  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   82|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (82:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   90|      0|    }                                                              \
  |  |   91|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (91:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  814|      0|                          "Flagfile cannot contain positional argument");
  815|       |
  816|      0|      positional_args.push_back(argv[curr_list.FrontIndex()]);
  817|      0|      continue;
  818|      0|    }
  819|       |
  820|       |    // Split the current argument on '=' to deduce the argument flag name and
  821|       |    // value. If flag name is empty it means we've got an "--" argument. Value
  822|       |    // can be empty either if there were no '=' in argument string at all or
  823|       |    // an argument looked like "--foo=". In a latter case is_empty_value is
  824|       |    // true.
  825|      4|    absl::string_view flag_name;
  826|      4|    absl::string_view value;
  827|      4|    bool is_empty_value = false;
  828|       |
  829|      4|    std::tie(flag_name, value, is_empty_value) =
  830|      4|        flags_internal::SplitNameAndValue(arg);
  831|       |
  832|       |    // Standalone "--" argument indicates that the rest of the arguments are
  833|       |    // positional. We do not support positional arguments in flagfiles.
  834|      4|    if (flag_name.empty()) {
  ------------------
  |  Branch (834:9): [True: 2, False: 2]
  ------------------
  835|      2|      ABSL_INTERNAL_CHECK(arg_from_argv,
  ------------------
  |  |   85|      2|  do {                                                             \
  |  |   86|      2|    if (ABSL_PREDICT_FALSE(!(condition))) {                        \
  |  |  ------------------
  |  |  |  |  190|      2|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 2]
  |  |  |  |  |  Branch (190:49): [Folded, False: 2]
  |  |  |  |  |  Branch (190:58): [True: 0, False: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   87|      0|      std::string death_message = "Check " #condition " failed: "; \
  |  |   88|      0|      death_message += std::string(message);                       \
  |  |   89|      0|      ABSL_INTERNAL_LOG(FATAL, death_message);                     \
  |  |  ------------------
  |  |  |  |   76|      0|  do {                                                                    \
  |  |  |  |   77|      0|    constexpr const char* absl_raw_log_internal_filename = __FILE__;      \
  |  |  |  |   78|      0|    ::absl::raw_log_internal::internal_log_function(                      \
  |  |  |  |   79|      0|        ABSL_RAW_LOG_INTERNAL_##severity, absl_raw_log_internal_filename, \
  |  |  |  |  ------------------
  |  |  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  |  |  ------------------
  |  |  |  |   80|      0|        __LINE__, message);                                               \
  |  |  |  |   81|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                   \
  |  |  |  |  ------------------
  |  |  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   82|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (82:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   90|      0|    }                                                              \
  |  |   91|      2|  } while (0)
  |  |  ------------------
  |  |  |  Branch (91:12): [Folded, False: 2]
  |  |  ------------------
  ------------------
  836|      2|                          "Flagfile cannot contain positional argument");
  837|       |
  838|      2|      curr_list.PopFront();
  839|      2|      break;
  840|      2|    }
  841|       |
  842|       |    // Locate the flag based on flag name. Handle both --foo and --nofoo.
  843|      2|    CommandLineFlag* flag = nullptr;
  844|      2|    bool is_negative = false;
  845|      2|    std::tie(flag, is_negative) = flags_internal::LocateFlag(flag_name);
  846|       |
  847|      2|    if (flag == nullptr) {
  ------------------
  |  Branch (847:9): [True: 0, False: 2]
  ------------------
  848|       |      // Usage flags are not modeled as Abseil flags. Locate them separately.
  849|      0|      if (flags_internal::DeduceUsageFlags(flag_name, value)) {
  ------------------
  |  Branch (849:11): [True: 0, False: 0]
  ------------------
  850|      0|        continue;
  851|      0|      }
  852|      0|      unrecognized_flags.emplace_back(arg_from_argv
  ------------------
  |  Branch (852:39): [True: 0, False: 0]
  ------------------
  853|      0|                                          ? UnrecognizedFlag::kFromArgv
  854|      0|                                          : UnrecognizedFlag::kFromFlagfile,
  855|      0|                                      flag_name);
  856|      0|      continue;
  857|      0|    }
  858|       |
  859|       |    // Deduce flag's value (from this or next argument).
  860|      2|    bool value_success = true;
  861|      2|    std::tie(value_success, value) = flags_internal::DeduceFlagValue(
  862|      2|        *flag, value, is_negative, is_empty_value, &curr_list);
  863|      2|    success &= value_success;
  864|       |
  865|       |    // Set the located flag to a new value, unless it is retired. Setting
  866|       |    // retired flag fails, but we ignoring it here while also reporting access
  867|       |    // to retired flag.
  868|      2|    std::string error;
  869|      2|    if (!flags_internal::PrivateHandleAccessor::ParseFrom(
  ------------------
  |  Branch (869:9): [True: 0, False: 2]
  ------------------
  870|      2|            *flag, value, flags_internal::SET_FLAGS_VALUE,
  871|      2|            flags_internal::kCommandLine, error)) {
  872|      0|      if (flag->IsRetired()) continue;
  ------------------
  |  Branch (872:11): [True: 0, False: 0]
  ------------------
  873|       |
  874|      0|      flags_internal::ReportUsageError(error, true);
  875|      0|      success = false;
  876|      2|    } else {
  877|      2|      specified_flags->push_back(flag);
  878|      2|    }
  879|      2|  }
  880|       |
  881|      2|  flags_internal::ResetGeneratorFlags(flagfile_value);
  882|       |
  883|       |  // All the remaining arguments are positional.
  884|      2|  if (!input_args.empty()) {
  ------------------
  |  Branch (884:7): [True: 2, False: 0]
  ------------------
  885|      2|    for (size_t arg_index = input_args.back().FrontIndex();
  886|     11|         arg_index < static_cast<size_t>(argc); ++arg_index) {
  ------------------
  |  Branch (886:10): [True: 9, False: 2]
  ------------------
  887|      9|      positional_args.push_back(argv[arg_index]);
  888|      9|    }
  889|      2|  }
  890|       |
  891|       |  // Trim and sort the vector.
  892|      2|  specified_flags->shrink_to_fit();
  893|      2|  std::sort(specified_flags->begin(), specified_flags->end(),
  894|      2|            flags_internal::SpecifiedFlagsCompare{});
  895|       |
  896|       |  // Filter out unrecognized flags, which are ok to ignore.
  897|      2|  std::vector<UnrecognizedFlag> filtered;
  898|      2|  filtered.reserve(unrecognized_flags.size());
  899|      2|  for (const auto& unrecognized : unrecognized_flags) {
  ------------------
  |  Branch (899:33): [True: 0, False: 2]
  ------------------
  900|      0|    if (flags_internal::CanIgnoreUndefinedFlag(unrecognized.flag_name))
  ------------------
  |  Branch (900:9): [True: 0, False: 0]
  ------------------
  901|      0|      continue;
  902|      0|    filtered.push_back(unrecognized);
  903|      0|  }
  904|       |
  905|      2|  std::swap(unrecognized_flags, filtered);
  906|       |
  907|      2|  if (!success) {
  ------------------
  |  Branch (907:7): [True: 0, False: 2]
  ------------------
  908|       |#if ABSL_FLAGS_STRIP_NAMES
  909|       |    flags_internal::ReportUsageError(
  910|       |        "NOTE: command line flags are disabled in this build", true);
  911|       |#else
  912|      0|    flags_internal::HandleUsageFlags(std::cerr, ProgramUsageMessage());
  913|      0|#endif
  914|      0|    return HelpMode::kFull;  // We just need to make sure the exit with
  915|       |                             // code 1.
  916|      0|  }
  917|       |
  918|      2|  return usage_flag_action == UsageFlagsAction::kHandleUsage
  ------------------
  |  Branch (918:10): [True: 2, False: 0]
  ------------------
  919|      2|             ? flags_internal::HandleUsageFlags(std::cout,
  920|      2|                                                ProgramUsageMessage())
  921|      2|             : HelpMode::kNone;
  922|      2|}
_ZN4absl12lts_2026052620ParseAbseilFlagsOnlyEiPPcRNSt3__16vectorIS1_NS3_9allocatorIS1_EEEERNS4_INS0_16UnrecognizedFlagENS5_IS9_EEEE:
  928|      2|                          std::vector<UnrecognizedFlag>& unrecognized_flags) {
  929|      2|  auto help_mode = flags_internal::ParseAbseilFlagsOnlyImpl(
  930|      2|      argc, argv, positional_args, unrecognized_flags,
  931|      2|      flags_internal::UsageFlagsAction::kHandleUsage);
  932|       |
  933|      2|  flags_internal::MaybeExit(help_mode);
  934|      2|}
parse.cc:_ZNK3$_0clEv:
  113|      2|    .OnUpdate([]() {
  114|      2|      if (absl::GetFlag(FLAGS_flagfile).empty()) return;
  ------------------
  |  Branch (114:11): [True: 2, False: 0]
  ------------------
  115|       |
  116|      0|      absl::MutexLock l(absl::flags_internal::ProcessingChecksMutex());
  117|       |
  118|       |      // Setting this flag twice before it is handled most likely an internal
  119|       |      // error and should be reviewed by developers.
  120|      0|      if (absl::flags_internal::flagfile_needs_processing) {
  ------------------
  |  Branch (120:11): [True: 0, False: 0]
  ------------------
  121|      0|        ABSL_INTERNAL_LOG(WARNING, "flagfile set twice before it is handled");
  ------------------
  |  |   76|      0|  do {                                                                    \
  |  |   77|      0|    constexpr const char* absl_raw_log_internal_filename = __FILE__;      \
  |  |   78|      0|    ::absl::raw_log_internal::internal_log_function(                      \
  |  |   79|      0|        ABSL_RAW_LOG_INTERNAL_##severity, absl_raw_log_internal_filename, \
  |  |  ------------------
  |  |  |  |  108|      0|#define ABSL_RAW_LOG_INTERNAL_WARNING ::absl::LogSeverity::kWarning
  |  |  ------------------
  |  |   80|      0|        __LINE__, message);                                               \
  |  |   81|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                   \
  |  |   82|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (82:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  122|      0|      }
  123|       |
  124|      0|      absl::flags_internal::flagfile_needs_processing = true;
  125|      0|    });
parse.cc:_ZN4absl12lts_2026052614flags_internal12_GLOBAL__N_121ProcessingChecksMutexEv:
   67|      6|absl::Mutex& ProcessingChecksMutex() {
   68|      6|  static absl::NoDestructor<absl::Mutex> mutex;
   69|      6|  return *mutex;
   70|      6|}
parse.cc:_ZNK3$_1clEv:
  129|      2|    .OnUpdate([]() {
  130|      2|      if (absl::GetFlag(FLAGS_fromenv).empty()) return;
  ------------------
  |  Branch (130:11): [True: 2, False: 0]
  ------------------
  131|       |
  132|      0|      absl::MutexLock l(absl::flags_internal::ProcessingChecksMutex());
  133|       |
  134|       |      // Setting this flag twice before it is handled most likely an internal
  135|       |      // error and should be reviewed by developers.
  136|      0|      if (absl::flags_internal::fromenv_needs_processing) {
  ------------------
  |  Branch (136:11): [True: 0, False: 0]
  ------------------
  137|      0|        ABSL_INTERNAL_LOG(WARNING, "fromenv set twice before it is handled.");
  ------------------
  |  |   76|      0|  do {                                                                    \
  |  |   77|      0|    constexpr const char* absl_raw_log_internal_filename = __FILE__;      \
  |  |   78|      0|    ::absl::raw_log_internal::internal_log_function(                      \
  |  |   79|      0|        ABSL_RAW_LOG_INTERNAL_##severity, absl_raw_log_internal_filename, \
  |  |  ------------------
  |  |  |  |  108|      0|#define ABSL_RAW_LOG_INTERNAL_WARNING ::absl::LogSeverity::kWarning
  |  |  ------------------
  |  |   80|      0|        __LINE__, message);                                               \
  |  |   81|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                   \
  |  |   82|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (82:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  138|      0|      }
  139|       |
  140|      0|      absl::flags_internal::fromenv_needs_processing = true;
  141|      0|    });
parse.cc:_ZNK3$_2clEv:
  145|      2|    .OnUpdate([]() {
  146|      2|      if (absl::GetFlag(FLAGS_tryfromenv).empty()) return;
  ------------------
  |  Branch (146:11): [True: 2, False: 0]
  ------------------
  147|       |
  148|      0|      absl::MutexLock l(absl::flags_internal::ProcessingChecksMutex());
  149|       |
  150|       |      // Setting this flag twice before it is handled most likely an internal
  151|       |      // error and should be reviewed by developers.
  152|      0|      if (absl::flags_internal::tryfromenv_needs_processing) {
  ------------------
  |  Branch (152:11): [True: 0, False: 0]
  ------------------
  153|      0|        ABSL_INTERNAL_LOG(WARNING,
  ------------------
  |  |   76|      0|  do {                                                                    \
  |  |   77|      0|    constexpr const char* absl_raw_log_internal_filename = __FILE__;      \
  |  |   78|      0|    ::absl::raw_log_internal::internal_log_function(                      \
  |  |   79|      0|        ABSL_RAW_LOG_INTERNAL_##severity, absl_raw_log_internal_filename, \
  |  |  ------------------
  |  |  |  |  108|      0|#define ABSL_RAW_LOG_INTERNAL_WARNING ::absl::LogSeverity::kWarning
  |  |  ------------------
  |  |   80|      0|        __LINE__, message);                                               \
  |  |   81|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                   \
  |  |   82|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (82:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  154|      0|                          "tryfromenv set twice before it is handled.");
  155|      0|      }
  156|       |
  157|      0|      absl::flags_internal::tryfromenv_needs_processing = true;
  158|      0|    });
parse.cc:_ZN4absl12lts_2026052614flags_internal12_GLOBAL__N_119SpecifiedFlagsMutexEv:
   79|      2|absl::Mutex& SpecifiedFlagsMutex() {
   80|      2|  static absl::NoDestructor<absl::Mutex> mutex;
   81|      2|  return *mutex;
   82|      2|}
parse.cc:_ZN4absl12lts_2026052614flags_internal12_GLOBAL__N_134CheckDefaultValuesParsingRoundtripEv:
  331|      2|void CheckDefaultValuesParsingRoundtrip() {
  332|       |#ifndef NDEBUG
  333|       |  flags_internal::ForEachFlag([&](CommandLineFlag& flag) {
  334|       |    if (flag.IsRetired()) return;
  335|       |
  336|       |#define ABSL_FLAGS_INTERNAL_IGNORE_TYPE(T, _) \
  337|       |  if (flag.IsOfType<T>()) return;
  338|       |
  339|       |    ABSL_FLAGS_INTERNAL_SUPPORTED_TYPES(ABSL_FLAGS_INTERNAL_IGNORE_TYPE)
  340|       |#undef ABSL_FLAGS_INTERNAL_IGNORE_TYPE
  341|       |
  342|       |    flags_internal::PrivateHandleAccessor::CheckDefaultValueParsingRoundtrip(
  343|       |        flag);
  344|       |  });
  345|       |#endif
  346|      2|}
parse.cc:_ZN4absl12lts_2026052614flags_internal12_GLOBAL__N_18ArgsListC2EiPPc:
  176|      2|  ArgsList(int argc, char* argv[]) : args_(argv, argv + argc), next_arg_(0) {}
parse.cc:_ZN4absl12lts_2026052614flags_internal12_GLOBAL__N_120HandleGeneratorFlagsERNSt3__16vectorINS2_8ArgsListENS3_9allocatorIS5_EEEERNS4_INS3_12basic_stringIcNS3_11char_traitsIcEENS6_IcEEEENS6_ISE_EEEE:
  424|      4|                          std::vector<std::string>& flagfile_value) {
  425|      4|  bool success = true;
  426|       |
  427|      4|  absl::MutexLock l(flags_internal::ProcessingChecksMutex());
  428|       |
  429|       |  // flagfile could have been set either on a command line or
  430|       |  // programmatically before invoking ParseCommandLine. Note that we do not
  431|       |  // actually process arguments specified in the flagfile, but instead
  432|       |  // create a secondary arguments list to be processed along with the rest
  433|       |  // of the command line arguments. Since we always the process most recently
  434|       |  // created list of arguments first, this will result in flagfile argument
  435|       |  // being processed before any other argument in the command line. If
  436|       |  // FLAGS_flagfile contains more than one file name we create multiple new
  437|       |  // levels of arguments in a reverse order of file names. Thus we always
  438|       |  // process arguments from first file before arguments containing in a
  439|       |  // second file, etc. If flagfile contains another
  440|       |  // --flagfile inside of it, it will produce new level of arguments and
  441|       |  // processed before the rest of the flagfile. We are also collecting all
  442|       |  // flagfiles set on original command line. Unlike the rest of the flags,
  443|       |  // this flag can be set multiple times and is expected to be handled
  444|       |  // multiple times. We are collecting them all into a single list and set
  445|       |  // the value of FLAGS_flagfile to that value at the end of the parsing.
  446|      4|  if (flags_internal::flagfile_needs_processing) {
  ------------------
  |  Branch (446:7): [True: 0, False: 4]
  ------------------
  447|      0|    auto flagfiles = absl::GetFlag(FLAGS_flagfile);
  448|       |
  449|      0|    if (input_args.size() == 1) {
  ------------------
  |  Branch (449:9): [True: 0, False: 0]
  ------------------
  450|      0|      flagfile_value.insert(flagfile_value.end(), flagfiles.begin(),
  451|      0|                            flagfiles.end());
  452|      0|    }
  453|       |
  454|      0|    success &= ReadFlagfiles(flagfiles, input_args);
  455|       |
  456|      0|    flags_internal::flagfile_needs_processing = false;
  457|      0|  }
  458|       |
  459|       |  // Similar to flagfile fromenv/tryfromemv can be set both
  460|       |  // programmatically and at runtime on a command line. Unlike flagfile these
  461|       |  // can't be recursive.
  462|      4|  if (flags_internal::fromenv_needs_processing) {
  ------------------
  |  Branch (462:7): [True: 0, False: 4]
  ------------------
  463|      0|    auto flags_list = absl::GetFlag(FLAGS_fromenv);
  464|       |
  465|      0|    success &= ReadFlagsFromEnv(flags_list, input_args, true);
  466|       |
  467|      0|    flags_internal::fromenv_needs_processing = false;
  468|      0|  }
  469|       |
  470|      4|  if (flags_internal::tryfromenv_needs_processing) {
  ------------------
  |  Branch (470:7): [True: 0, False: 4]
  ------------------
  471|      0|    auto flags_list = absl::GetFlag(FLAGS_tryfromenv);
  472|       |
  473|      0|    success &= ReadFlagsFromEnv(flags_list, input_args, false);
  474|       |
  475|      0|    flags_internal::tryfromenv_needs_processing = false;
  476|      0|  }
  477|       |
  478|      4|  return success;
  479|      4|}
parse.cc:_ZN4absl12lts_2026052614flags_internal12_GLOBAL__N_18ArgsList8PopFrontEv:
  186|      6|  void PopFront() { next_arg_++; }
parse.cc:_ZNK4absl12lts_2026052614flags_internal12_GLOBAL__N_18ArgsList4SizeEv:
  183|      4|  size_t Size() const { return args_.size() - next_arg_; }
parse.cc:_ZNK4absl12lts_2026052614flags_internal12_GLOBAL__N_18ArgsList5FrontEv:
  185|      4|  absl::string_view Front() const { return args_[next_arg_]; }
parse.cc:_ZNK4absl12lts_2026052614flags_internal12_GLOBAL__N_18ArgsList10FrontIndexEv:
  184|      2|  size_t FrontIndex() const { return next_arg_; }
parse.cc:_ZN4absl12lts_2026052614flags_internal12_GLOBAL__N_117SplitNameAndValueENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
  287|      4|    absl::string_view arg) {
  288|       |  // Allow -foo and --foo
  289|      4|  absl::ConsumePrefix(&arg, "-");
  290|       |
  291|      4|  if (arg.empty()) {
  ------------------
  |  Branch (291:7): [True: 2, False: 2]
  ------------------
  292|      2|    return std::make_tuple("", "", false);
  293|      2|  }
  294|       |
  295|      2|  auto equal_sign_pos = arg.find('=');
  296|       |
  297|      2|  absl::string_view flag_name = arg.substr(0, equal_sign_pos);
  298|       |
  299|      2|  absl::string_view value;
  300|      2|  bool is_empty_value = false;
  301|       |
  302|      2|  if (equal_sign_pos != absl::string_view::npos) {
  ------------------
  |  Branch (302:7): [True: 2, False: 0]
  ------------------
  303|      2|    value = arg.substr(equal_sign_pos + 1);
  304|      2|    is_empty_value = value.empty();
  305|      2|  }
  306|       |
  307|      2|  return std::make_tuple(flag_name, value, is_empty_value);
  308|      4|}
parse.cc:_ZN4absl12lts_2026052614flags_internal12_GLOBAL__N_110LocateFlagENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
  315|      2|std::tuple<CommandLineFlag*, bool> LocateFlag(absl::string_view flag_name) {
  316|      2|  CommandLineFlag* flag = absl::FindCommandLineFlag(flag_name);
  317|      2|  bool is_negative = false;
  318|       |
  319|      2|  if (!flag && absl::ConsumePrefix(&flag_name, "no")) {
  ------------------
  |  Branch (319:7): [True: 0, False: 2]
  |  Branch (319:16): [True: 0, False: 0]
  ------------------
  320|      0|    flag = absl::FindCommandLineFlag(flag_name);
  321|      0|    is_negative = true;
  322|      0|  }
  323|       |
  324|      2|  return std::make_tuple(flag, is_negative);
  325|      2|}
parse.cc:_ZN4absl12lts_2026052614flags_internal12_GLOBAL__N_115DeduceFlagValueERKNS0_15CommandLineFlagENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEbbPNS2_8ArgsListE:
  518|      2|                                                    ArgsList* curr_list) {
  519|       |  // Value is either an argument suffix after `=` in "--foo=<value>"
  520|       |  // or separate argument in case of "--foo" "<value>".
  521|       |
  522|       |  // boolean flags have these forms:
  523|       |  //   --foo
  524|       |  //   --nofoo
  525|       |  //   --foo=true
  526|       |  //   --foo=false
  527|       |  //   --nofoo=<value> is not supported
  528|       |  //   --foo <value> is not supported
  529|       |
  530|       |  // non boolean flags have these forms:
  531|       |  // --foo=<value>
  532|       |  // --foo <value>
  533|       |  // --nofoo is not supported
  534|       |
  535|      2|  if (flag.IsOfType<bool>()) {
  ------------------
  |  Branch (535:7): [True: 0, False: 2]
  ------------------
  536|      0|    if (value.empty()) {
  ------------------
  |  Branch (536:9): [True: 0, False: 0]
  ------------------
  537|      0|      if (is_empty_value) {
  ------------------
  |  Branch (537:11): [True: 0, False: 0]
  ------------------
  538|       |        // "--bool_flag=" case
  539|      0|        flags_internal::ReportUsageError(
  540|      0|            absl::StrCat(
  541|      0|                "Missing the value after assignment for the boolean flag '",
  542|      0|                flag.Name(), "'"),
  543|      0|            true);
  544|      0|        return std::make_tuple(false, "");
  545|      0|      }
  546|       |
  547|       |      // "--bool_flag" case
  548|      0|      value = is_negative ? "0" : "1";
  ------------------
  |  Branch (548:15): [True: 0, False: 0]
  ------------------
  549|      0|    } else if (is_negative) {
  ------------------
  |  Branch (549:16): [True: 0, False: 0]
  ------------------
  550|       |      // "--nobool_flag=Y" case
  551|      0|      flags_internal::ReportUsageError(
  552|      0|          absl::StrCat("Negative form with assignment is not valid for the "
  553|      0|                       "boolean flag '",
  554|      0|                       flag.Name(), "'"),
  555|      0|          true);
  556|      0|      return std::make_tuple(false, "");
  557|      0|    }
  558|      2|  } else if (is_negative) {
  ------------------
  |  Branch (558:14): [True: 0, False: 2]
  ------------------
  559|       |    // "--noint_flag=1" case
  560|      0|    flags_internal::ReportUsageError(
  561|      0|        absl::StrCat("Negative form is not valid for the flag '", flag.Name(),
  562|      0|                     "'"),
  563|      0|        true);
  564|      0|    return std::make_tuple(false, "");
  565|      2|  } else if (value.empty() && (!is_empty_value)) {
  ------------------
  |  Branch (565:14): [True: 0, False: 2]
  |  Branch (565:31): [True: 0, False: 0]
  ------------------
  566|      0|    if (curr_list->Size() == 1) {
  ------------------
  |  Branch (566:9): [True: 0, False: 0]
  ------------------
  567|       |      // "--int_flag" case
  568|      0|      flags_internal::ReportUsageError(
  569|      0|          absl::StrCat("Missing the value for the flag '", flag.Name(), "'"),
  570|      0|          true);
  571|      0|      return std::make_tuple(false, "");
  572|      0|    }
  573|       |
  574|       |    // "--int_flag" "10" case
  575|      0|    curr_list->PopFront();
  576|      0|    value = curr_list->Front();
  577|       |
  578|       |    // Heuristic to detect the case where someone treats a string arg
  579|       |    // like a bool or just forgets to pass a value:
  580|       |    // --my_string_var --foo=bar
  581|       |    // We look for a flag of string type, whose value begins with a
  582|       |    // dash and corresponds to known flag or standalone --.
  583|      0|    if (!value.empty() && value[0] == '-' && flag.IsOfType<std::string>()) {
  ------------------
  |  Branch (583:9): [True: 0, False: 0]
  |  Branch (583:27): [True: 0, False: 0]
  |  Branch (583:46): [True: 0, False: 0]
  ------------------
  584|      0|      auto maybe_flag_name = std::get<0>(SplitNameAndValue(value.substr(1)));
  585|       |
  586|      0|      if (maybe_flag_name.empty() ||
  ------------------
  |  Branch (586:11): [True: 0, False: 0]
  |  Branch (586:11): [True: 0, False: 0]
  ------------------
  587|      0|          std::get<0>(LocateFlag(maybe_flag_name)) != nullptr) {
  ------------------
  |  Branch (587:11): [True: 0, False: 0]
  ------------------
  588|       |        // "--string_flag" "--known_flag" case
  589|      0|        ABSL_INTERNAL_LOG(
  ------------------
  |  |   76|      0|  do {                                                                    \
  |  |   77|      0|    constexpr const char* absl_raw_log_internal_filename = __FILE__;      \
  |  |   78|      0|    ::absl::raw_log_internal::internal_log_function(                      \
  |  |   79|      0|        ABSL_RAW_LOG_INTERNAL_##severity, absl_raw_log_internal_filename, \
  |  |  ------------------
  |  |  |  |  108|      0|#define ABSL_RAW_LOG_INTERNAL_WARNING ::absl::LogSeverity::kWarning
  |  |  ------------------
  |  |   80|      0|        __LINE__, message);                                               \
  |  |   81|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                   \
  |  |   82|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (82:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  590|      0|            WARNING,
  591|      0|            absl::StrCat("Did you really mean to set flag '", flag.Name(),
  592|      0|                         "' to the value '", value, "'?"));
  593|      0|      }
  594|      0|    }
  595|      0|  }
  596|       |
  597|      2|  return std::make_tuple(true, value);
  598|      2|}
parse.cc:_ZN4absl12lts_2026052614flags_internal12_GLOBAL__N_119ResetGeneratorFlagsERKNSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEE:
  483|      2|void ResetGeneratorFlags(const std::vector<std::string>& flagfile_value) {
  484|       |  // Setting flagfile to the value which collates all the values set on a
  485|       |  // command line and programmatically. So if command line looked like
  486|       |  // --flagfile=f1 --flagfile=f2 the final value of the FLAGS_flagfile flag is
  487|       |  // going to be {"f1", "f2"}
  488|      2|  if (!flagfile_value.empty()) {
  ------------------
  |  Branch (488:7): [True: 0, False: 2]
  ------------------
  489|      0|    absl::SetFlag(&FLAGS_flagfile, flagfile_value);
  490|      0|    absl::MutexLock l(flags_internal::ProcessingChecksMutex());
  491|      0|    flags_internal::flagfile_needs_processing = false;
  492|      0|  }
  493|       |
  494|       |  // fromenv/tryfromenv are set to <undefined> value.
  495|      2|  if (!absl::GetFlag(FLAGS_fromenv).empty()) {
  ------------------
  |  Branch (495:7): [True: 0, False: 2]
  ------------------
  496|      0|    absl::SetFlag(&FLAGS_fromenv, {});
  497|      0|  }
  498|      2|  if (!absl::GetFlag(FLAGS_tryfromenv).empty()) {
  ------------------
  |  Branch (498:7): [True: 0, False: 2]
  ------------------
  499|      0|    absl::SetFlag(&FLAGS_tryfromenv, {});
  500|      0|  }
  501|       |
  502|      2|  absl::MutexLock l(flags_internal::ProcessingChecksMutex());
  503|      2|  flags_internal::fromenv_needs_processing = false;
  504|      2|  flags_internal::tryfromenv_needs_processing = false;
  505|      2|}

_ZN4absl12lts_2026052614flags_internal12FlagRegistry8FindFlagENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
  103|      2|CommandLineFlag* FlagRegistry::FindFlag(absl::string_view name) {
  104|      2|  if (finalized_flags_.load(std::memory_order_acquire)) {
  ------------------
  |  Branch (104:7): [True: 2, False: 0]
  ------------------
  105|       |    // We could save some gcus here if we make `Name()` be non-virtual.
  106|       |    // We could move the `const char*` name to the base class.
  107|      2|    auto it = std::partition_point(
  108|      2|        flat_flags_.begin(), flat_flags_.end(),
  109|      2|        [=](CommandLineFlag* f) { return f->Name() < name; });
  110|      2|    if (it != flat_flags_.end() && (*it)->Name() == name) return *it;
  ------------------
  |  Branch (110:9): [True: 2, False: 0]
  |  Branch (110:9): [True: 2, False: 0]
  |  Branch (110:36): [True: 2, False: 0]
  ------------------
  111|      2|  }
  112|       |
  113|      0|  FlagRegistryLock frl(*this);
  114|      0|  auto it = flags_.find(name);
  115|      0|  return it != flags_.end() ? it->second : nullptr;
  ------------------
  |  Branch (115:10): [True: 0, False: 0]
  ------------------
  116|      2|}
_ZN4absl12lts_2026052614flags_internal12FlagRegistry12RegisterFlagERNS0_15CommandLineFlagEPKc:
  118|     50|void FlagRegistry::RegisterFlag(CommandLineFlag& flag, const char* filename) {
  119|     50|  if (filename != nullptr &&
  ------------------
  |  Branch (119:7): [True: 50, False: 0]
  |  Branch (119:7): [True: 0, False: 50]
  ------------------
  120|     50|      flag.Filename() != GetUsageConfig().normalize_filename(filename)) {
  ------------------
  |  Branch (120:7): [True: 0, False: 50]
  ------------------
  121|      0|    flags_internal::ReportUsageError(
  122|      0|        absl::StrCat(
  123|      0|            "Inconsistency between flag object and registration for flag '",
  124|      0|            flag.Name(),
  125|      0|            "', likely due to duplicate flags or an ODR violation. Relevant "
  126|      0|            "files: ",
  127|      0|            flag.Filename(), " and ", filename),
  128|      0|        true);
  129|      0|    std::exit(1);
  130|      0|  }
  131|       |
  132|     50|  FlagRegistryLock registry_lock(*this);
  133|       |
  134|     50|  std::pair<FlagIterator, bool> ins =
  135|     50|      flags_.insert(FlagMap::value_type(flag.Name(), &flag));
  136|     50|  if (ins.second == false) {  // means the name was already in the map
  ------------------
  |  Branch (136:7): [True: 0, False: 50]
  ------------------
  137|      0|    CommandLineFlag& old_flag = *ins.first->second;
  138|      0|    if (flag.IsRetired() != old_flag.IsRetired()) {
  ------------------
  |  Branch (138:9): [True: 0, False: 0]
  ------------------
  139|       |      // All registrations must agree on the 'retired' flag.
  140|      0|      flags_internal::ReportUsageError(
  141|      0|          absl::StrCat(
  142|      0|              "Retired flag '", flag.Name(), "' was defined normally in file '",
  143|      0|              (flag.IsRetired() ? old_flag.Filename() : flag.Filename()), "'."),
  ------------------
  |  Branch (143:16): [True: 0, False: 0]
  ------------------
  144|      0|          true);
  145|      0|    } else if (flags_internal::PrivateHandleAccessor::TypeId(flag) !=
  ------------------
  |  Branch (145:16): [True: 0, False: 0]
  ------------------
  146|      0|               flags_internal::PrivateHandleAccessor::TypeId(old_flag)) {
  147|      0|      flags_internal::ReportUsageError(
  148|      0|          absl::StrCat("Flag '", flag.Name(),
  149|      0|                       "' was defined more than once but with "
  150|      0|                       "differing types. Defined in files '",
  151|      0|                       old_flag.Filename(), "' and '", flag.Filename(), "'."),
  152|      0|          true);
  153|      0|    } else if (old_flag.IsRetired()) {
  ------------------
  |  Branch (153:16): [True: 0, False: 0]
  ------------------
  154|      0|      return;
  155|      0|    } else if (old_flag.Filename() != flag.Filename()) {
  ------------------
  |  Branch (155:16): [True: 0, False: 0]
  ------------------
  156|      0|      flags_internal::ReportUsageError(
  157|      0|          absl::StrCat("Flag '", flag.Name(),
  158|      0|                       "' was defined more than once (in files '",
  159|      0|                       old_flag.Filename(), "' and '", flag.Filename(), "')."),
  160|      0|          true);
  161|      0|    } else {
  162|      0|      flags_internal::ReportUsageError(
  163|      0|          absl::StrCat(
  164|      0|              "Something is wrong with flag '", flag.Name(), "' in file '",
  165|      0|              flag.Filename(), "'. One possibility: file '", flag.Filename(),
  166|      0|              "' is being linked both statically and dynamically into this "
  167|      0|              "executable. e.g. some files listed as srcs to a test and also "
  168|      0|              "listed as srcs of some shared lib deps of the same test."),
  169|      0|          true);
  170|      0|    }
  171|       |    // All cases above are fatal, except for the retired flags.
  172|      0|    std::exit(1);
  173|      0|  }
  174|     50|}
_ZN4absl12lts_2026052614flags_internal12FlagRegistry14GlobalRegistryEv:
  176|     54|FlagRegistry& FlagRegistry::GlobalRegistry() {
  177|     54|  static absl::NoDestructor<FlagRegistry> global_registry;
  178|     54|  return *global_registry;
  179|     54|}
_ZN4absl12lts_2026052614flags_internal23RegisterCommandLineFlagERNS0_15CommandLineFlagEPKc:
  196|     50|bool RegisterCommandLineFlag(CommandLineFlag& flag, const char* filename) {
  197|     50|  FlagRegistry::GlobalRegistry().RegisterFlag(flag, filename);
  198|     50|  return true;
  199|     50|}
_ZN4absl12lts_2026052614flags_internal16FinalizeRegistryEv:
  201|      2|void FinalizeRegistry() {
  202|      2|  auto& registry = FlagRegistry::GlobalRegistry();
  203|      2|  FlagRegistryLock frl(registry);
  204|      2|  if (registry.finalized_flags_.load(std::memory_order_relaxed)) {
  ------------------
  |  Branch (204:7): [True: 0, False: 2]
  ------------------
  205|       |    // Was already finalized. Ignore the second time.
  206|      0|    return;
  207|      0|  }
  208|      2|  registry.flat_flags_.reserve(registry.flags_.size());
  209|     50|  for (const auto& f : registry.flags_) {
  ------------------
  |  Branch (209:22): [True: 50, False: 2]
  ------------------
  210|     50|    registry.flat_flags_.push_back(f.second);
  211|     50|  }
  212|      2|  std::sort(std::begin(registry.flat_flags_), std::end(registry.flat_flags_),
  213|      2|            [](const CommandLineFlag* lhs, const CommandLineFlag* rhs) {
  214|      2|              return lhs->Name() < rhs->Name();
  215|      2|            });
  216|      2|  registry.flags_.clear();
  217|      2|  registry.finalized_flags_.store(true, std::memory_order_release);
  218|      2|}
_ZN4absl12lts_2026052619FindCommandLineFlagENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  350|      2|CommandLineFlag* FindCommandLineFlag(absl::string_view name) {
  351|      2|  if (name.empty()) return nullptr;
  ------------------
  |  Branch (351:7): [True: 0, False: 2]
  ------------------
  352|      2|  flags_internal::FlagRegistry& registry =
  353|      2|      flags_internal::FlagRegistry::GlobalRegistry();
  354|      2|  return registry.FindFlag(name);
  355|      2|}
reflection.cc:_ZN4absl12lts_2026052614flags_internal12_GLOBAL__N_116FlagRegistryLockC2ERNS1_12FlagRegistryE:
   94|     52|  explicit FlagRegistryLock(FlagRegistry& fr) : fr_(fr) { fr_.lock(); }
_ZN4absl12lts_2026052614flags_internal12FlagRegistry4lockEv:
   57|     52|  void lock() ABSL_EXCLUSIVE_LOCK_FUNCTION(lock_) { lock_.lock(); }
reflection.cc:_ZN4absl12lts_2026052614flags_internal12_GLOBAL__N_116FlagRegistryLockD2Ev:
   95|     52|  ~FlagRegistryLock() { fr_.unlock(); }
_ZN4absl12lts_2026052614flags_internal12FlagRegistry6unlockEv:
   60|     52|  void unlock() ABSL_UNLOCK_FUNCTION(lock_) { lock_.unlock(); }
_ZN4absl12lts_2026052614flags_internal12FlagRegistryC2Ev:
   51|      2|  FlagRegistry() = default;
reflection.cc:_ZZN4absl12lts_2026052614flags_internal12FlagRegistry8FindFlagENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEENK3$_0clEPNS0_15CommandLineFlagE:
  109|     10|        [=](CommandLineFlag* f) { return f->Name() < name; });
reflection.cc:_ZZN4absl12lts_2026052614flags_internal16FinalizeRegistryEvENK3$_0clEPKNS0_15CommandLineFlagES5_:
  213|    260|            [](const CommandLineFlag* lhs, const CommandLineFlag* rhs) {
  214|    260|              return lhs->Name() < rhs->Name();
  215|    260|            });

_ZN4absl12lts_2026052619ProgramUsageMessageEv:
   57|      2|absl::string_view ProgramUsageMessage() {
   58|      2|  absl::MutexLock l(flags_internal::usage_message_guard);
   59|       |
   60|      2|  return flags_internal::program_usage_message != nullptr
  ------------------
  |  Branch (60:10): [True: 0, False: 2]
  ------------------
   61|      2|             ? absl::string_view(*flags_internal::program_usage_message)
   62|      2|             : "Warning: SetProgramUsageMessage() never called";
   63|      2|}

_ZN4absl12lts_2026052614flags_internal14GetUsageConfigEv:
  118|    100|FlagsUsageConfig GetUsageConfig() {
  119|    100|  absl::MutexLock l(CustomUsageConfigMutex());
  120|       |
  121|    100|  if (custom_usage_config) return *custom_usage_config;
  ------------------
  |  Branch (121:7): [True: 0, False: 100]
  ------------------
  122|       |
  123|    100|  FlagsUsageConfig default_config;
  124|    100|  default_config.contains_helpshort_flags = &ContainsHelpshortFlags;
  125|    100|  default_config.contains_help_flags = &ContainsHelppackageFlags;
  126|    100|  default_config.contains_helppackage_flags = &ContainsHelppackageFlags;
  127|    100|  default_config.version_string = &VersionString;
  128|    100|  default_config.normalize_filename = &NormalizeFilename;
  129|       |
  130|    100|  return default_config;
  131|    100|}
usage_config.cc:_ZN4absl12lts_2026052614flags_internal12_GLOBAL__N_122CustomUsageConfigMutexEv:
  108|    100|absl::Mutex& CustomUsageConfigMutex() {
  109|    100|  static absl::NoDestructor<absl::Mutex> mutex;
  110|    100|  return *mutex;
  111|    100|}
usage_config.cc:_ZN4absl12lts_2026052614flags_internal12_GLOBAL__N_117NormalizeFilenameENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   97|    100|std::string NormalizeFilename(absl::string_view filename) {
   98|       |  // Skip any leading slashes
   99|    100|  auto pos = filename.find_first_not_of("\\/");
  100|    100|  if (pos == absl::string_view::npos) return "";
  ------------------
  |  Branch (100:7): [True: 0, False: 100]
  ------------------
  101|       |
  102|    100|  filename.remove_prefix(pos);
  103|    100|  return std::string(filename);
  104|    100|}

_ZN4absl12lts_2026052612AnyInvocableIKFNSt3__110unique_ptrIN8fuzztest8internal14FuzzTestFuzzerENS2_14default_deleteIS6_EEEERKNS5_8FuzzTestEEEC2IZNS5_17RegistrationToken24GetFuzzTestFuzzerFactoryINS5_27RegistrationWithDomainsBaseIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEENS5_9NoFixtureEPFvNS2_17basic_string_viewIcSL_EEEPvEESE_ONS5_12RegistrationIT0_T1_T_T2_EEEUlSC_E_vEEOSZ_:
  197|      2|      : Impl(internal_any_invocable::ConversionConstruct(),
  198|      2|             std::forward<F>(f)) {}
_ZN4absl12lts_2026052612AnyInvocableIKFNSt3__110unique_ptrIN8fuzztest8internal14FuzzTestFuzzerENS2_14default_deleteIS6_EEEERKNS5_8FuzzTestEEEC2EOSE_:
  187|      4|  AnyInvocable(AnyInvocable&& /*f*/) noexcept = default;
compatibility_mode.cc:_ZN4absl12lts_2026052612AnyInvocableIFvvOEEC2IZN8fuzztest8internal29FuzzTestExternalEngineAdaptor16RunInFuzzingModeEPiPPPcRKNS6_13ConfigurationEE3$_0vEEOT_:
  197|      2|      : Impl(internal_any_invocable::ConversionConstruct(),
  198|      2|             std::forward<F>(f)) {}
runtime.cc:_ZN4absl12lts_2026052612AnyInvocableIFvvOEEC2IZN8fuzztest8internal18FuzzTestFuzzerImpl11RunOneInputERKNS7_5InputEE3$_0vEEOT_:
  197|  1.13k|      : Impl(internal_any_invocable::ConversionConstruct(),
  198|  1.13k|             std::forward<F>(f)) {}

init_fuzztest.cc:_ZN4absl12lts_2026052611FunctionRefIFvRN8fuzztest8internal8FuzzTestEEEC2IZNS2_19ListRegisteredTestsEvE3$_0vEEOT_:
  112|      6|      : FunctionRef(std::in_place, std::forward<F>(f)) {}
init_fuzztest.cc:_ZN4absl12lts_2026052611FunctionRefIFvRN8fuzztest8internal8FuzzTestEEEC2IZNS2_19ListRegisteredTestsEvE3$_0EENSt3__110in_place_tEOT_:
  100|      6|      : invoker_(&absl::functional_internal::InvokeObject<F&, R, Args...>) {
  101|      6|    absl::functional_internal::AssertNonNull(f);
  102|      6|    ptr_.obj = &f;
  103|      6|  }
_ZN4absl12lts_2026052611FunctionRefIFmmEEC2INS0_18container_internal7HashKeyINS5_10StringHashENSt3__117basic_string_viewIcNS8_11char_traitsIcEEEELb1EEEvEEOT_:
  112|      4|      : FunctionRef(std::in_place, std::forward<F>(f)) {}
_ZN4absl12lts_2026052611FunctionRefIFmmEEC2INS0_18container_internal7HashKeyINS5_10StringHashENSt3__117basic_string_viewIcNS8_11char_traitsIcEEEELb1EEEEENS8_10in_place_tEOT_:
  100|      4|      : invoker_(&absl::functional_internal::InvokeObject<F&, R, Args...>) {
  101|      4|    absl::functional_internal::AssertNonNull(f);
  102|      4|    ptr_.obj = &f;
  103|      4|  }
googletest_adaptor.cc:_ZN4absl12lts_2026052611FunctionRefIFvRN8fuzztest8internal8FuzzTestEEEC2IZNS3_30RegisterFuzzTestsAsGoogleTestsEPiPPPcRKNS3_13ConfigurationEE3$_0vEEOT_:
  112|      2|      : FunctionRef(std::in_place, std::forward<F>(f)) {}
googletest_adaptor.cc:_ZN4absl12lts_2026052611FunctionRefIFvRN8fuzztest8internal8FuzzTestEEEC2IZNS3_30RegisterFuzzTestsAsGoogleTestsEPiPPPcRKNS3_13ConfigurationEE3$_0EENSt3__110in_place_tEOT_:
  100|      2|      : invoker_(&absl::functional_internal::InvokeObject<F&, R, Args...>) {
  101|      2|    absl::functional_internal::AssertNonNull(f);
  102|      2|    ptr_.obj = &f;
  103|      2|  }
_ZNK4absl12lts_2026052611FunctionRefIFvRN8fuzztest8internal8FuzzTestEEEclES5_:
  164|      8|  R operator()(Args... args) const {
  165|      8|    return invoker_(ptr_, std::forward<Args>(args)...);
  166|      8|  }
_ZNK4absl12lts_2026052611FunctionRefIFmmEEclEm:
  164|      2|  R operator()(Args... args) const {
  165|      2|    return invoker_(ptr_, std::forward<Args>(args)...);
  166|      2|  }

_ZN4absl12lts_2026052622internal_any_invocable4ImplIKFNSt3__110unique_ptrIN8fuzztest8internal14FuzzTestFuzzerENS3_14default_deleteIS7_EEEERKNS6_8FuzzTestEEEC2IZNS6_17RegistrationToken24GetFuzzTestFuzzerFactoryINS6_27RegistrationWithDomainsBaseIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEENS6_9NoFixtureEPFvNS3_17basic_string_viewIcSM_EEEPvEENS0_12AnyInvocableISE_EEONS6_12RegistrationIT0_T1_T_T2_EEEUlSD_E_EENS1_19ConversionConstructEOS12_:
  719|      2|        : Core(TypedConversionConstruct<                                       \
  720|      2|                   typename std::decay<F>::type inv_quals>(),                  \
  721|      2|               std::forward<F>(f)) {}                                          \
_ZN4absl12lts_2026052622internal_any_invocable8CoreImplILb0ENSt3__110unique_ptrIN8fuzztest8internal14FuzzTestFuzzerENS3_14default_deleteIS7_EEEEJRKNS6_8FuzzTestEEEC2IRKZNS6_17RegistrationToken24GetFuzzTestFuzzerFactoryINS6_27RegistrationWithDomainsBaseIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEENS6_9NoFixtureEPFvNS3_17basic_string_viewIcSL_EEEPvEENS0_12AnyInvocableIKFSA_SD_EEEONS6_12RegistrationIT0_T1_T_T2_EEEUlSD_E_S16_EENS1_24TypedConversionConstructIS12_EEOS10_:
  417|      2|  explicit CoreImpl(TypedConversionConstruct<QualDecayedTRef>, F&& f) {
  418|      2|    using DecayedT = RemoveCVRef<QualDecayedTRef>;
  419|       |
  420|       |    if constexpr (std::is_pointer<DecayedT>::value ||
  421|       |                  std::is_member_pointer<DecayedT>::value) {
  422|       |      // This condition handles types that decay into pointers. This includes
  423|       |      // function references, which cannot be null. GCC warns against comparing
  424|       |      // their decayed form with nullptr (https://godbolt.org/z/9r9TMTcPK).
  425|       |      // We could work around this warning with constexpr programming, using
  426|       |      // std::is_function_v<std::remove_reference_t<F>>, but we choose to ignore
  427|       |      // it instead of writing more code.
  428|       |#if !defined(__clang__) && defined(__GNUC__)
  429|       |#pragma GCC diagnostic push
  430|       |#pragma GCC diagnostic ignored "-Wpragmas"
  431|       |#pragma GCC diagnostic ignored "-Waddress"
  432|       |#pragma GCC diagnostic ignored "-Wnonnull-compare"
  433|       |#endif
  434|       |      if (static_cast<DecayedT>(f) == nullptr) {
  435|       |#if !defined(__clang__) && defined(__GNUC__)
  436|       |#pragma GCC diagnostic pop
  437|       |#endif
  438|       |        manager_ = EmptyManager;
  439|       |        invoker_ = nullptr;
  440|       |      } else {
  441|       |        InitializeStorage<QualDecayedTRef>(std::forward<F>(f));
  442|       |      }
  443|       |    } else if constexpr (IsCompatibleAnyInvocable<DecayedT>::value) {
  444|       |      // In this case we can "steal the guts" of the other AnyInvocable.
  445|       |      f.manager_(FunctionToCall::relocate_from_to, &f.state_, &state_);
  446|       |      manager_ = f.manager_;
  447|       |      invoker_ = f.invoker_;
  448|       |
  449|       |      f.manager_ = EmptyManager;
  450|       |      f.invoker_ = nullptr;
  451|       |    } else if constexpr (IsAnyInvocable<DecayedT>::value) {
  452|       |      if (f.HasValue()) {
  453|       |        InitializeStorage<QualDecayedTRef>(std::forward<F>(f));
  454|       |      } else {
  455|       |        manager_ = EmptyManager;
  456|       |        invoker_ = nullptr;
  457|       |      }
  458|      2|    } else {
  459|      2|      InitializeStorage<QualDecayedTRef>(std::forward<F>(f));
  460|      2|    }
  461|      2|  }
_ZN4absl12lts_2026052622internal_any_invocable8CoreImplILb0ENSt3__110unique_ptrIN8fuzztest8internal14FuzzTestFuzzerENS3_14default_deleteIS7_EEEEJRKNS6_8FuzzTestEEE17InitializeStorageIRKZNS6_17RegistrationToken24GetFuzzTestFuzzerFactoryINS6_27RegistrationWithDomainsBaseIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEENS6_9NoFixtureEPFvNS3_17basic_string_viewIcSL_EEEPvEENS0_12AnyInvocableIKFSA_SD_EEEONS6_12RegistrationIT0_T1_T_T2_EEEUlSD_E_JS16_EEEvDpOT0_:
  513|      2|  void InitializeStorage(Args&&... args) {
  514|      2|    using RawT = RemoveCVRef<QualTRef>;
  515|       |    if constexpr (IsStoredLocally<RawT>()) {
  516|       |      ::new (static_cast<void*>(&state_.storage))
  517|       |          RawT(std::forward<Args>(args)...);
  518|       |      invoker_ = LocalInvoker<SigIsNoexcept, ReturnType, QualTRef, P...>;
  519|       |      // We can simplify our manager if we know the type is trivially copyable.
  520|       |      if constexpr (std::is_trivially_copyable_v<RawT>) {
  521|       |        manager_ = LocalManagerTrivial;
  522|       |      } else {
  523|       |        manager_ = LocalManagerNontrivial<RawT>;
  524|       |      }
  525|      2|    } else {
  526|      2|      InitializeRemoteManager<RawT>(std::forward<Args>(args)...);
  527|       |      // This is set after everything else in case an exception is thrown in an
  528|       |      // earlier step of the initialization.
  529|      2|      invoker_ = RemoteInvoker<SigIsNoexcept, ReturnType, QualTRef, P...>;
  530|      2|    }
  531|      2|  }
_ZN4absl12lts_2026052622internal_any_invocable8CoreImplILb0ENSt3__110unique_ptrIN8fuzztest8internal14FuzzTestFuzzerENS3_14default_deleteIS7_EEEEJRKNS6_8FuzzTestEEE23InitializeRemoteManagerIZNS6_17RegistrationToken24GetFuzzTestFuzzerFactoryINS6_27RegistrationWithDomainsBaseIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEENS6_9NoFixtureEPFvNS3_17basic_string_viewIcSL_EEEPvEENS0_12AnyInvocableIKFSA_SD_EEEONS6_12RegistrationIT0_T1_T_T2_EEEUlSD_E_JS16_EEEvDpOT0_:
  534|      2|  void InitializeRemoteManager(Args&&... args) {
  535|       |    if constexpr (std::is_trivially_destructible_v<T> &&
  536|       |                  alignof(T) <= ABSL_INTERNAL_DEFAULT_NEW_ALIGNMENT) {
  537|       |      // unique_ptr is used for exception-safety in case construction throws.
  538|       |      std::unique_ptr<void, TrivialDeleter> uninitialized_target(
  539|       |          ::operator new(sizeof(T)), TrivialDeleter(sizeof(T)));
  540|       |      ::new (uninitialized_target.get()) T(std::forward<Args>(args)...);
  541|       |      state_.remote.target = uninitialized_target.release();
  542|       |      state_.remote.size = sizeof(T);
  543|       |      manager_ = RemoteManagerTrivial;
  544|      2|    } else {
  545|      2|      state_.remote.target = ::new T(std::forward<Args>(args)...);
  546|      2|      manager_ = RemoteManagerNontrivial<T>;
  547|      2|    }
  548|      2|  }
_ZN4absl12lts_2026052622internal_any_invocable23RemoteManagerNontrivialIZN8fuzztest8internal17RegistrationToken24GetFuzzTestFuzzerFactoryINS4_27RegistrationWithDomainsBaseIJNSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEEEEENS4_9NoFixtureEPFvNS8_17basic_string_viewIcSB_EEEPvEENS0_12AnyInvocableIKFNS8_10unique_ptrINS4_14FuzzTestFuzzerENS8_14default_deleteISO_EEEERKNS4_8FuzzTestEEEEONS4_12RegistrationIT0_T1_T_T2_EEEUlSU_E_EEvNS1_14FunctionToCallEPNS1_15TypeErasedStateES17_:
  309|      4|                             TypeErasedState* const to) noexcept {
  310|      4|  static_assert(!IsStoredLocally<T>(),
  311|      4|                "Remote storage must only be used for types that do not "
  312|      4|                "qualify for local storage.");
  313|       |
  314|      4|  switch (operation) {
  ------------------
  |  Branch (314:11): [True: 4, False: 0]
  ------------------
  315|      4|    case FunctionToCall::relocate_from_to:
  ------------------
  |  Branch (315:5): [True: 4, False: 0]
  ------------------
  316|      4|    case FunctionToCall::relocate_from_to_and_query_rust:
  ------------------
  |  Branch (316:5): [True: 0, False: 4]
  ------------------
  317|       |      // NOTE: Requires that the left-hand operand is already empty.
  318|      4|      to->remote.target = from->remote.target;
  319|      4|      return;
  320|      0|    case FunctionToCall::dispose:
  ------------------
  |  Branch (320:5): [True: 0, False: 4]
  ------------------
  321|      0|      ::delete static_cast<T*>(from->remote.target);  // Must not throw.
  322|      0|      return;
  323|      4|  }
  324|      0|  ABSL_UNREACHABLE();
  ------------------
  |  |  237|      0|  do {                                           \
  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  ------------------
  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  ------------------
  |  |  241|      0|  } while (false)
  |  |  ------------------
  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  325|      0|}
_ZN4absl12lts_2026052622internal_any_invocable13RemoteInvokerILb0ENSt3__110unique_ptrIN8fuzztest8internal14FuzzTestFuzzerENS3_14default_deleteIS7_EEEERKZNS6_17RegistrationToken24GetFuzzTestFuzzerFactoryINS6_27RegistrationWithDomainsBaseIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEENS6_9NoFixtureEPFvNS3_17basic_string_viewIcSG_EEEPvEENS0_12AnyInvocableIKFSA_RKNS6_8FuzzTestEEEEONS6_12RegistrationIT0_T1_T_T2_EEEUlSU_E_JSU_EEESY_PNS1_15TypeErasedStateEDpNS1_18ForwardedParameterIT2_E4typeE:
  331|      2|    ForwardedParameterType<P>... args) noexcept(SigIsNoexcept) {
  332|      2|  using RawT = RemoveCVRef<QualTRef>;
  333|      2|  static_assert(!IsStoredLocally<RawT>(),
  334|      2|                "Target object must be in remote storage in order to be "
  335|      2|                "invoked from it.");
  336|       |
  337|      2|  auto& f = *static_cast<RawT*>(state->remote.target);
  338|      2|  return (InvokeR<ReturnType>)(static_cast<QualTRef>(f),
  339|      2|                               static_cast<ForwardedParameterType<P>>(args)...);
  340|      2|}
_ZN4absl12lts_2026052622internal_any_invocable7InvokeRINSt3__110unique_ptrIN8fuzztest8internal14FuzzTestFuzzerENS3_14default_deleteIS7_EEEERKZNS6_17RegistrationToken24GetFuzzTestFuzzerFactoryINS6_27RegistrationWithDomainsBaseIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEENS6_9NoFixtureEPFvNS3_17basic_string_viewIcSG_EEEPvEENS0_12AnyInvocableIKFSA_RKNS6_8FuzzTestEEEEONS6_12RegistrationIT0_T1_T_T2_EEEUlSU_E_JSU_EEES10_OSY_DpOT1_:
  119|      2|ReturnType InvokeR(F&& f, P&&... args) {
  120|       |  if constexpr (std::is_void_v<ReturnType>) {
  121|       |    std::invoke(std::forward<F>(f), std::forward<P>(args)...);
  122|      2|  } else {
  123|      2|    return std::invoke(std::forward<F>(f), std::forward<P>(args)...);
  124|      2|  }
  125|      2|}
_ZN4absl12lts_2026052622internal_any_invocable8CoreImplILb0ENSt3__110unique_ptrIN8fuzztest8internal14FuzzTestFuzzerENS3_14default_deleteIS7_EEEEJRKNS6_8FuzzTestEEED2Ev:
  499|      4|  ~CoreImpl() { manager_(FunctionToCall::dispose, &state_, &state_); }
_ZN4absl12lts_2026052622internal_any_invocable12EmptyManagerENS1_14FunctionToCallEPNS1_15TypeErasedStateES4_:
  213|      4|                         TypeErasedState* /*to*/) noexcept {}
_ZN4absl12lts_2026052622internal_any_invocable19LocalManagerTrivialENS1_14FunctionToCallEPNS1_15TypeErasedStateES4_:
  219|  1.13k|                                TypeErasedState* const to) noexcept {
  220|       |  // This single statement without branching handles both possible operations.
  221|       |  //
  222|       |  // For FunctionToCall::dispose, "from" and "to" point to the same state, and
  223|       |  // so this assignment logically would do nothing.
  224|       |  //
  225|       |  // Note: Correctness here relies on http://wg21.link/p0593, which has only
  226|       |  // become standard in C++20, though implementations do not break it in
  227|       |  // practice for earlier versions of C++.
  228|       |  //
  229|       |  // The correct way to do this without that paper is to first placement-new a
  230|       |  // default-constructed T in "to->storage" prior to the memmove, but doing so
  231|       |  // requires a different function to be created for each T that is stored
  232|       |  // locally, which can cause unnecessary bloat and be less cache friendly.
  233|  1.13k|  *to = *from;
  234|       |
  235|       |  // Note: Because the type is trivially copyable, the destructor does not need
  236|       |  // to be called ("trivially copyable" requires a trivial destructor).
  237|  1.13k|}
_ZNK4absl12lts_2026052622internal_any_invocable4ImplIKFNSt3__110unique_ptrIN8fuzztest8internal14FuzzTestFuzzerENS3_14default_deleteIS7_EEEERKNS6_8FuzzTestEEE14ExtractInvokerEv:
  736|      2|    InvokerType<noex, ReturnType, P...>* ExtractInvoker() cv {                 \
  737|      2|      using QualifiedTestType = int cv ref;                                    \
  738|      2|      auto* invoker = this->invoker_;                                          \
  739|      2|      if (!std::is_const<QualifiedTestType>::value &&                          \
  ------------------
  |  Branch (739:11): [Folded, False: 2]
  ------------------
  740|      2|          std::is_rvalue_reference<QualifiedTestType>::value) {                \
  ------------------
  |  Branch (740:11): [Folded, False: 0]
  ------------------
  741|      0|        ABSL_ASSERT([this]() {                                                 \
  ------------------
  |  |  127|      0|#define ABSL_ASSERT(expr) ABSL_INTERNAL_UNEVALUATED((expr) ? void() : void())
  |  |  ------------------
  |  |  |  |   87|      0|#define ABSL_INTERNAL_UNEVALUATED(expr) (false ? (void)(expr) : void())
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (87:42): [Folded, False: 0]
  |  |  |  |  |  Branch (87:57): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  742|      0|          /* We checked that this isn't const above, so const_cast is safe */  \
  743|      0|          const_cast<Impl*>(this)->invoker_ = InvokedAfterMove;                \
  744|      0|          return this->HasValue();                                             \
  745|      0|        }());                                                                  \
  746|      0|      }                                                                        \
  747|      2|      return invoker;                                                          \
  748|      2|    }                                                                          \
_ZN4absl12lts_2026052622internal_any_invocable8CoreImplILb0ENSt3__110unique_ptrIN8fuzztest8internal14FuzzTestFuzzerENS3_14default_deleteIS7_EEEEJRKNS6_8FuzzTestEEEC2EOSE_:
  471|      4|  CoreImpl(CoreImpl&& other) noexcept {
  472|      4|    other.manager_(FunctionToCall::relocate_from_to, &other.state_, &state_);
  473|      4|    manager_ = other.manager_;
  474|      4|    invoker_ = other.invoker_;
  475|      4|    other.manager_ = EmptyManager;
  476|      4|    other.invoker_ = nullptr;
  477|      4|  }
_ZN4absl12lts_2026052622internal_any_invocable8CoreImplILb0EvJEED2Ev:
  499|  1.13k|  ~CoreImpl() { manager_(FunctionToCall::dispose, &state_, &state_); }
compatibility_mode.cc:_ZN4absl12lts_2026052622internal_any_invocable4ImplIFvvOEEC2IZN8fuzztest8internal29FuzzTestExternalEngineAdaptor16RunInFuzzingModeEPiPPPcRKNS7_13ConfigurationEE3$_0EENS1_19ConversionConstructEOT_:
  719|      2|        : Core(TypedConversionConstruct<                                       \
  720|      2|                   typename std::decay<F>::type inv_quals>(),                  \
  721|      2|               std::forward<F>(f)) {}                                          \
compatibility_mode.cc:_ZN4absl12lts_2026052622internal_any_invocable8CoreImplILb0EvJEEC2IOZN8fuzztest8internal29FuzzTestExternalEngineAdaptor16RunInFuzzingModeEPiPPPcRKNS6_13ConfigurationEE3$_0SF_EENS1_24TypedConversionConstructIT_EEOT0_:
  417|      2|  explicit CoreImpl(TypedConversionConstruct<QualDecayedTRef>, F&& f) {
  418|      2|    using DecayedT = RemoveCVRef<QualDecayedTRef>;
  419|       |
  420|       |    if constexpr (std::is_pointer<DecayedT>::value ||
  421|       |                  std::is_member_pointer<DecayedT>::value) {
  422|       |      // This condition handles types that decay into pointers. This includes
  423|       |      // function references, which cannot be null. GCC warns against comparing
  424|       |      // their decayed form with nullptr (https://godbolt.org/z/9r9TMTcPK).
  425|       |      // We could work around this warning with constexpr programming, using
  426|       |      // std::is_function_v<std::remove_reference_t<F>>, but we choose to ignore
  427|       |      // it instead of writing more code.
  428|       |#if !defined(__clang__) && defined(__GNUC__)
  429|       |#pragma GCC diagnostic push
  430|       |#pragma GCC diagnostic ignored "-Wpragmas"
  431|       |#pragma GCC diagnostic ignored "-Waddress"
  432|       |#pragma GCC diagnostic ignored "-Wnonnull-compare"
  433|       |#endif
  434|       |      if (static_cast<DecayedT>(f) == nullptr) {
  435|       |#if !defined(__clang__) && defined(__GNUC__)
  436|       |#pragma GCC diagnostic pop
  437|       |#endif
  438|       |        manager_ = EmptyManager;
  439|       |        invoker_ = nullptr;
  440|       |      } else {
  441|       |        InitializeStorage<QualDecayedTRef>(std::forward<F>(f));
  442|       |      }
  443|       |    } else if constexpr (IsCompatibleAnyInvocable<DecayedT>::value) {
  444|       |      // In this case we can "steal the guts" of the other AnyInvocable.
  445|       |      f.manager_(FunctionToCall::relocate_from_to, &f.state_, &state_);
  446|       |      manager_ = f.manager_;
  447|       |      invoker_ = f.invoker_;
  448|       |
  449|       |      f.manager_ = EmptyManager;
  450|       |      f.invoker_ = nullptr;
  451|       |    } else if constexpr (IsAnyInvocable<DecayedT>::value) {
  452|       |      if (f.HasValue()) {
  453|       |        InitializeStorage<QualDecayedTRef>(std::forward<F>(f));
  454|       |      } else {
  455|       |        manager_ = EmptyManager;
  456|       |        invoker_ = nullptr;
  457|       |      }
  458|      2|    } else {
  459|      2|      InitializeStorage<QualDecayedTRef>(std::forward<F>(f));
  460|      2|    }
  461|      2|  }
compatibility_mode.cc:_ZN4absl12lts_2026052622internal_any_invocable8CoreImplILb0EvJEE17InitializeStorageIOZN8fuzztest8internal29FuzzTestExternalEngineAdaptor16RunInFuzzingModeEPiPPPcRKNS6_13ConfigurationEE3$_0JSF_EEEvDpOT0_:
  513|      2|  void InitializeStorage(Args&&... args) {
  514|      2|    using RawT = RemoveCVRef<QualTRef>;
  515|      2|    if constexpr (IsStoredLocally<RawT>()) {
  516|      2|      ::new (static_cast<void*>(&state_.storage))
  517|      2|          RawT(std::forward<Args>(args)...);
  518|      2|      invoker_ = LocalInvoker<SigIsNoexcept, ReturnType, QualTRef, P...>;
  519|       |      // We can simplify our manager if we know the type is trivially copyable.
  520|      2|      if constexpr (std::is_trivially_copyable_v<RawT>) {
  521|      2|        manager_ = LocalManagerTrivial;
  522|       |      } else {
  523|       |        manager_ = LocalManagerNontrivial<RawT>;
  524|       |      }
  525|       |    } else {
  526|       |      InitializeRemoteManager<RawT>(std::forward<Args>(args)...);
  527|       |      // This is set after everything else in case an exception is thrown in an
  528|       |      // earlier step of the initialization.
  529|       |      invoker_ = RemoteInvoker<SigIsNoexcept, ReturnType, QualTRef, P...>;
  530|       |    }
  531|      2|  }
compatibility_mode.cc:_ZN4absl12lts_2026052622internal_any_invocable12LocalInvokerILb0EvOZN8fuzztest8internal29FuzzTestExternalEngineAdaptor16RunInFuzzingModeEPiPPPcRKNS4_13ConfigurationEE3$_0JEEET0_PNS1_15TypeErasedStateEDpNS1_18ForwardedParameterIT2_E4typeE:
  271|      2|    ForwardedParameterType<P>... args) noexcept(SigIsNoexcept) {
  272|      2|  using RawT = RemoveCVRef<QualTRef>;
  273|      2|  static_assert(
  274|      2|      IsStoredLocally<RawT>(),
  275|      2|      "Target object must be in local storage in order to be invoked from it.");
  276|       |
  277|      2|  auto& f = (ObjectInLocalStorage<RawT>)(state);
  278|      2|  return (InvokeR<ReturnType>)(static_cast<QualTRef>(f),
  279|      2|                               static_cast<ForwardedParameterType<P>>(args)...);
  280|      2|}
compatibility_mode.cc:_ZN4absl12lts_2026052622internal_any_invocable20ObjectInLocalStorageIZN8fuzztest8internal29FuzzTestExternalEngineAdaptor16RunInFuzzingModeEPiPPPcRKNS4_13ConfigurationEE3$_0EERT_PNS1_15TypeErasedStateE:
  191|      2|T& ObjectInLocalStorage(TypeErasedState* const state) {
  192|       |  // We launder here because the storage may be reused with the same type.
  193|      2|  return *std::launder(reinterpret_cast<T*>(&state->storage));
  194|      2|}
compatibility_mode.cc:_ZN4absl12lts_2026052622internal_any_invocable7InvokeRIvZN8fuzztest8internal29FuzzTestExternalEngineAdaptor16RunInFuzzingModeEPiPPPcRKNS4_13ConfigurationEE3$_0JEEET_OT0_DpOT1_:
  119|      2|ReturnType InvokeR(F&& f, P&&... args) {
  120|      2|  if constexpr (std::is_void_v<ReturnType>) {
  121|      2|    std::invoke(std::forward<F>(f), std::forward<P>(args)...);
  122|       |  } else {
  123|       |    return std::invoke(std::forward<F>(f), std::forward<P>(args)...);
  124|       |  }
  125|      2|}
runtime.cc:_ZN4absl12lts_2026052622internal_any_invocable4ImplIFvvOEEC2IZN8fuzztest8internal18FuzzTestFuzzerImpl11RunOneInputERKNS8_5InputEE3$_0EENS1_19ConversionConstructEOT_:
  719|  1.13k|        : Core(TypedConversionConstruct<                                       \
  720|  1.13k|                   typename std::decay<F>::type inv_quals>(),                  \
  721|  1.13k|               std::forward<F>(f)) {}                                          \
runtime.cc:_ZN4absl12lts_2026052622internal_any_invocable8CoreImplILb0EvJEEC2IOZN8fuzztest8internal18FuzzTestFuzzerImpl11RunOneInputERKNS7_5InputEE3$_0SB_EENS1_24TypedConversionConstructIT_EEOT0_:
  417|  1.13k|  explicit CoreImpl(TypedConversionConstruct<QualDecayedTRef>, F&& f) {
  418|  1.13k|    using DecayedT = RemoveCVRef<QualDecayedTRef>;
  419|       |
  420|       |    if constexpr (std::is_pointer<DecayedT>::value ||
  421|       |                  std::is_member_pointer<DecayedT>::value) {
  422|       |      // This condition handles types that decay into pointers. This includes
  423|       |      // function references, which cannot be null. GCC warns against comparing
  424|       |      // their decayed form with nullptr (https://godbolt.org/z/9r9TMTcPK).
  425|       |      // We could work around this warning with constexpr programming, using
  426|       |      // std::is_function_v<std::remove_reference_t<F>>, but we choose to ignore
  427|       |      // it instead of writing more code.
  428|       |#if !defined(__clang__) && defined(__GNUC__)
  429|       |#pragma GCC diagnostic push
  430|       |#pragma GCC diagnostic ignored "-Wpragmas"
  431|       |#pragma GCC diagnostic ignored "-Waddress"
  432|       |#pragma GCC diagnostic ignored "-Wnonnull-compare"
  433|       |#endif
  434|       |      if (static_cast<DecayedT>(f) == nullptr) {
  435|       |#if !defined(__clang__) && defined(__GNUC__)
  436|       |#pragma GCC diagnostic pop
  437|       |#endif
  438|       |        manager_ = EmptyManager;
  439|       |        invoker_ = nullptr;
  440|       |      } else {
  441|       |        InitializeStorage<QualDecayedTRef>(std::forward<F>(f));
  442|       |      }
  443|       |    } else if constexpr (IsCompatibleAnyInvocable<DecayedT>::value) {
  444|       |      // In this case we can "steal the guts" of the other AnyInvocable.
  445|       |      f.manager_(FunctionToCall::relocate_from_to, &f.state_, &state_);
  446|       |      manager_ = f.manager_;
  447|       |      invoker_ = f.invoker_;
  448|       |
  449|       |      f.manager_ = EmptyManager;
  450|       |      f.invoker_ = nullptr;
  451|       |    } else if constexpr (IsAnyInvocable<DecayedT>::value) {
  452|       |      if (f.HasValue()) {
  453|       |        InitializeStorage<QualDecayedTRef>(std::forward<F>(f));
  454|       |      } else {
  455|       |        manager_ = EmptyManager;
  456|       |        invoker_ = nullptr;
  457|       |      }
  458|  1.13k|    } else {
  459|  1.13k|      InitializeStorage<QualDecayedTRef>(std::forward<F>(f));
  460|  1.13k|    }
  461|  1.13k|  }
runtime.cc:_ZN4absl12lts_2026052622internal_any_invocable8CoreImplILb0EvJEE17InitializeStorageIOZN8fuzztest8internal18FuzzTestFuzzerImpl11RunOneInputERKNS7_5InputEE3$_0JSB_EEEvDpOT0_:
  513|  1.13k|  void InitializeStorage(Args&&... args) {
  514|  1.13k|    using RawT = RemoveCVRef<QualTRef>;
  515|  1.13k|    if constexpr (IsStoredLocally<RawT>()) {
  516|  1.13k|      ::new (static_cast<void*>(&state_.storage))
  517|  1.13k|          RawT(std::forward<Args>(args)...);
  518|  1.13k|      invoker_ = LocalInvoker<SigIsNoexcept, ReturnType, QualTRef, P...>;
  519|       |      // We can simplify our manager if we know the type is trivially copyable.
  520|  1.13k|      if constexpr (std::is_trivially_copyable_v<RawT>) {
  521|  1.13k|        manager_ = LocalManagerTrivial;
  522|       |      } else {
  523|       |        manager_ = LocalManagerNontrivial<RawT>;
  524|       |      }
  525|       |    } else {
  526|       |      InitializeRemoteManager<RawT>(std::forward<Args>(args)...);
  527|       |      // This is set after everything else in case an exception is thrown in an
  528|       |      // earlier step of the initialization.
  529|       |      invoker_ = RemoteInvoker<SigIsNoexcept, ReturnType, QualTRef, P...>;
  530|       |    }
  531|  1.13k|  }
runtime.cc:_ZN4absl12lts_2026052622internal_any_invocable12LocalInvokerILb0EvOZN8fuzztest8internal18FuzzTestFuzzerImpl11RunOneInputERKNS5_5InputEE3$_0JEEET0_PNS1_15TypeErasedStateEDpNS1_18ForwardedParameterIT2_E4typeE:
  271|  1.13k|    ForwardedParameterType<P>... args) noexcept(SigIsNoexcept) {
  272|  1.13k|  using RawT = RemoveCVRef<QualTRef>;
  273|  1.13k|  static_assert(
  274|  1.13k|      IsStoredLocally<RawT>(),
  275|  1.13k|      "Target object must be in local storage in order to be invoked from it.");
  276|       |
  277|  1.13k|  auto& f = (ObjectInLocalStorage<RawT>)(state);
  278|  1.13k|  return (InvokeR<ReturnType>)(static_cast<QualTRef>(f),
  279|  1.13k|                               static_cast<ForwardedParameterType<P>>(args)...);
  280|  1.13k|}
runtime.cc:_ZN4absl12lts_2026052622internal_any_invocable20ObjectInLocalStorageIZN8fuzztest8internal18FuzzTestFuzzerImpl11RunOneInputERKNS5_5InputEE3$_0EERT_PNS1_15TypeErasedStateE:
  191|  1.13k|T& ObjectInLocalStorage(TypeErasedState* const state) {
  192|       |  // We launder here because the storage may be reused with the same type.
  193|  1.13k|  return *std::launder(reinterpret_cast<T*>(&state->storage));
  194|  1.13k|}
runtime.cc:_ZN4absl12lts_2026052622internal_any_invocable7InvokeRIvZN8fuzztest8internal18FuzzTestFuzzerImpl11RunOneInputERKNS5_5InputEE3$_0JEEET_OT0_DpOT1_:
  119|  1.13k|ReturnType InvokeR(F&& f, P&&... args) {
  120|  1.13k|  if constexpr (std::is_void_v<ReturnType>) {
  121|  1.13k|    std::invoke(std::forward<F>(f), std::forward<P>(args)...);
  122|       |  } else {
  123|       |    return std::invoke(std::forward<F>(f), std::forward<P>(args)...);
  124|       |  }
  125|  1.13k|}
_ZN4absl12lts_2026052622internal_any_invocable4ImplIFvvOEE14ExtractInvokerEv:
  736|  1.13k|    InvokerType<noex, ReturnType, P...>* ExtractInvoker() cv {                 \
  737|  1.13k|      using QualifiedTestType = int cv ref;                                    \
  738|  1.13k|      auto* invoker = this->invoker_;                                          \
  739|  1.13k|      if (!std::is_const<QualifiedTestType>::value &&                          \
  ------------------
  |  Branch (739:11): [True: 0, Folded]
  ------------------
  740|  1.13k|          std::is_rvalue_reference<QualifiedTestType>::value) {                \
  ------------------
  |  Branch (740:11): [True: 0, Folded]
  ------------------
  741|  1.13k|        ABSL_ASSERT([this]() {                                                 \
  ------------------
  |  |  127|  1.13k|#define ABSL_ASSERT(expr) ABSL_INTERNAL_UNEVALUATED((expr) ? void() : void())
  |  |  ------------------
  |  |  |  |   87|  1.13k|#define ABSL_INTERNAL_UNEVALUATED(expr) (false ? (void)(expr) : void())
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (87:42): [Folded, False: 1.13k]
  |  |  |  |  |  Branch (87:57): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  742|  1.13k|          /* We checked that this isn't const above, so const_cast is safe */  \
  743|  1.13k|          const_cast<Impl*>(this)->invoker_ = InvokedAfterMove;                \
  744|  1.13k|          return this->HasValue();                                             \
  745|  1.13k|        }());                                                                  \
  746|  1.13k|      }                                                                        \
  747|  1.13k|      return invoker;                                                          \
  748|  1.13k|    }                                                                          \

init_fuzztest.cc:_ZN4absl12lts_2026052619functional_internal12InvokeObjectIRZN8fuzztest19ListRegisteredTestsEvE3$_0vJRNS3_8internal8FuzzTestEEEET0_NS1_7VoidPtrEDpNS1_8ForwardTIT1_E4typeE:
   74|      6|R InvokeObject(VoidPtr ptr, typename ForwardT<Args>::type... args) {
   75|      6|  using T = std::remove_reference_t<Obj>;
   76|      6|  return static_cast<R>(std::invoke(
   77|      6|      std::forward<Obj>(*const_cast<T*>(static_cast<const T*>(ptr.obj))),
   78|      6|      std::forward<typename ForwardT<Args>::type>(args)...));
   79|      6|}
init_fuzztest.cc:_ZN4absl12lts_2026052619functional_internal13AssertNonNullIZN8fuzztest19ListRegisteredTestsEvE3$_0EEvRKT_:
  136|      6|void AssertNonNull(const F&) {}
_ZN4absl12lts_2026052619functional_internal12InvokeObjectIRNS0_18container_internal7HashKeyINS3_10StringHashENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEELb1EEEmJmEEET0_NS1_7VoidPtrEDpNS1_8ForwardTIT1_E4typeE:
   74|      2|R InvokeObject(VoidPtr ptr, typename ForwardT<Args>::type... args) {
   75|      2|  using T = std::remove_reference_t<Obj>;
   76|      2|  return static_cast<R>(std::invoke(
   77|      2|      std::forward<Obj>(*const_cast<T*>(static_cast<const T*>(ptr.obj))),
   78|      2|      std::forward<typename ForwardT<Args>::type>(args)...));
   79|      2|}
_ZN4absl12lts_2026052619functional_internal13AssertNonNullINS0_18container_internal7HashKeyINS3_10StringHashENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEELb1EEEEEvRKT_:
  136|      4|void AssertNonNull(const F&) {}
googletest_adaptor.cc:_ZN4absl12lts_2026052619functional_internal12InvokeObjectIRZN8fuzztest8internal30RegisterFuzzTestsAsGoogleTestsEPiPPPcRKNS4_13ConfigurationEE3$_0vJRNS4_8FuzzTestEEEET0_NS1_7VoidPtrEDpNS1_8ForwardTIT1_E4typeE:
   74|      2|R InvokeObject(VoidPtr ptr, typename ForwardT<Args>::type... args) {
   75|      2|  using T = std::remove_reference_t<Obj>;
   76|      2|  return static_cast<R>(std::invoke(
   77|      2|      std::forward<Obj>(*const_cast<T*>(static_cast<const T*>(ptr.obj))),
   78|      2|      std::forward<typename ForwardT<Args>::type>(args)...));
   79|      2|}
googletest_adaptor.cc:_ZN4absl12lts_2026052619functional_internal13AssertNonNullIZN8fuzztest8internal30RegisterFuzzTestsAsGoogleTestsEPiPPPcRKNS4_13ConfigurationEE3$_0EEvRKT_:
  136|      2|void AssertNonNull(const F&) {}

_ZN4absl12lts_2026052613hash_internal43CombineLargeContiguousImplOn64BitLengthGt32EmPKhm:
  417|      8|                                                     size_t len) {
  418|      8|  assert(len > 32);
  419|      8|  assert(sizeof(size_t) == 8);  // NOLINT(misc-static-assert)
  420|      8|  if (ABSL_PREDICT_TRUE(len <= PiecewiseChunkSize())) {
  ------------------
  |  |  191|      8|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 8, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 8]
  |  |  |  Branch (191:57): [True: 8, False: 0]
  |  |  ------------------
  ------------------
  421|      8|    return HashBlockOn64Bit(state, first, len);
  422|      8|  }
  423|      0|  return SplitAndCombineOn64Bit(state, first, len);
  424|      8|}
hash.cc:_ZN4absl12lts_2026052613hash_internal12_GLOBAL__N_116HashBlockOn64BitEmPKhm:
  376|      8|    uint64_t state, const unsigned char* data, size_t len) {
  377|      8|#ifdef ABSL_HAVE_INTRINSIC_INT128
  378|      8|  return LowLevelHashLenGt32(state, data, len);
  379|       |#else
  380|       |  return hash_internal::CityHash64WithSeed(reinterpret_cast<const char*>(data),
  381|       |                                           len, state);
  382|       |#endif
  383|      8|}
hash.cc:_ZN4absl12lts_2026052613hash_internal12_GLOBAL__N_119LowLevelHashLenGt32EmPKvm:
  341|      8|                                              size_t len) {
  342|      8|  assert(len > 32);
  343|      8|  if (ABSL_PREDICT_FALSE(len > 64)) {
  ------------------
  |  |  190|      8|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 8]
  |  |  |  Branch (190:49): [Folded, False: 8]
  |  |  |  Branch (190:58): [True: 0, False: 8]
  |  |  ------------------
  ------------------
  344|      0|    return LowLevelHashLenGt64(seed, data, len);
  345|      0|  }
  346|      8|  return LowLevelHash33To64(seed, static_cast<const uint8_t*>(data), len);
  347|      8|}
hash.cc:_ZN4absl12lts_2026052613hash_internal12_GLOBAL__N_110Mix32BytesEPKhm:
  271|     16|uint64_t Mix32Bytes(const uint8_t* ptr, uint64_t current_state) {
  272|     16|  uint64_t a = absl::base_internal::UnalignedLoad64(ptr);
  273|     16|  uint64_t b = absl::base_internal::UnalignedLoad64(ptr + 8);
  274|     16|  uint64_t c = absl::base_internal::UnalignedLoad64(ptr + 16);
  275|     16|  uint64_t d = absl::base_internal::UnalignedLoad64(ptr + 24);
  276|       |
  277|     16|  uint64_t cs0 = Mix(a ^ kStaticRandomData[1], b ^ current_state);
  278|     16|  uint64_t cs1 = Mix(c ^ kStaticRandomData[2], d ^ current_state);
  279|     16|  return cs0 ^ cs1;
  280|     16|}
hash.cc:_ZN4absl12lts_2026052613hash_internal12_GLOBAL__N_118LowLevelHash33To64EmPKhm:
  282|      8|uint64_t LowLevelHash33To64(uint64_t seed, const uint8_t* ptr, size_t len) {
  283|      8|  assert(len > 32);
  284|       |  assert(len <= 64);
  285|      8|  uint64_t current_state = seed ^ kStaticRandomData[0] ^ len;
  286|      8|  const uint8_t* last_32_ptr = ptr + len - 32;
  287|      8|  return Mix32Bytes(last_32_ptr, Mix32Bytes(ptr, current_state));
  288|      8|}

_ZN4absl12lts_2026052613hash_internal13HashStateBaseINS1_15MixingHashStateEE7combineES3_:
  299|     78|  static H combine(H state) { return state; }
_ZN4absl12lts_2026052613hash_internal13AbslHashValueINS1_15MixingHashStateEEET_S4_NSt3__117basic_string_viewIcNS5_11char_traitsIcEEEE:
  661|     78|H AbslHashValue(H hash_state, absl::string_view str) {
  662|     78|  return H::combine_contiguous(std::move(hash_state), str.data(), str.size());
  663|     78|}
_ZN4absl12lts_2026052613hash_internal13HashStateBaseINS1_15MixingHashStateEE18combine_contiguousIcEES3_S3_PKT_m:
 1556|     78|H HashStateBase<H>::combine_contiguous(H state, const T* data, size_t size) {
 1557|     78|  return hash_internal::hash_range_or_bytes(std::move(state), data, size);
 1558|     78|}
_ZN4absl12lts_2026052613hash_internal19hash_range_or_bytesINS1_15MixingHashStateEcEENSt3__19enable_ifIXsr23is_uniquely_representedIT0_EE5valueET_E4typeES7_PKS6_m:
  978|     78|hash_range_or_bytes(H hash_state, const T* data, size_t size) {
  979|     78|  const auto* bytes = reinterpret_cast<const unsigned char*>(data);
  980|     78|  return H::combine_contiguous(std::move(hash_state), bytes, sizeof(T) * size);
  981|     78|}
_ZN4absl12lts_2026052613hash_internal15MixingHashState18combine_contiguousES2_PKhm:
 1399|     78|                                            size_t size) {
 1400|     78|    return MixingHashState(
 1401|     78|        CombineContiguousImpl(hash_state.state_, first, size,
 1402|     78|                              std::integral_constant<int, sizeof(size_t)>{}));
 1403|     78|  }
_ZN4absl12lts_2026052613hash_internal21CombineContiguousImplEmPKhmNSt3__117integral_constantIiLi8EEE:
 1260|     78|    std::integral_constant<int, 8> /* sizeof_size_t */) {
 1261|       |  // For large values we use LowLevelHash or CityHash depending on the platform,
 1262|       |  // for small ones we use custom low latency hash.
 1263|     78|  if (len <= 8) {
  ------------------
  |  Branch (1263:7): [True: 20, False: 58]
  ------------------
 1264|     20|    return CombineSmallContiguousImpl(PrecombineLengthMix(state, len), first,
 1265|     20|                                      len);
 1266|     20|  }
 1267|     58|  if (len <= 16) {
  ------------------
  |  Branch (1267:7): [True: 30, False: 28]
  ------------------
 1268|     30|    return CombineContiguousImpl9to16(PrecombineLengthMix(state, len), first,
 1269|     30|                                      len);
 1270|     30|  }
 1271|     28|  if (len <= 32) {
  ------------------
  |  Branch (1271:7): [True: 20, False: 8]
  ------------------
 1272|     20|    return CombineContiguousImpl17to32(PrecombineLengthMix(state, len), first,
 1273|     20|                                       len);
 1274|     20|  }
 1275|       |  // We must not mix length into the state here because calling
 1276|       |  // CombineContiguousImpl twice with PiecewiseChunkSize() must be equivalent
 1277|       |  // to calling CombineLargeContiguousImpl once with 2 * PiecewiseChunkSize().
 1278|      8|  return CombineLargeContiguousImplOn64BitLengthGt32(state, first, len);
 1279|     28|}
_ZN4absl12lts_2026052613hash_internal26CombineSmallContiguousImplEmPKhm:
 1136|     20|    uint64_t state, const unsigned char* first, size_t len) {
 1137|     20|  ABSL_ASSUME(len <= 8);
  ------------------
  |  |  271|     20|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1138|     20|  uint64_t v;
 1139|     20|  if (len >= 4) {
  ------------------
  |  Branch (1139:7): [True: 20, False: 0]
  ------------------
 1140|     20|    v = Read4To8(first, len);
 1141|     20|  } else if (len > 0) {
  ------------------
  |  Branch (1141:14): [True: 0, False: 0]
  ------------------
 1142|      0|    v = Read1To3(first, len);
 1143|      0|  } else {
 1144|       |    // Empty string must modify the state.
 1145|      0|    v = 0x57;
 1146|      0|  }
 1147|     20|  return CombineRawImpl(state, v);
 1148|     20|}
_ZN4absl12lts_2026052613hash_internal8Read4To8EPKhm:
 1045|     20|inline uint64_t Read4To8(const unsigned char* p, size_t len) {
 1046|       |  // If `len < 8`, we duplicate bytes. We always put low memory at the end.
 1047|       |  // E.g., on little endian platforms:
 1048|       |  // `ABCD` will be read as `ABCDABCD`.
 1049|       |  // `ABCDE` will be read as `BCDEABCD`.
 1050|       |  // `ABCDEF` will be read as `CDEFABCD`.
 1051|       |  // `ABCDEFG` will be read as `DEFGABCD`.
 1052|       |  // `ABCDEFGH` will be read as `EFGHABCD`.
 1053|       |  // We also do not care about endianness. On big-endian platforms, bytes will
 1054|       |  // be permuted differently. We always shift low memory by 32, because that
 1055|       |  // can be pipelined earlier. Reading high memory requires computing
 1056|       |  // `p + len - 4`.
 1057|     20|  uint64_t most_significant =
 1058|     20|      static_cast<uint64_t>(absl::base_internal::UnalignedLoad32(p)) << 32;
 1059|     20|  uint64_t least_significant =
 1060|     20|      absl::base_internal::UnalignedLoad32(p + len - 4);
 1061|     20|  return most_significant | least_significant;
 1062|     20|}
_ZN4absl12lts_2026052613hash_internal14CombineRawImplEmm:
 1120|     20|                                                            uint64_t value) {
 1121|     20|  return Mix(state ^ value, kMul);
 1122|     20|}
_ZN4absl12lts_2026052613hash_internal3MixEmm:
 1012|    122|ABSL_ATTRIBUTE_ALWAYS_INLINE inline uint64_t Mix(uint64_t lhs, uint64_t rhs) {
 1013|       |  // Though the 128-bit product needs multiple instructions on non-x86-64
 1014|       |  // platforms, it is still a good balance between speed and hash quality.
 1015|    122|  absl::uint128 m = lhs;
 1016|    122|  m *= rhs;
 1017|    122|  return Uint128High64(m) ^ Uint128Low64(m);
 1018|    122|}
_ZN4absl12lts_2026052613hash_internal19PrecombineLengthMixEmm:
 1005|     70|inline uint64_t PrecombineLengthMix(uint64_t state, size_t len) {
 1006|     70|  ABSL_ASSUME(len + sizeof(uint64_t) <= sizeof(kStaticRandomData));
  ------------------
  |  |  271|     70|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1007|     70|  uint64_t data = absl::base_internal::UnalignedLoad64(
 1008|     70|      reinterpret_cast<const unsigned char*>(&kStaticRandomData[0]) + len);
 1009|     70|  return state ^ data;
 1010|     70|}
_ZN4absl12lts_2026052613hash_internal26CombineContiguousImpl9to16EmPKhm:
 1151|     30|    uint64_t state, const unsigned char* first, size_t len) {
 1152|     30|  ABSL_ASSUME(len >= 9);
  ------------------
  |  |  271|     30|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1153|     30|  ABSL_ASSUME(len <= 16);
  ------------------
  |  |  271|     30|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1154|       |  // Note: any time one half of the mix function becomes zero it will fail to
 1155|       |  // incorporate any bits from the other half. However, there is exactly 1 in
 1156|       |  // 2^64 values for each side that achieve this, and only when the size is
 1157|       |  // exactly 16 -- for smaller sizes there is an overlapping byte that makes
 1158|       |  // this impossible unless the seed is *also* incredibly unlucky.
 1159|     30|  auto p = Read9To16(first, len);
 1160|     30|  return Mix(state ^ p.first, kMul ^ p.second);
 1161|     30|}
_ZN4absl12lts_2026052613hash_internal9Read9To16EPKhm:
 1039|     30|                                               size_t len) {
 1040|     30|  return {Read8(p), Read8(p + len - 8)};
 1041|     30|}
_ZN4absl12lts_2026052613hash_internal5Read8EPKh:
 1028|    140|inline uint64_t Read8(const unsigned char* p) {
 1029|    140|  return absl::base_internal::UnalignedLoad64(p);
 1030|    140|}
_ZN4absl12lts_2026052613hash_internal27CombineContiguousImpl17to32EmPKhm:
 1164|     20|    uint64_t state, const unsigned char* first, size_t len) {
 1165|     20|  ABSL_ASSUME(len >= 17);
  ------------------
  |  |  271|     20|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1166|     20|  ABSL_ASSUME(len <= 32);
  ------------------
  |  |  271|     20|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1167|       |  // Do two mixes of overlapping 16-byte ranges in parallel to minimize
 1168|       |  // latency.
 1169|     20|  const uint64_t m0 =
 1170|     20|      Mix(Read8(first) ^ kStaticRandomData[1], Read8(first + 8) ^ state);
 1171|       |
 1172|     20|  const unsigned char* tail_16b_ptr = first + (len - 16);
 1173|     20|  const uint64_t m1 = Mix(Read8(tail_16b_ptr) ^ kStaticRandomData[3],
 1174|     20|                          Read8(tail_16b_ptr + 8) ^ state);
 1175|     20|  return m0 ^ m1;
 1176|     20|}
_ZN4absl12lts_2026052613hash_internal15MixingHashStateC2Em:
 1450|    156|  explicit MixingHashState(uint64_t state) : state_(state) {}
_ZN4absl12lts_2026052613hash_internal18PiecewiseChunkSizeEv:
  157|      8|constexpr size_t PiecewiseChunkSize() { return 1024; }
_ZN4absl12lts_2026052613hash_internal15MixingHashState14hash_with_seedINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEETnNS4_9enable_ifIXntsr16IntegralFastPathIT_EE5valueEiE4typeELi0EEEmRKSA_m:
 1423|     78|  static size_t hash_with_seed(const T& value, size_t seed) {
 1424|     78|    return static_cast<size_t>(combine(MixingHashState{seed}, value).state_);
 1425|     78|  }
_ZN4absl12lts_2026052613hash_internal13HashStateBaseINS1_15MixingHashStateEE7combineINSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEJEEES3_S3_RKT_DpRKT0_:
 1548|     78|H HashStateBase<H>::combine(H state, const T& value, const Ts&... values) {
 1549|     78|  return H::combine(hash_internal::HashSelect::template Apply<T>::Invoke(
 1550|     78|                        std::move(state), value),
 1551|     78|                    values...);
 1552|     78|}
_ZN4absl12lts_2026052613hash_internal10HashSelect14HashValueProbe6InvokeINS1_15MixingHashStateENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEEENS6_9enable_ifIXsr3std7is_sameIT_DTcl13AbslHashValueclsr3stdE4movefp_Efp0_EEEE5valueESC_E4typeESC_RKT0_:
 1326|     78|        H> {
 1327|     78|      return AbslHashValue(std::move(state), value);
 1328|     78|    }
_ZNK4absl12lts_2026052613hash_internal12HashWithSeed4hashINS1_4HashINSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEEES9_EEmRKT_RKT0_m:
  412|     78|  size_t hash(const Hasher& hasher, const T& value, size_t seed) const {
  413|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  414|     78|    return hasher.hash_with_seed(value, seed);
  415|     78|  }
_ZNK4absl12lts_2026052613hash_internal8HashImplINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEE14hash_with_seedERKS7_m:
 1537|     78|  size_t hash_with_seed(const T& value, size_t seed) const {
 1538|     78|    return MixingHashState::hash_with_seed(value, seed);
 1539|     78|  }
_ZNK4absl12lts_2026052613hash_internal12HashWithSeed4hashINS0_18container_internal10StringHashENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEEEmRKT_RKT0_m:
  412|     78|  size_t hash(const Hasher& hasher, const T& value, size_t seed) const {
  413|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  414|     78|    return hasher.hash_with_seed(value, seed);
  415|     78|  }

_ZN4absl12lts_2026052611countl_zeroImEENSt3__19enable_ifIXsr3std11is_unsignedIT_EE5valueEiE4typeES4_:
  108|  22.5k|    countl_zero(T x) noexcept {
  109|  22.5k|  return numeric_internal::CountLeadingZeroes(x);
  110|  22.5k|}
_ZN4absl12lts_2026052611countr_zeroImEENSt3__19enable_ifIXsr3std11is_unsignedIT_EE5valueEiE4typeES4_:
  123|     12|    countr_zero(T x) noexcept {
  124|     12|  return numeric_internal::CountTrailingZeroes(x);
  125|     12|}
_ZN4absl12lts_2026052611countr_zeroIjEENSt3__19enable_ifIXsr3std11is_unsignedIT_EE5valueEiE4typeES4_:
  123|     72|    countr_zero(T x) noexcept {
  124|     72|  return numeric_internal::CountTrailingZeroes(x);
  125|     72|}
_ZN4absl12lts_202605269bit_widthImEENSt3__19enable_ifIXsr3std11is_unsignedIT_EE5valueEiE4typeES4_:
  165|  4.51k|    bit_width(T x) noexcept {
  166|  4.51k|  return std::numeric_limits<T>::digits - countl_zero(x);
  167|  4.51k|}

_ZN4absl12lts_20260526mlENS0_7uint128ES1_:
 1059|  20.7k|constexpr uint128 operator*(uint128 lhs, uint128 rhs) {
 1060|       |  // TODO(strel) Remove once alignment issues are resolved and unsigned __int128
 1061|       |  // can be used for uint128 storage.
 1062|  20.7k|  return static_cast<unsigned __int128>(lhs) *
 1063|  20.7k|         static_cast<unsigned __int128>(rhs);
 1064|  20.7k|}
_ZNK4absl12lts_202605267uint128cvoEv:
  794|   247k|constexpr uint128::operator unsigned __int128() const {
  795|   247k|  return (static_cast<unsigned __int128>(hi_) << 64) + lo_;
  796|   247k|}
_ZN4absl12lts_202605267uint128C2Eo:
  692|   113k|    : lo_{static_cast<uint64_t>(v & ~uint64_t{0})},
  693|   113k|      hi_{static_cast<uint64_t>(v >> 64)} {}
_ZN4absl12lts_202605267uint128C2Em:
  683|  47.7k|constexpr uint128::uint128(unsigned long v) : lo_{v}, hi_{0} {}
_ZNK4absl12lts_202605267uint128cvmEv:
  777|  15.2k|constexpr uint128::operator unsigned long() const {  // NOLINT(runtime/int)
  778|  15.2k|  return static_cast<unsigned long>(lo_);            // NOLINT(runtime/int)
  779|  15.2k|}
_ZN4absl12lts_20260526rsENS0_7uint128Ei:
  974|  24.0k|constexpr uint128 operator>>(uint128 lhs, int amount) {
  975|  24.0k|#ifdef ABSL_HAVE_INTRINSIC_INT128
  976|  24.0k|  return static_cast<unsigned __int128>(lhs) >> amount;
  977|       |#else
  978|       |  // uint64_t shifts of >= 64 are undefined, so we will need some
  979|       |  // special-casing.
  980|       |  return amount >= 64  ? MakeUint128(0, Uint128High64(lhs) >> (amount - 64))
  981|       |         : amount == 0 ? lhs
  982|       |                       : MakeUint128(Uint128High64(lhs) >> amount,
  983|       |                                     (Uint128Low64(lhs) >> amount) |
  984|       |                                         (Uint128High64(lhs) << (64 - amount)));
  985|       |#endif
  986|  24.0k|}
_ZN4absl12lts_202605267uint128mLES1_:
  646|  11.6k|inline uint128& uint128::operator*=(uint128 other) {
  647|  11.6k|  *this = *this * other;
  648|  11.6k|  return *this;
  649|  11.6k|}
_ZN4absl12lts_2026052613Uint128High64ENS0_7uint128E:
  663|  49.6k|constexpr uint64_t Uint128High64(uint128 v) { return v.hi_; }
_ZN4absl12lts_2026052612Uint128Low64ENS0_7uint128E:
  661|  11.6k|constexpr uint64_t Uint128Low64(uint128 v) { return v.lo_; }
_ZN4absl12lts_202605267uint128rSEi:
  631|  24.0k|inline uint128& uint128::operator>>=(int amount) {
  632|  24.0k|  *this = *this >> amount;
  633|  24.0k|  return *this;
  634|  24.0k|}
_ZN4absl12lts_202605267uint128pLES1_:
  636|  2.74k|inline uint128& uint128::operator+=(uint128 other) {
  637|  2.74k|  *this = *this + other;
  638|  2.74k|  return *this;
  639|  2.74k|}
_ZN4absl12lts_20260526eqENS0_7uint128ES1_:
  820|  22.8k|constexpr bool operator==(uint128 lhs, uint128 rhs) {
  821|  22.8k|#if defined(ABSL_HAVE_INTRINSIC_INT128)
  822|  22.8k|  return static_cast<unsigned __int128>(lhs) ==
  823|  22.8k|         static_cast<unsigned __int128>(rhs);
  824|       |#else
  825|       |  return (Uint128Low64(lhs) == Uint128Low64(rhs) &&
  826|       |          Uint128High64(lhs) == Uint128High64(rhs));
  827|       |#endif
  828|  22.8k|}
_ZN4absl12lts_20260526ltENS0_7uint128ES1_:
  832|  12.9k|constexpr bool operator<(uint128 lhs, uint128 rhs) {
  833|  12.9k|#ifdef ABSL_HAVE_INTRINSIC_INT128
  834|  12.9k|  return static_cast<unsigned __int128>(lhs) <
  835|  12.9k|         static_cast<unsigned __int128>(rhs);
  836|       |#else
  837|       |  return (Uint128High64(lhs) == Uint128High64(rhs))
  838|       |             ? (Uint128Low64(lhs) < Uint128Low64(rhs))
  839|       |             : (Uint128High64(lhs) < Uint128High64(rhs));
  840|       |#endif
  841|  12.9k|}
_ZN4absl12lts_20260526gtENS0_7uint128ES1_:
  843|  12.9k|constexpr bool operator>(uint128 lhs, uint128 rhs) { return rhs < lhs; }
_ZN4absl12lts_20260526anENS0_7uint128ES1_:
  923|  14.1k|constexpr inline uint128 operator&(uint128 lhs, uint128 rhs) {
  924|  14.1k|#if defined(ABSL_HAVE_INTRINSIC_INT128)
  925|  14.1k|  return static_cast<unsigned __int128>(lhs) &
  926|  14.1k|         static_cast<unsigned __int128>(rhs);
  927|       |#else
  928|       |  return MakeUint128(Uint128High64(lhs) & Uint128High64(rhs),
  929|       |                     Uint128Low64(lhs) & Uint128Low64(rhs));
  930|       |#endif
  931|  14.1k|}
_ZN4absl12lts_20260526eoENS0_7uint128ES1_:
  933|      4|constexpr inline uint128 operator^(uint128 lhs, uint128 rhs) {
  934|      4|#if defined(ABSL_HAVE_INTRINSIC_INT128)
  935|      4|  return static_cast<unsigned __int128>(lhs) ^
  936|      4|         static_cast<unsigned __int128>(rhs);
  937|       |#else
  938|       |  return MakeUint128(Uint128High64(lhs) ^ Uint128High64(rhs),
  939|       |                     Uint128Low64(lhs) ^ Uint128Low64(rhs));
  940|       |#endif
  941|      4|}
_ZN4absl12lts_202605267uint128eOES1_:
  953|      4|inline uint128& uint128::operator^=(uint128 other) {
  954|      4|  *this = *this ^ other;
  955|      4|  return *this;
  956|      4|}
_ZN4absl12lts_20260526lsENS0_7uint128Ei:
  960|  28.2k|constexpr uint128 operator<<(uint128 lhs, int amount) {
  961|  28.2k|#ifdef ABSL_HAVE_INTRINSIC_INT128
  962|  28.2k|  return static_cast<unsigned __int128>(lhs) << amount;
  963|       |#else
  964|       |  // uint64_t shifts of >= 64 are undefined, so we will need some
  965|       |  // special-casing.
  966|       |  return amount >= 64  ? MakeUint128(Uint128Low64(lhs) << (amount - 64), 0)
  967|       |         : amount == 0 ? lhs
  968|       |                       : MakeUint128((Uint128High64(lhs) << amount) |
  969|       |                                         (Uint128Low64(lhs) >> (64 - amount)),
  970|       |                                     Uint128Low64(lhs) << amount);
  971|       |#endif
  972|  28.2k|}
_ZN4absl12lts_20260526plENS0_7uint128ES1_:
  999|  3.92k|constexpr uint128 operator+(uint128 lhs, uint128 rhs) {
 1000|  3.92k|#if defined(ABSL_HAVE_INTRINSIC_INT128)
 1001|  3.92k|  return static_cast<unsigned __int128>(lhs) +
 1002|  3.92k|         static_cast<unsigned __int128>(rhs);
 1003|       |#else
 1004|       |  return int128_internal::AddResult(
 1005|       |      MakeUint128(Uint128High64(lhs) + Uint128High64(rhs),
 1006|       |                  Uint128Low64(lhs) + Uint128Low64(rhs)),
 1007|       |      lhs);
 1008|       |#endif
 1009|  3.92k|}
_ZN4absl12lts_20260526miENS0_7uint128ES1_:
 1022|  22.8k|constexpr uint128 operator-(uint128 lhs, uint128 rhs) {
 1023|  22.8k|#if defined(ABSL_HAVE_INTRINSIC_INT128)
 1024|  22.8k|  return static_cast<unsigned __int128>(lhs) -
 1025|  22.8k|         static_cast<unsigned __int128>(rhs);
 1026|       |#else
 1027|       |  return int128_internal::SubstructResult(
 1028|       |      MakeUint128(Uint128High64(lhs) - Uint128High64(rhs),
 1029|       |                  Uint128Low64(lhs) - Uint128Low64(rhs)),
 1030|       |      lhs, rhs);
 1031|       |#endif
 1032|  22.8k|}
_ZN4absl12lts_202605267uint128ppEv:
 1091|    587|inline uint128& uint128::operator++() {
 1092|    587|  *this += 1;
 1093|    587|  return *this;
 1094|    587|}
_ZN4absl12lts_202605267uint128C2Ei:
  672|  52.9k|    : lo_{static_cast<uint64_t>(v)},
  673|  52.9k|      hi_{v < 0 ? (std::numeric_limits<uint64_t>::max)() : 0} {}
  ------------------
  |  Branch (673:11): [True: 0, False: 52.9k]
  ------------------

_ZN4absl12lts_2026052616numeric_internal18CountLeadingZeroesImEEiT_:
  268|  22.5k|CountLeadingZeroes(T x) {
  269|  22.5k|  static_assert(std::is_unsigned<T>::value, "T must be unsigned");
  270|  22.5k|  static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
  271|  22.5k|                "T must have a power-of-2 size");
  272|  22.5k|  static_assert(sizeof(T) <= sizeof(uint64_t), "T too large");
  273|  22.5k|  return sizeof(T) <= sizeof(uint16_t)
  ------------------
  |  Branch (273:10): [Folded, False: 22.5k]
  ------------------
  274|  22.5k|             ? CountLeadingZeroes16(static_cast<uint16_t>(x)) -
  275|      0|                   (std::numeric_limits<uint16_t>::digits -
  276|      0|                    std::numeric_limits<T>::digits)
  277|  22.5k|             : (sizeof(T) <= sizeof(uint32_t)
  ------------------
  |  Branch (277:17): [Folded, False: 22.5k]
  ------------------
  278|  22.5k|                    ? CountLeadingZeroes32(static_cast<uint32_t>(x)) -
  279|      0|                          (std::numeric_limits<uint32_t>::digits -
  280|      0|                           std::numeric_limits<T>::digits)
  281|  22.5k|                    : CountLeadingZeroes64(x));
  282|  22.5k|}
_ZN4absl12lts_2026052616numeric_internal20CountLeadingZeroes64Em:
  214|  22.5k|CountLeadingZeroes64(uint64_t x) {
  215|  22.5k|#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_clzll)
  216|       |  // Use __builtin_clzll, which uses the following instructions:
  217|       |  //  x86: bsr, lzcnt
  218|       |  //  ARM64: clz
  219|       |  //  PPC: cntlzd
  220|  22.5k|  static_assert(sizeof(unsigned long long) == sizeof(x),  // NOLINT(runtime/int)
  221|  22.5k|                "__builtin_clzll does not take 64-bit arg");
  222|       |
  223|       |  // Handle 0 as a special case because __builtin_clzll(0) is undefined.
  224|  22.5k|  return x == 0 ? 64 : __builtin_clzll(x);
  ------------------
  |  Branch (224:10): [True: 0, False: 22.5k]
  ------------------
  225|       |#elif defined(_MSC_VER) && !defined(__clang__) && \
  226|       |    (defined(_M_X64) || defined(_M_ARM64))
  227|       |  // MSVC does not have __buitin_clzll. Use _BitScanReverse64.
  228|       |  unsigned long result = 0;  // NOLINT(runtime/int)
  229|       |  if (_BitScanReverse64(&result, x)) {
  230|       |    return 63 - result;
  231|       |  }
  232|       |  return 64;
  233|       |#elif defined(_MSC_VER) && !defined(__clang__)
  234|       |  // MSVC does not have __buitin_clzll. Compose two calls to _BitScanReverse
  235|       |  unsigned long result = 0;  // NOLINT(runtime/int)
  236|       |  if ((x >> 32) &&
  237|       |      _BitScanReverse(&result, static_cast<unsigned long>(x >> 32))) {
  238|       |    return 31 - result;
  239|       |  }
  240|       |  if (_BitScanReverse(&result, static_cast<unsigned long>(x))) {
  241|       |    return 63 - result;
  242|       |  }
  243|       |  return 64;
  244|       |#else
  245|       |  int zeroes = 60;
  246|       |  if (x >> 32) {
  247|       |    zeroes -= 32;
  248|       |    x >>= 32;
  249|       |  }
  250|       |  if (x >> 16) {
  251|       |    zeroes -= 16;
  252|       |    x >>= 16;
  253|       |  }
  254|       |  if (x >> 8) {
  255|       |    zeroes -= 8;
  256|       |    x >>= 8;
  257|       |  }
  258|       |  if (x >> 4) {
  259|       |    zeroes -= 4;
  260|       |    x >>= 4;
  261|       |  }
  262|       |  return "\4\3\2\2\1\1\1\1\0\0\0\0\0\0\0"[x] + zeroes;
  263|       |#endif
  264|  22.5k|}
_ZN4absl12lts_2026052616numeric_internal19CountTrailingZeroesImEEiT_:
  353|     12|CountTrailingZeroes(T x) noexcept {
  354|     12|  static_assert(std::is_unsigned<T>::value, "T must be unsigned");
  355|     12|  static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
  356|     12|                "T must have a power-of-2 size");
  357|     12|  static_assert(sizeof(T) <= sizeof(uint64_t), "T too large");
  358|     12|  return x == 0 ? std::numeric_limits<T>::digits
  ------------------
  |  Branch (358:10): [True: 0, False: 12]
  ------------------
  359|     12|                : (sizeof(T) <= sizeof(uint16_t)
  ------------------
  |  Branch (359:20): [Folded, False: 12]
  ------------------
  360|     12|                       ? CountTrailingZeroesNonzero16(static_cast<uint16_t>(x))
  361|     12|                       : (sizeof(T) <= sizeof(uint32_t)
  ------------------
  |  Branch (361:27): [Folded, False: 12]
  ------------------
  362|     12|                              ? CountTrailingZeroesNonzero32(
  363|      0|                                    static_cast<uint32_t>(x))
  364|     12|                              : CountTrailingZeroesNonzero64(x)));
  365|     12|}
_ZN4absl12lts_2026052616numeric_internal28CountTrailingZeroesNonzero64Em:
  307|     12|CountTrailingZeroesNonzero64(uint64_t x) {
  308|     12|#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_ctzll)
  309|     12|  static_assert(sizeof(unsigned long long) == sizeof(x),  // NOLINT(runtime/int)
  310|     12|                "__builtin_ctzll does not take 64-bit arg");
  311|     12|  return __builtin_ctzll(x);
  312|       |#elif defined(_MSC_VER) && !defined(__clang__) && \
  313|       |    (defined(_M_X64) || defined(_M_ARM64))
  314|       |  unsigned long result = 0;  // NOLINT(runtime/int)
  315|       |  _BitScanForward64(&result, x);
  316|       |  return result;
  317|       |#elif defined(_MSC_VER) && !defined(__clang__)
  318|       |  unsigned long result = 0;  // NOLINT(runtime/int)
  319|       |  if (static_cast<uint32_t>(x) == 0) {
  320|       |    _BitScanForward(&result, static_cast<unsigned long>(x >> 32));
  321|       |    return result + 32;
  322|       |  }
  323|       |  _BitScanForward(&result, static_cast<unsigned long>(x));
  324|       |  return result;
  325|       |#else
  326|       |  int c = 63;
  327|       |  x &= ~x + 1;
  328|       |  if (x & 0x00000000FFFFFFFF) c -= 32;
  329|       |  if (x & 0x0000FFFF0000FFFF) c -= 16;
  330|       |  if (x & 0x00FF00FF00FF00FF) c -= 8;
  331|       |  if (x & 0x0F0F0F0F0F0F0F0F) c -= 4;
  332|       |  if (x & 0x3333333333333333) c -= 2;
  333|       |  if (x & 0x5555555555555555) c -= 1;
  334|       |  return c;
  335|       |#endif
  336|     12|}
_ZN4absl12lts_2026052616numeric_internal19CountTrailingZeroesIjEEiT_:
  353|     72|CountTrailingZeroes(T x) noexcept {
  354|     72|  static_assert(std::is_unsigned<T>::value, "T must be unsigned");
  355|     72|  static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
  356|     72|                "T must have a power-of-2 size");
  357|     72|  static_assert(sizeof(T) <= sizeof(uint64_t), "T too large");
  358|     72|  return x == 0 ? std::numeric_limits<T>::digits
  ------------------
  |  Branch (358:10): [True: 0, False: 72]
  ------------------
  359|     72|                : (sizeof(T) <= sizeof(uint16_t)
  ------------------
  |  Branch (359:20): [Folded, False: 72]
  ------------------
  360|     72|                       ? CountTrailingZeroesNonzero16(static_cast<uint16_t>(x))
  361|     72|                       : (sizeof(T) <= sizeof(uint32_t)
  ------------------
  |  Branch (361:27): [True: 72, Folded]
  ------------------
  362|     72|                              ? CountTrailingZeroesNonzero32(
  363|     72|                                    static_cast<uint32_t>(x))
  364|     72|                              : CountTrailingZeroesNonzero64(x)));
  365|     72|}
_ZN4absl12lts_2026052616numeric_internal28CountTrailingZeroesNonzero32Ej:
  285|     72|CountTrailingZeroesNonzero32(uint32_t x) {
  286|     72|#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_ctz)
  287|     72|  static_assert(sizeof(unsigned int) == sizeof(x),
  288|     72|                "__builtin_ctz does not take 32-bit arg");
  289|     72|  return __builtin_ctz(x);
  290|       |#elif defined(_MSC_VER) && !defined(__clang__)
  291|       |  unsigned long result = 0;  // NOLINT(runtime/int)
  292|       |  _BitScanForward(&result, x);
  293|       |  return result;
  294|       |#else
  295|       |  int c = 31;
  296|       |  x &= ~x + 1;
  297|       |  if (x & 0x0000FFFF) c -= 16;
  298|       |  if (x & 0x00FF00FF) c -= 8;
  299|       |  if (x & 0x0F0F0F0F) c -= 4;
  300|       |  if (x & 0x33333333) c -= 2;
  301|       |  if (x & 0x55555555) c -= 1;
  302|       |  return c;
  303|       |#endif
  304|     72|}

_ZN4absl12lts_2026052615random_internal24InitDiscreteDistributionEPNSt3__16vectorIdNS2_9allocatorIdEEEE:
   34|      2|    std::vector<double>* probabilities) {
   35|       |  // The empty-case should already be handled by the constructor.
   36|      2|  assert(probabilities);
   37|      2|  assert(!probabilities->empty());
   38|       |
   39|       |  // Step 1. Normalize the input probabilities to 1.0.
   40|      2|  double sum = std::accumulate(std::begin(*probabilities),
   41|      2|                               std::end(*probabilities), 0.0);
   42|      2|  if (std::fabs(sum - 1.0) > 1e-6) {
  ------------------
  |  Branch (42:7): [True: 2, False: 0]
  ------------------
   43|       |    // Scale `probabilities` only when the sum is too far from 1.0.  Scaling
   44|       |    // unconditionally will alter the probabilities slightly.
   45|      2|    for (double& item : *probabilities) {
  ------------------
  |  Branch (45:23): [True: 2, False: 2]
  ------------------
   46|      2|      item = item / sum;
   47|      2|    }
   48|      2|  }
   49|       |
   50|       |  // Step 2. At this point `probabilities` is set to the conditional
   51|       |  // probabilities of each element which sum to 1.0, to within reasonable error.
   52|       |  // These values are used to construct the proportional probability tables for
   53|       |  // the selection phases of Walker's Aliasing algorithm.
   54|       |  //
   55|       |  // To construct the table, pick an element which is under-full (i.e., an
   56|       |  // element for which `(*probabilities)[i] < 1.0/n`), and pair it with an
   57|       |  // element which is over-full (i.e., an element for which
   58|       |  // `(*probabilities)[i] > 1.0/n`). The smaller value can always be retired.
   59|       |  // The larger may still be greater than 1.0/n, or may now be less than 1.0/n,
   60|       |  // and put back onto the appropriate collection.
   61|      2|  const size_t n = probabilities->size();
   62|      2|  std::vector<std::pair<double, size_t>> q;
   63|      2|  q.reserve(n);
   64|       |
   65|      2|  std::vector<size_t> over;
   66|      2|  std::vector<size_t> under;
   67|      2|  size_t idx = 0;
   68|      2|  for (const double item : *probabilities) {
  ------------------
  |  Branch (68:26): [True: 2, False: 2]
  ------------------
   69|      2|    assert(item >= 0);
   70|      2|    const double v = item * n;
   71|      2|    q.emplace_back(v, 0);
   72|      2|    if (v < 1.0) {
  ------------------
  |  Branch (72:9): [True: 0, False: 2]
  ------------------
   73|      0|      under.push_back(idx++);
   74|      2|    } else {
   75|      2|      over.push_back(idx++);
   76|      2|    }
   77|      2|  }
   78|      2|  while (!over.empty() && !under.empty()) {
  ------------------
  |  Branch (78:10): [True: 2, False: 0]
  |  Branch (78:27): [True: 0, False: 2]
  ------------------
   79|      0|    auto lo = under.back();
   80|      0|    under.pop_back();
   81|      0|    auto hi = over.back();
   82|      0|    over.pop_back();
   83|       |
   84|      0|    q[lo].second = hi;
   85|      0|    const double r = q[hi].first - (1.0 - q[lo].first);
   86|      0|    q[hi].first = r;
   87|      0|    if (r < 1.0) {
  ------------------
  |  Branch (87:9): [True: 0, False: 0]
  ------------------
   88|      0|      under.push_back(hi);
   89|      0|    } else {
   90|      0|      over.push_back(hi);
   91|      0|    }
   92|      0|  }
   93|       |
   94|       |  // Due to rounding errors, there may be un-paired elements in either
   95|       |  // collection; these should all be values near 1.0.  For these values, set `q`
   96|       |  // to 1.0 and set the alternate to the identity.
   97|      2|  for (auto i : over) {
  ------------------
  |  Branch (97:15): [True: 2, False: 2]
  ------------------
   98|      2|    q[i] = {1.0, i};
   99|      2|  }
  100|      2|  for (auto i : under) {
  ------------------
  |  Branch (100:15): [True: 0, False: 2]
  ------------------
  101|      0|    q[i] = {1.0, i};
  102|      0|  }
  103|      2|  return q;
  104|      2|}

_ZN4absl12lts_2026052621discrete_distributionIiEC2Ev:
  113|      2|  discrete_distribution() : param_() {}
_ZN4absl12lts_2026052621discrete_distributionIiE10param_typeC2Ev:
   62|      2|    param_type() { init(); }
_ZN4absl12lts_2026052621discrete_distributionIiE10param_type4initEv:
  185|      4|void discrete_distribution<IntType>::param_type::init() {
  186|      4|  if (p_.empty()) {
  ------------------
  |  Branch (186:7): [True: 2, False: 2]
  ------------------
  187|      2|    p_.push_back(1.0);
  188|      2|    q_.emplace_back(1.0, 0);
  189|      2|  } else {
  190|       |    assert(n() <= (std::numeric_limits<IntType>::max)());
  191|      2|    q_ = random_internal::InitDiscreteDistribution(&p_);
  192|      2|  }
  193|      4|}
_ZN4absl12lts_2026052621discrete_distributionIiEC2INSt3__111__wrap_iterIPdEEEET_S8_:
  119|      2|      : param_(begin, end) {}
_ZN4absl12lts_2026052621discrete_distributionIiE10param_typeC2INSt3__111__wrap_iterIPdEEEET_S9_:
   66|      2|        : p_(begin, end) {
   67|      2|      init();
   68|      2|    }

_ZN4absl12lts_202605267UniformIjRNS0_6BitGenEEENSt3__19enable_ifIXntsr3std14numeric_limitsIT_EE9is_signedES6_E4typeEOT0_:
  210|     16|Uniform(URBG&& urbg) {  // NOLINT(runtime/references)
  211|     16|  using gen_t = std::decay_t<URBG>;
  212|     16|  using distribution_t = random_internal::UniformDistributionWrapper<R>;
  213|       |
  214|     16|  return random_internal::DistributionCaller<gen_t>::template Call<
  215|     16|      distribution_t>(&urbg);
  216|     16|}

_ZN4absl12lts_2026052615random_internal18DistributionCallerINS0_6BitGenEE4CallINS1_26UniformDistributionWrapperIjEEJEEENT_11result_typeEPS3_DpOT0_:
   73|     16|  static typename DistrT::result_type Call(URBG* urbg, Args&&... args) {
   74|     16|    return Impl<DistrT, Args...>(RandomMockingAccess::HasInvokeMock<URBG>{},
   75|     16|                                 urbg, std::forward<Args>(args)...);
   76|     16|  }
_ZN4absl12lts_2026052615random_internal18DistributionCallerINS0_6BitGenEE4ImplINS1_26UniformDistributionWrapperIjEEJEEENT_11result_typeENSt3__117integral_constantIbLb0EEEPS3_DpOT0_:
   47|     16|                                           Args&&... args) {
   48|     16|    DistrT dist(std::forward<Args>(args)...);
   49|     16|    return dist(*urbg);
   50|     16|  }

_ZN4absl12lts_2026052615random_internal24GetEntropyFromRandenPoolEPvm:
  178|      2|void GetEntropyFromRandenPool(void* dest, size_t bytes) {
  179|      2|  auto* pool = GetPoolForCurrentThread();
  180|      2|  pool->Fill(reinterpret_cast<uint8_t*>(dest), bytes);
  181|      2|}
entropy_pool.cc:_ZN4absl12lts_2026052615random_internal12_GLOBAL__N_123GetPoolForCurrentThreadEv:
  171|      2|RandenPoolEntry* GetPoolForCurrentThread() {
  172|      2|  absl::call_once(pool_once, InitPoolURBG);
  173|      2|  return shared_pools[GetPoolID()];
  174|      2|}
entropy_pool.cc:_ZN4absl12lts_2026052615random_internal12_GLOBAL__N_112InitPoolURBGEv:
  155|      2|void InitPoolURBG() {
  156|      2|  static constexpr size_t kSeedSize =
  157|      2|      RandenTraits::kStateBytes / sizeof(uint32_t);
  158|       |  // Read OS entropy once, and use it to initialize each pool entry.
  159|      2|  uint32_t seed_material[kPoolSize * kSeedSize];
  160|      2|  if (!ReadSeedMaterialFromOSEntropy(absl::MakeSpan(seed_material))) {
  ------------------
  |  Branch (160:7): [True: 0, False: 2]
  ------------------
  161|      0|    ThrowSeedGenException();
  162|      0|  }
  163|     18|  for (size_t i = 0; i < kPoolSize; i++) {
  ------------------
  |  Branch (163:22): [True: 16, False: 2]
  ------------------
  164|     16|    shared_pools[i] = new RandenPoolEntry();
  165|     16|    shared_pools[i]->Init(
  166|     16|        absl::MakeSpan(&seed_material[i * kSeedSize], kSeedSize));
  167|     16|  }
  168|      2|}
entropy_pool.cc:_ZN4absl12lts_2026052615random_internal12_GLOBAL__N_115RandenPoolEntry4InitENS0_4SpanIKjEE:
   57|     16|  void Init(absl::Span<const uint32_t> data) {
   58|     16|    SpinLockHolder l(mu_);  // Always uncontested.
   59|     16|    std::copy(data.begin(), data.end(), std::begin(state_));
   60|     16|    next_ = kState;
   61|     16|  }
entropy_pool.cc:_ZN4absl12lts_2026052615random_internal12_GLOBAL__N_19GetPoolIDEv:
  116|      2|size_t GetPoolID() {
  117|      2|  static_assert(kPoolSize >= 1,
  118|      2|                "At least one urbg instance is required for PoolURBG");
  119|       |
  120|      2|  ABSL_CONST_INIT static std::atomic<uint64_t> sequence{0};
  ------------------
  |  |  849|      2|#define ABSL_CONST_INIT [[clang::require_constant_initialization]]
  ------------------
  121|       |
  122|      2|#ifdef ABSL_HAVE_THREAD_LOCAL
  123|      2|  static thread_local size_t my_pool_id = kPoolSize;
  124|      2|  if (ABSL_PREDICT_FALSE(my_pool_id == kPoolSize)) {
  ------------------
  |  |  190|      2|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 2, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 2]
  |  |  |  Branch (190:58): [True: 2, False: 0]
  |  |  ------------------
  ------------------
  125|      2|    my_pool_id = (sequence++ % kPoolSize);
  126|      2|  }
  127|      2|  return my_pool_id;
  128|       |#else
  129|       |  static pthread_key_t tid_key = [] {
  130|       |    pthread_key_t tmp_key;
  131|       |    int err = pthread_key_create(&tmp_key, nullptr);
  132|       |    if (err) {
  133|       |      ABSL_RAW_LOG(FATAL, "pthread_key_create failed with %d", err);
  134|       |    }
  135|       |    return tmp_key;
  136|       |  }();
  137|       |
  138|       |  // Store the value in the pthread_{get/set}specific. However an uninitialized
  139|       |  // value is 0, so add +1 to distinguish from the null value.
  140|       |  uintptr_t my_pool_id =
  141|       |      reinterpret_cast<uintptr_t>(pthread_getspecific(tid_key));
  142|       |  if (ABSL_PREDICT_FALSE(my_pool_id == 0)) {
  143|       |    // No allocated ID, allocate the next value, cache it, and return.
  144|       |    my_pool_id = (sequence++ % kPoolSize) + 1;
  145|       |    int err = pthread_setspecific(tid_key, reinterpret_cast<void*>(my_pool_id));
  146|       |    if (err) {
  147|       |      ABSL_RAW_LOG(FATAL, "pthread_setspecific failed with %d", err);
  148|       |    }
  149|       |  }
  150|       |  return my_pool_id - 1;
  151|       |#endif
  152|      2|}
entropy_pool.cc:_ZN4absl12lts_2026052615random_internal12_GLOBAL__N_115RandenPoolEntry4FillEPhm:
   86|      2|void RandenPoolEntry::Fill(uint8_t* out, size_t bytes) {
   87|      2|  SpinLockHolder l(mu_);
   88|      4|  while (bytes > 0) {
  ------------------
  |  Branch (88:10): [True: 2, False: 2]
  ------------------
   89|      2|    MaybeRefill();
   90|      2|    size_t remaining = available() * sizeof(state_[0]);
   91|      2|    size_t to_copy = std::min(bytes, remaining);
   92|      2|    std::memcpy(out, &state_[next_], to_copy);
   93|      2|    out += to_copy;
   94|      2|    bytes -= to_copy;
   95|      2|    next_ += (to_copy + sizeof(state_[0]) - 1) / sizeof(state_[0]);
   96|      2|  }
   97|      2|}
entropy_pool.cc:_ZN4absl12lts_2026052615random_internal12_GLOBAL__N_115RandenPoolEntry11MaybeRefillEv:
   66|      2|  inline void MaybeRefill() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
   67|      2|    if (next_ >= kState) {
  ------------------
  |  Branch (67:9): [True: 2, False: 0]
  ------------------
   68|      2|      next_ = kCapacity;
   69|      2|      impl_.Generate(state_);
   70|      2|    }
   71|      2|  }
entropy_pool.cc:_ZNK4absl12lts_2026052615random_internal12_GLOBAL__N_115RandenPoolEntry9availableEv:
   73|      2|  inline size_t available() const ABSL_SHARED_LOCKS_REQUIRED(mu_) {
   74|      2|    return kState - next_;
   75|      2|  }

_ZN4absl12lts_2026052615random_internal15FastUniformBitsIjEclINS0_6BitGenEEEjRT_:
  122|     16|FastUniformBits<UIntType>::operator()(URBG& g) {  // NOLINT(runtime/references)
  123|       |  // kRangeMask is the mask used when sampling variates from the URBG when the
  124|       |  // width of the URBG range is not a power of 2.
  125|       |  // Y = (2 ^ kRange) - 1
  126|     16|  static_assert((URBG::max)() > (URBG::min)(),
  127|     16|                "URBG::max and URBG::min may not be equal.");
  128|       |
  129|     16|  using tag = std::conditional_t<IsPowerOfTwoOrZero(RangeSize<URBG>()),
  130|     16|                                  SimplifiedLoopTag, RejectionLoopTag>;
  131|     16|  return Generate(g, tag{});
  132|     16|}
_ZN4absl12lts_2026052615random_internal15FastUniformBitsIjE8GenerateINS0_6BitGenEEEjRT_NS1_17SimplifiedLoopTagE:
  138|     16|                                    SimplifiedLoopTag) {
  139|       |  // The simplified version of FastUniformBits works only on URBGs that have
  140|       |  // a range that is a power of 2. In this case we simply loop and shift without
  141|       |  // attempting to balance the bits across calls.
  142|     16|  static_assert(IsPowerOfTwoOrZero(RangeSize<URBG>()),
  143|     16|                "incorrect Generate tag for URBG instance");
  144|       |
  145|     16|  static constexpr size_t kResultBits =
  146|     16|      std::numeric_limits<result_type>::digits;
  147|     16|  static constexpr size_t kUrbgBits = NumBits<URBG>();
  148|     16|  static constexpr size_t kIters =
  149|     16|      (kResultBits / kUrbgBits) + (kResultBits % kUrbgBits != 0);
  150|     16|  static constexpr size_t kShift = (kIters == 1) ? 0 : kUrbgBits;
  ------------------
  |  Branch (150:36): [True: 0, Folded]
  ------------------
  151|     16|  static constexpr auto kMin = (URBG::min)();
  152|       |
  153|     16|  result_type r = static_cast<result_type>(g() - kMin);
  154|     16|  for (size_t n = 1; n < kIters; ++n) {
  ------------------
  |  Branch (154:22): [True: 0, False: 16]
  ------------------
  155|      0|    r = static_cast<result_type>(r << kShift) +
  156|      0|        static_cast<result_type>(g() - kMin);
  157|      0|  }
  158|     16|  return r;
  159|     16|}

_ZN4absl12lts_2026052615random_internal17RandenPoolSeedSeq4sizeEv:
   66|      2|  size_t size() { return 0; }
_ZN4absl12lts_2026052615random_internal17NonsecureURBGBaseINS1_13randen_engineImEENS1_17RandenPoolSeedSeqEEC2Ev:
  100|      2|  NonsecureURBGBase() : urbg_(ConstructURBG()) {}
_ZN4absl12lts_2026052615random_internal17NonsecureURBGBaseINS1_13randen_engineImEENS1_17RandenPoolSeedSeqEE13ConstructURBGEv:
  141|      2|  static URBG ConstructURBG() {
  142|      2|    Seeder seeder;
  143|      2|    return URBG(seeder);
  144|      2|  }
_ZN4absl12lts_2026052615random_internal17RandenPoolSeedSeq8generateIPjEEvT_S5_:
   72|      2|  void generate(RandomAccessIterator begin, RandomAccessIterator end) {
   73|       |    // RandomAccessIterator must be assignable from uint32_t
   74|      2|    if (begin != end) {
  ------------------
  |  Branch (74:9): [True: 2, False: 0]
  ------------------
   75|      2|      using U = typename std::iterator_traits<RandomAccessIterator>::value_type;
   76|       |      // ContiguousTag indicates the common case of a known contiguous buffer,
   77|       |      // which allows directly filling the buffer. In C++20,
   78|       |      // std::contiguous_iterator_tag provides a mechanism for testing this
   79|       |      // capability, however until Abseil's support requirements allow us to
   80|       |      // assume C++20, limit checks to a few common cases.
   81|      2|      using TagType = std::conditional_t<
   82|      2|          (std::is_pointer<RandomAccessIterator>::value ||
   83|      2|           std::is_same<RandomAccessIterator,
   84|      2|                        typename std::vector<U>::iterator>::value),
   85|      2|          ContiguousTag, BufferTag>;
   86|       |
   87|      2|      generate_impl(TagType{}, begin, end);
   88|      2|    }
   89|      2|  }
_ZN4absl12lts_2026052615random_internal17RandenPoolSeedSeq13generate_implIPjEEvNS2_13ContiguousTagET_S6_:
   46|      2|  void generate_impl(ContiguousTag, Contiguous begin, Contiguous end) {
   47|      2|    const size_t n = static_cast<size_t>(std::distance(begin, end));
   48|      2|    auto* a = &(*begin);
   49|      2|    GetEntropyFromRandenPool(a, sizeof(*a) * n);
   50|      2|  }
_ZN4absl12lts_2026052615random_internal17NonsecureURBGBaseINS1_13randen_engineImEENS1_17RandenPoolSeedSeqEEclEv:
  125|     16|  result_type operator()() { return urbg_(); }

_ZN4absl12lts_2026052615random_internal6RandenC2Ev:
   81|     18|Randen::Randen() {
   82|     18|  auto tmp = GetRandenState();
   83|     18|  keys_ = tmp.keys;
   84|     18|#if ABSL_RANDOM_INTERNAL_AES_DISPATCH
   85|     18|  has_crypto_ = tmp.has_crypto;
   86|     18|#endif
   87|     18|}
randen.cc:_ZN4absl12lts_2026052615random_internal12_GLOBAL__N_114GetRandenStateEv:
   53|     18|RandenState GetRandenState() {
   54|     18|  static const RandenState state = []() {
   55|     18|    RandenState tmp;
   56|     18|#if ABSL_RANDOM_INTERNAL_AES_DISPATCH
   57|       |    // HW AES Dispatch.
   58|     18|    if (HasRandenHwAesImplementation() && CPUSupportsRandenHwAes()) {
   59|     18|      tmp.has_crypto = true;
   60|     18|      tmp.keys = RandenHwAes::GetKeys();
   61|     18|    } else {
   62|     18|      tmp.has_crypto = false;
   63|     18|      tmp.keys = RandenSlow::GetKeys();
   64|     18|    }
   65|       |#elif ABSL_HAVE_ACCELERATED_AES
   66|       |    // HW AES is enabled.
   67|       |    tmp.has_crypto = true;
   68|       |    tmp.keys = RandenHwAes::GetKeys();
   69|       |#else
   70|       |    // HW AES is disabled.
   71|       |    tmp.has_crypto = false;
   72|       |    tmp.keys = RandenSlow::GetKeys();
   73|       |#endif
   74|     18|    return tmp;
   75|     18|  }();
   76|     18|  return state;
   77|     18|}
randen.cc:_ZZN4absl12lts_2026052615random_internal12_GLOBAL__N_114GetRandenStateEvENK3$_0clEv:
   54|      2|  static const RandenState state = []() {
   55|      2|    RandenState tmp;
   56|      2|#if ABSL_RANDOM_INTERNAL_AES_DISPATCH
   57|       |    // HW AES Dispatch.
   58|      2|    if (HasRandenHwAesImplementation() && CPUSupportsRandenHwAes()) {
  ------------------
  |  Branch (58:9): [True: 0, False: 2]
  |  Branch (58:43): [True: 0, False: 0]
  ------------------
   59|      0|      tmp.has_crypto = true;
   60|      0|      tmp.keys = RandenHwAes::GetKeys();
   61|      2|    } else {
   62|      2|      tmp.has_crypto = false;
   63|      2|      tmp.keys = RandenSlow::GetKeys();
   64|      2|    }
   65|       |#elif ABSL_HAVE_ACCELERATED_AES
   66|       |    // HW AES is enabled.
   67|       |    tmp.has_crypto = true;
   68|       |    tmp.keys = RandenHwAes::GetKeys();
   69|       |#else
   70|       |    // HW AES is disabled.
   71|       |    tmp.has_crypto = false;
   72|       |    tmp.keys = RandenSlow::GetKeys();
   73|       |#endif
   74|      2|    return tmp;
   75|      2|  }();

_ZNK4absl12lts_2026052615random_internal6Randen8GenerateEPv:
   47|      4|  inline void Generate(void* state) const {
   48|      4|#if ABSL_RANDOM_INTERNAL_AES_DISPATCH
   49|       |    // HW AES Dispatch.
   50|      4|    if (has_crypto_) {
  ------------------
  |  Branch (50:9): [True: 0, False: 4]
  ------------------
   51|      0|      RandenHwAes::Generate(keys_, state);
   52|      4|    } else {
   53|      4|      RandenSlow::Generate(keys_, state);
   54|      4|    }
   55|       |#elif ABSL_HAVE_ACCELERATED_AES
   56|       |    // HW AES is enabled.
   57|       |    RandenHwAes::Generate(keys_, state);
   58|       |#else
   59|       |    // HW AES is disabled.
   60|       |    RandenSlow::Generate(keys_, state);
   61|       |#endif
   62|      4|  }
_ZNK4absl12lts_2026052615random_internal6Randen6AbsorbEPKvPv:
   68|      2|  inline void Absorb(const void* seed, void* state) const {
   69|      2|#if ABSL_RANDOM_INTERNAL_AES_DISPATCH
   70|       |    // HW AES Dispatch.
   71|      2|    if (has_crypto_) {
  ------------------
  |  Branch (71:9): [True: 0, False: 2]
  ------------------
   72|      0|      RandenHwAes::Absorb(seed, state);
   73|      2|    } else {
   74|      2|      RandenSlow::Absorb(seed, state);
   75|      2|    }
   76|       |#elif ABSL_HAVE_ACCELERATED_AES
   77|       |    // HW AES is enabled.
   78|       |    RandenHwAes::Absorb(seed, state);
   79|       |#else
   80|       |    // HW AES is disabled.
   81|       |    RandenSlow::Absorb(seed, state);
   82|       |#endif
   83|      2|  }

_ZN4absl12lts_2026052615random_internal13randen_engineImEC2IRNS1_17RandenPoolSeedSeqEvEEOT_:
   68|      2|  explicit randen_engine(SeedSequence&& seq) {
   69|      2|    seed(seq);
   70|      2|  }
_ZN4absl12lts_2026052615random_internal13randen_engineImE4seedIRNS1_17RandenPoolSeedSeqEEENSt3__19enable_ifIXntsr3std14is_convertibleIT_mEE5valueEvE4typeEOS9_:
   98|      2|  seed(SeedSequence&& seq) {
   99|       |    // Zeroes the state.
  100|      2|    seed();
  101|      2|    reseed(seq);
  102|      2|  }
_ZN4absl12lts_2026052615random_internal13randen_engineImE4seedEm:
  104|      2|  void seed(result_type seed_value = 0) {
  105|      2|    next_ = kStateSizeT;
  106|       |    // Zeroes the inner state and fills the outer state with seed_value to
  107|       |    // mimic the behaviour of reseed
  108|      2|    auto* begin = state();
  109|      2|    std::fill(begin, begin + kCapacityT, 0);
  110|      2|    std::fill(begin + kCapacityT, begin + kStateSizeT, seed_value);
  111|      2|  }
_ZN4absl12lts_2026052615random_internal13randen_engineImE5stateEv:
  245|     20|  result_type* state() {
  246|     20|    return reinterpret_cast<result_type*>(
  247|     20|        (reinterpret_cast<uintptr_t>(&raw_state_) & 0xf) ? (raw_state_ + 8)
  ------------------
  |  Branch (247:9): [True: 20, False: 0]
  ------------------
  248|     20|                                                         : raw_state_);
  249|     20|  }
_ZN4absl12lts_2026052615random_internal13randen_engineImE6reseedINS1_17RandenPoolSeedSeqEEEvRT_:
  117|      2|  void reseed(SeedSequence& seq) {
  118|      2|    using sequence_result_type = typename SeedSequence::result_type;
  119|      2|    static_assert(sizeof(sequence_result_type) == 4,
  120|      2|                  "SeedSequence::result_type must be 32-bit");
  121|      2|    constexpr size_t kBufferSize =
  122|      2|        Randen::kSeedBytes / sizeof(sequence_result_type);
  123|      2|    alignas(16) sequence_result_type buffer[kBufferSize];
  124|       |
  125|       |    // Randen::Absorb XORs the seed into state, which is then mixed by a call
  126|       |    // to Randen::Generate. Seeding with only the provided entropy is preferred
  127|       |    // to using an arbitrary generate() call, so use [rand.req.seed_seq]
  128|       |    // size as a proxy for the number of entropy units that can be generated
  129|       |    // without relying on seed sequence mixing...
  130|      2|    const size_t entropy_size = seq.size();
  131|      2|    if (entropy_size < kBufferSize) {
  ------------------
  |  Branch (131:9): [True: 2, False: 0]
  ------------------
  132|       |      // ... and only request that many values, or 256-bits, when unspecified.
  133|      2|      const size_t requested_entropy = (entropy_size == 0) ? 8u : entropy_size;
  ------------------
  |  Branch (133:40): [True: 2, False: 0]
  ------------------
  134|      2|      std::fill(buffer + requested_entropy, buffer + kBufferSize, 0);
  135|      2|      seq.generate(buffer, buffer + requested_entropy);
  136|       |#ifdef ABSL_IS_BIG_ENDIAN
  137|       |      // Randen expects the seed buffer to be in Little Endian; reverse it on
  138|       |      // Big Endian platforms.
  139|       |      for (sequence_result_type& e : buffer) {
  140|       |        e = absl::little_endian::FromHost(e);
  141|       |      }
  142|       |#endif
  143|       |      // The Randen paper suggests preferentially initializing even-numbered
  144|       |      // 128-bit vectors of the randen state (there are 16 such vectors).
  145|       |      // The seed data is merged into the state offset by 128-bits, which
  146|       |      // implies preferring seed bytes [16..31, ..., 208..223]. Since the
  147|       |      // buffer is 32-bit values, we swap the corresponding buffer positions in
  148|       |      // 128-bit chunks.
  149|      2|      size_t dst = kBufferSize;
  150|     16|      while (dst > 7) {
  ------------------
  |  Branch (150:14): [True: 14, False: 2]
  ------------------
  151|       |        // leave the odd bucket as-is.
  152|     14|        dst -= 4;
  153|     14|        size_t src = dst >> 1;
  154|       |        // swap 128-bits into the even bucket
  155|     14|        std::swap(buffer[--dst], buffer[--src]);
  156|     14|        std::swap(buffer[--dst], buffer[--src]);
  157|     14|        std::swap(buffer[--dst], buffer[--src]);
  158|     14|        std::swap(buffer[--dst], buffer[--src]);
  159|     14|      }
  160|      2|    } else {
  161|      0|      seq.generate(buffer, buffer + kBufferSize);
  162|      0|    }
  163|      2|    impl_.Absorb(buffer, state());
  164|       |
  165|       |    // Generate will be called when operator() is called
  166|      2|    next_ = kStateSizeT;
  167|      2|  }
_ZN4absl12lts_2026052615random_internal13randen_engineImEclEv:
   85|     16|  result_type operator()() {
   86|       |    // Refill the buffer if needed (unlikely).
   87|     16|    auto* begin = state();
   88|     16|    if (next_ >= kStateSizeT) {
  ------------------
  |  Branch (88:9): [True: 2, False: 14]
  ------------------
   89|      2|      next_ = kCapacityT;
   90|      2|      impl_.Generate(begin);
   91|      2|    }
   92|     16|    return little_endian::ToHost(begin[next_++]);
   93|     16|  }

_ZN4absl12lts_2026052615random_internal28HasRandenHwAesImplementationEv:
   54|      2|bool HasRandenHwAesImplementation() { return false; }

_ZN4absl12lts_2026052615random_internal10RandenSlow7GetKeysEv:
  421|      2|const void* RandenSlow::GetKeys() {
  422|       |  // Round keys for one AES per Feistel round and branch.
  423|       |  // The canonical implementation uses first digits of Pi.
  424|      2|#ifdef ABSL_IS_LITTLE_ENDIAN
  425|      2|  return kRandenRoundKeys;
  426|       |#else
  427|       |  return kRandenRoundKeysBE;
  428|       |#endif
  429|      2|}
_ZN4absl12lts_2026052615random_internal10RandenSlow6AbsorbEPKvPv:
  431|      2|void RandenSlow::Absorb(const void* seed_void, void* state_void) {
  432|      2|  auto* state =
  433|      2|      reinterpret_cast<uint64_t * ABSL_RANDOM_INTERNAL_RESTRICT>(state_void);
  434|      2|  const auto* seed =
  435|      2|      reinterpret_cast<const uint64_t * ABSL_RANDOM_INTERNAL_RESTRICT>(
  436|      2|          seed_void);
  437|       |
  438|      2|  constexpr size_t kCapacityBlocks =
  439|      2|      RandenTraits::kCapacityBytes / sizeof(uint64_t);
  440|      2|  static_assert(
  441|      2|      kCapacityBlocks * sizeof(uint64_t) == RandenTraits::kCapacityBytes,
  442|      2|      "Not i*V");
  443|       |
  444|      2|  for (size_t i = kCapacityBlocks;
  445|     62|       i < RandenTraits::kStateBytes / sizeof(uint64_t); ++i) {
  ------------------
  |  Branch (445:8): [True: 60, False: 2]
  ------------------
  446|     60|    state[i] ^= seed[i - kCapacityBlocks];
  447|     60|  }
  448|      2|}
_ZN4absl12lts_2026052615random_internal10RandenSlow8GenerateEPKvPv:
  450|      4|void RandenSlow::Generate(const void* keys_void, void* state_void) {
  451|      4|  static_assert(RandenTraits::kCapacityBytes == sizeof(absl::uint128),
  452|      4|                "Capacity mismatch");
  453|       |
  454|      4|  auto* state = reinterpret_cast<absl::uint128*>(state_void);
  455|      4|  const auto* keys = reinterpret_cast<const absl::uint128*>(keys_void);
  456|       |
  457|      4|  const absl::uint128 prev_inner = state[0];
  458|       |
  459|      4|  SwapEndian(state);
  460|       |
  461|      4|  Permute(state, keys);
  462|       |
  463|      4|  SwapEndian(state);
  464|       |
  465|       |  // Ensure backtracking resistance.
  466|      4|  *state ^= prev_inner;
  467|      4|}
randen_slow.cc:_ZN12_GLOBAL__N_110SwapEndianEPN4absl12lts_202605267uint128E:
  400|      8|    absl::uint128* state) {
  401|       |#ifdef ABSL_IS_BIG_ENDIAN
  402|       |  for (uint32_t block = 0; block < RandenTraits::kFeistelBlocks; ++block) {
  403|       |    uint64_t new_lo = absl::little_endian::ToHost64(
  404|       |        static_cast<uint64_t>(state[block] >> 64));
  405|       |    uint64_t new_hi = absl::little_endian::ToHost64(
  406|       |        static_cast<uint64_t>((state[block] << 64) >> 64));
  407|       |    state[block] = (static_cast<absl::uint128>(new_hi) << 64) | new_lo;
  408|       |  }
  409|       |#else
  410|       |  // Avoid warning about unused variable.
  411|      8|  (void)state;
  412|      8|#endif
  413|      8|}
randen_slow.cc:_ZN12_GLOBAL__N_17PermuteEPN4absl12lts_202605267uint128EPKS2_:
  391|      4|    const absl::uint128* ABSL_RANDOM_INTERNAL_RESTRICT keys) {
  392|     72|  for (size_t round = 0; round < RandenTraits::kFeistelRounds; ++round) {
  ------------------
  |  Branch (392:26): [True: 68, False: 4]
  ------------------
  393|     68|    keys = FeistelRound(state, keys);
  394|     68|    BlockShuffle(state);
  395|     68|  }
  396|      4|}
randen_slow.cc:_ZN12_GLOBAL__N_112FeistelRoundEPN4absl12lts_202605267uint128EPKS2_:
  365|     68|             const absl::uint128* ABSL_RANDOM_INTERNAL_RESTRICT keys) {
  366|    340|  for (size_t branch = 0; branch < RandenTraits::kFeistelBlocks; branch += 4) {
  ------------------
  |  Branch (366:27): [True: 272, False: 68]
  ------------------
  367|    272|    const Vector128 s0 = Vector128Load(state + branch);
  368|    272|    const Vector128 s1 = Vector128Load(state + branch + 1);
  369|    272|    const Vector128 f0 = AesRound(s0, Vector128Load(keys));
  370|    272|    keys++;
  371|    272|    const Vector128 o1 = AesRound(f0, s1);
  372|    272|    Vector128Store(o1, state + branch + 1);
  373|       |
  374|       |    // Manually unroll this loop once. about 10% better than not unrolled.
  375|    272|    const Vector128 s2 = Vector128Load(state + branch + 2);
  376|    272|    const Vector128 s3 = Vector128Load(state + branch + 3);
  377|    272|    const Vector128 f2 = AesRound(s2, Vector128Load(keys));
  378|    272|    keys++;
  379|    272|    const Vector128 o3 = AesRound(f2, s3);
  380|    272|    Vector128Store(o3, state + branch + 3);
  381|    272|  }
  382|     68|  return keys;
  383|     68|}
randen_slow.cc:_ZN12_GLOBAL__N_113Vector128LoadEPKv:
  239|  1.63k|Vector128Load(const void* from) {
  240|  1.63k|  Vector128 result;
  241|  1.63k|  std::memcpy(result.s, from, sizeof(Vector128));
  242|  1.63k|  return result;
  243|  1.63k|}
randen_slow.cc:_ZN12_GLOBAL__N_18AesRoundERKNS_9Vector128ES2_:
  253|  1.08k|AesRound(const Vector128& state, const Vector128& round_key) {
  254|  1.08k|  Vector128 result;
  255|  1.08k|#ifdef ABSL_IS_LITTLE_ENDIAN
  256|  1.08k|  result.s[0] = round_key.s[0] ^                  //
  257|  1.08k|                te0[uint8_t(state.s[0])] ^        //
  258|  1.08k|                te1[uint8_t(state.s[1] >> 8)] ^   //
  259|  1.08k|                te2[uint8_t(state.s[2] >> 16)] ^  //
  260|  1.08k|                te3[uint8_t(state.s[3] >> 24)];
  261|  1.08k|  result.s[1] = round_key.s[1] ^                  //
  262|  1.08k|                te0[uint8_t(state.s[1])] ^        //
  263|  1.08k|                te1[uint8_t(state.s[2] >> 8)] ^   //
  264|  1.08k|                te2[uint8_t(state.s[3] >> 16)] ^  //
  265|  1.08k|                te3[uint8_t(state.s[0] >> 24)];
  266|  1.08k|  result.s[2] = round_key.s[2] ^                  //
  267|  1.08k|                te0[uint8_t(state.s[2])] ^        //
  268|  1.08k|                te1[uint8_t(state.s[3] >> 8)] ^   //
  269|  1.08k|                te2[uint8_t(state.s[0] >> 16)] ^  //
  270|  1.08k|                te3[uint8_t(state.s[1] >> 24)];
  271|  1.08k|  result.s[3] = round_key.s[3] ^                  //
  272|  1.08k|                te0[uint8_t(state.s[3])] ^        //
  273|  1.08k|                te1[uint8_t(state.s[0] >> 8)] ^   //
  274|  1.08k|                te2[uint8_t(state.s[1] >> 16)] ^  //
  275|  1.08k|                te3[uint8_t(state.s[2] >> 24)];
  276|       |#else
  277|       |  result.s[0] = round_key.s[0] ^                  //
  278|       |                te0[uint8_t(state.s[0])] ^        //
  279|       |                te1[uint8_t(state.s[3] >> 8)] ^   //
  280|       |                te2[uint8_t(state.s[2] >> 16)] ^  //
  281|       |                te3[uint8_t(state.s[1] >> 24)];
  282|       |  result.s[1] = round_key.s[1] ^                  //
  283|       |                te0[uint8_t(state.s[1])] ^        //
  284|       |                te1[uint8_t(state.s[0] >> 8)] ^   //
  285|       |                te2[uint8_t(state.s[3] >> 16)] ^  //
  286|       |                te3[uint8_t(state.s[2] >> 24)];
  287|       |  result.s[2] = round_key.s[2] ^                  //
  288|       |                te0[uint8_t(state.s[2])] ^        //
  289|       |                te1[uint8_t(state.s[1] >> 8)] ^   //
  290|       |                te2[uint8_t(state.s[0] >> 16)] ^  //
  291|       |                te3[uint8_t(state.s[3] >> 24)];
  292|       |  result.s[3] = round_key.s[3] ^                  //
  293|       |                te0[uint8_t(state.s[3])] ^        //
  294|       |                te1[uint8_t(state.s[2] >> 8)] ^   //
  295|       |                te2[uint8_t(state.s[1] >> 16)] ^  //
  296|       |                te3[uint8_t(state.s[0] >> 24)];
  297|       |#endif
  298|  1.08k|  return result;
  299|  1.08k|}
randen_slow.cc:_ZN12_GLOBAL__N_114Vector128StoreERKNS_9Vector128EPv:
  246|    544|    const Vector128& v, void* to) {
  247|    544|  std::memcpy(to, v.s, sizeof(Vector128));
  248|    544|}
randen_slow.cc:_ZN12_GLOBAL__N_112BlockShuffleEPN4absl12lts_202605267uint128E:
  305|     68|    absl::uint128* state) {
  306|     68|  static_assert(RandenTraits::kFeistelBlocks == 16,
  307|     68|                "Feistel block shuffle only works for 16 blocks.");
  308|       |
  309|     68|  constexpr size_t shuffle[RandenTraits::kFeistelBlocks] = {
  310|     68|      7, 2, 13, 4, 11, 8, 3, 6, 15, 0, 9, 10, 1, 14, 5, 12};
  311|       |
  312|       |  // The fully unrolled loop without the memcpy improves the speed by about
  313|       |  // 30% over the equivalent:
  314|       |#if 0
  315|       |  absl::uint128 source[RandenTraits::kFeistelBlocks];
  316|       |  std::memcpy(source, state, sizeof(source));
  317|       |  for (size_t i = 0; i < RandenTraits::kFeistelBlocks; i++) {
  318|       |    const absl::uint128 v0 = source[shuffle[i]];
  319|       |    state[i] = v0;
  320|       |  }
  321|       |  return;
  322|       |#endif
  323|       |
  324|     68|  const absl::uint128 v0 = state[shuffle[0]];
  325|     68|  const absl::uint128 v1 = state[shuffle[1]];
  326|     68|  const absl::uint128 v2 = state[shuffle[2]];
  327|     68|  const absl::uint128 v3 = state[shuffle[3]];
  328|     68|  const absl::uint128 v4 = state[shuffle[4]];
  329|     68|  const absl::uint128 v5 = state[shuffle[5]];
  330|     68|  const absl::uint128 v6 = state[shuffle[6]];
  331|     68|  const absl::uint128 v7 = state[shuffle[7]];
  332|     68|  const absl::uint128 w0 = state[shuffle[8]];
  333|     68|  const absl::uint128 w1 = state[shuffle[9]];
  334|     68|  const absl::uint128 w2 = state[shuffle[10]];
  335|     68|  const absl::uint128 w3 = state[shuffle[11]];
  336|     68|  const absl::uint128 w4 = state[shuffle[12]];
  337|     68|  const absl::uint128 w5 = state[shuffle[13]];
  338|     68|  const absl::uint128 w6 = state[shuffle[14]];
  339|     68|  const absl::uint128 w7 = state[shuffle[15]];
  340|     68|  state[0] = v0;
  341|     68|  state[1] = v1;
  342|     68|  state[2] = v2;
  343|     68|  state[3] = v3;
  344|     68|  state[4] = v4;
  345|     68|  state[5] = v5;
  346|     68|  state[6] = v6;
  347|     68|  state[7] = v7;
  348|     68|  state[8] = w0;
  349|     68|  state[9] = w1;
  350|     68|  state[10] = w2;
  351|     68|  state[11] = w3;
  352|     68|  state[12] = w4;
  353|     68|  state[13] = w5;
  354|     68|  state[14] = w6;
  355|     68|  state[15] = w7;
  356|     68|}

_ZN4absl12lts_2026052615random_internal29ReadSeedMaterialFromOSEntropyENS0_4SpanIjEE:
  188|      2|bool ReadSeedMaterialFromOSEntropy(absl::Span<uint32_t> values) {
  189|      2|  assert(values.data() != nullptr);
  190|      2|  if (values.data() == nullptr) {
  ------------------
  |  Branch (190:7): [True: 0, False: 2]
  ------------------
  191|      0|    return false;
  192|      0|  }
  193|      2|  if (values.empty()) {
  ------------------
  |  Branch (193:7): [True: 0, False: 2]
  ------------------
  194|      0|    return true;
  195|      0|  }
  196|      2|  return ReadSeedMaterialFromOSEntropyImpl(values);
  197|      2|}
seed_material.cc:_ZN4absl12lts_2026052615random_internal12_GLOBAL__N_133ReadSeedMaterialFromOSEntropyImplENS0_4SpanIjEE:
  173|      2|bool ReadSeedMaterialFromOSEntropyImpl(absl::Span<uint32_t> values) {
  174|      2|#if defined(ABSL_RANDOM_USE_GET_ENTROPY)
  175|      2|  if (ReadSeedMaterialFromGetEntropy(values)) {
  ------------------
  |  Branch (175:7): [True: 2, False: 0]
  ------------------
  176|      2|    return true;
  177|      2|  }
  178|      0|#endif
  179|       |  // Libc may support getentropy, but the kernel may not, so we still have
  180|       |  // to fallback to ReadSeedMaterialFromDevURandom().
  181|      0|  return ReadSeedMaterialFromDevURandom(values);
  182|      2|}
seed_material.cc:_ZN4absl12lts_2026052615random_internal12_GLOBAL__N_130ReadSeedMaterialFromGetEntropyENS0_4SpanIjEE:
  122|      2|bool ReadSeedMaterialFromGetEntropy(absl::Span<uint32_t> values) {
  123|      2|  auto buffer = reinterpret_cast<uint8_t*>(values.data());
  124|      2|  size_t buffer_size = sizeof(uint32_t) * values.size();
  125|     18|  while (buffer_size > 0) {
  ------------------
  |  Branch (125:10): [True: 16, False: 2]
  ------------------
  126|       |    // getentropy() has a maximum permitted length of 256.
  127|     16|    size_t to_read = std::min<size_t>(buffer_size, 256);
  128|     16|    int result = getentropy(buffer, to_read);
  129|     16|    if (result < 0) {
  ------------------
  |  Branch (129:9): [True: 0, False: 16]
  ------------------
  130|      0|      return false;
  131|      0|    }
  132|       |    // https://github.com/google/sanitizers/issues/1173
  133|       |    // MemorySanitizer can't see through getentropy().
  134|     16|    ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(buffer, to_read);
  135|     16|    buffer += to_read;
  136|     16|    buffer_size -= to_read;
  137|     16|  }
  138|      2|  return true;
  139|      2|}

_ZN4absl12lts_2026052615random_internal26UniformDistributionWrapperIjEC2Ev:
  236|     16|      : UniformDistribution<NumType>(std::numeric_limits<NumType>::lowest(),
  237|     16|                                     (std::numeric_limits<NumType>::max)()) {}

_ZNK4absl12lts_2026052624uniform_int_distributionIjE5paramEv:
  135|     16|  param_type param() const { return param_; }
_ZNK4absl12lts_2026052624uniform_int_distributionIjE10param_type1aEv:
   81|     16|    result_type a() const { return lo_; }
_ZNK4absl12lts_2026052624uniform_int_distributionIjE10param_type5rangeEv:
   96|     16|    unsigned_type range() const { return range_; }
_ZN4absl12lts_2026052624uniform_int_distributionIjEC2Ejj:
  111|     16|      : param_(lo, hi) {}
_ZN4absl12lts_2026052624uniform_int_distributionIjE10param_typeC2Ejj:
   74|     16|        : lo_(lo),
   75|     16|          range_(static_cast<unsigned_type>(hi) -
   76|     16|                 static_cast<unsigned_type>(lo)) {
   77|       |      // [rand.dist.uni.int] precondition 2
   78|       |      assert(lo <= hi);
   79|     16|    }
_ZN4absl12lts_2026052624uniform_int_distributionIjEclINS0_6BitGenEEEjRT_:
  122|     16|  result_type operator()(URBG& gen) {  // NOLINT(runtime/references)
  123|     16|    return (*this)(gen, param());
  124|     16|  }
_ZN4absl12lts_2026052624uniform_int_distributionIjEclINS0_6BitGenEEEjRT_RKNS2_10param_typeE:
  128|     16|      URBG& gen, const param_type& param) {  // NOLINT(runtime/references)
  129|     16|    return static_cast<result_type>(param.a() + Generate(gen, param.range()));
  130|     16|  }
_ZN4absl12lts_2026052624uniform_int_distributionIjE8GenerateINS0_6BitGenEEEjRT_j:
  199|     16|    typename random_internal::make_unsigned_bits<IntType>::type R) {
  200|     16|  random_internal::FastUniformBits<unsigned_type> fast_bits;
  201|     16|  unsigned_type bits = fast_bits(g);
  202|     16|  const unsigned_type Lim = R + 1;
  203|     16|  if ((R & Lim) == 0) {
  ------------------
  |  Branch (203:7): [True: 16, False: 0]
  ------------------
  204|       |    // If the interval's length is a power of two range, just take the low bits.
  205|     16|    return bits & R;
  206|     16|  }
  207|       |
  208|       |  // Generates a uniform variate on [0, Lim) using fixed-point multiplication.
  209|       |  // The above fast-path guarantees that Lim is representable in unsigned_type.
  210|       |  //
  211|       |  // Algorithm adapted from
  212|       |  // http://lemire.me/blog/2016/06/30/fast-random-shuffling/, with added
  213|       |  // explanation.
  214|       |  //
  215|       |  // The algorithm creates a uniform variate `bits` in the interval [0, 2^N),
  216|       |  // and treats it as the fractional part of a fixed-point real value in [0, 1),
  217|       |  // multiplied by 2^N.  For example, 0.25 would be represented as 2^(N - 2),
  218|       |  // because 2^N * 0.25 == 2^(N - 2).
  219|       |  //
  220|       |  // Next, `bits` and `Lim` are multiplied with a wide-multiply to bring the
  221|       |  // value into the range [0, Lim).  The integral part (the high word of the
  222|       |  // multiplication result) is then very nearly the desired result.  However,
  223|       |  // this is not quite accurate; viewing the multiplication result as one
  224|       |  // double-width integer, the resulting values for the sample are mapped as
  225|       |  // follows:
  226|       |  //
  227|       |  // If the result lies in this interval:       Return this value:
  228|       |  //        [0, 2^N)                                    0
  229|       |  //        [2^N, 2 * 2^N)                              1
  230|       |  //        ...                                         ...
  231|       |  //        [K * 2^N, (K + 1) * 2^N)                    K
  232|       |  //        ...                                         ...
  233|       |  //        [(Lim - 1) * 2^N, Lim * 2^N)                Lim - 1
  234|       |  //
  235|       |  // While all of these intervals have the same size, the result of `bits * Lim`
  236|       |  // must be a multiple of `Lim`, and not all of these intervals contain the
  237|       |  // same number of multiples of `Lim`.  In particular, some contain
  238|       |  // `F = floor(2^N / Lim)` and some contain `F + 1 = ceil(2^N / Lim)`.  This
  239|       |  // difference produces a small nonuniformity, which is corrected by applying
  240|       |  // rejection sampling to one of the values in the "larger intervals" (i.e.,
  241|       |  // the intervals containing `F + 1` multiples of `Lim`.
  242|       |  //
  243|       |  // An interval contains `F + 1` multiples of `Lim` if and only if its smallest
  244|       |  // value modulo 2^N is less than `2^N % Lim`.  The unique value satisfying
  245|       |  // this property is used as the one for rejection.  That is, a value of
  246|       |  // `bits * Lim` is rejected if `(bit * Lim) % 2^N < (2^N % Lim)`.
  247|       |
  248|      0|  using helper = random_internal::wide_multiply<unsigned_type>;
  249|      0|  auto product = helper::multiply(bits, Lim);
  250|       |
  251|       |  // Two optimizations here:
  252|       |  // * Rejection occurs with some probability less than 1/2, and for reasonable
  253|       |  //   ranges considerably less (in particular, less than 1/(F+1)), so
  254|       |  //   ABSL_PREDICT_FALSE is apt.
  255|       |  // * `Lim` is an overestimate of `threshold`, and doesn't require a divide.
  256|      0|  if (ABSL_PREDICT_FALSE(helper::lo(product) < Lim)) {
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  257|       |    // This quantity is exactly equal to `2^N % Lim`, but does not require high
  258|       |    // precision calculations: `2^N % Lim` is congruent to `(2^N - Lim) % Lim`.
  259|       |    // Ideally this could be expressed simply as `-X` rather than `2^N - X`, but
  260|       |    // for types smaller than int, this calculation is incorrect due to integer
  261|       |    // promotion rules.
  262|      0|    const unsigned_type threshold =
  263|      0|        ((std::numeric_limits<unsigned_type>::max)() - Lim + 1) % Lim;
  264|      0|    while (helper::lo(product) < threshold) {
  ------------------
  |  Branch (264:12): [True: 0, False: 0]
  ------------------
  265|      0|      bits = fast_bits(g);
  266|      0|      product = helper::multiply(bits, Lim);
  267|      0|    }
  268|      0|  }
  269|       |
  270|      0|  return helper::hi(product);
  271|     16|}

_ZNK4absl12lts_2026052615status_internal9StatusRep5UnrefEv:
   53|  3.57k|void StatusRep::Unref() const {
   54|       |  // Fast path: if ref==1, there is no need for a RefCountDec (since
   55|       |  // this is the only reference and therefore no other thread is
   56|       |  // allowed to be mucking with r).
   57|  3.57k|  if (ref_.load(std::memory_order_acquire) == 1 ||
  ------------------
  |  Branch (57:7): [True: 3.57k, False: 0]
  ------------------
   58|  3.57k|      ref_.fetch_sub(1, std::memory_order_acq_rel) - 1 == 0) {
  ------------------
  |  Branch (58:7): [True: 0, False: 0]
  ------------------
   59|  3.57k|    delete this;
   60|  3.57k|  }
   61|  3.57k|}
_ZN4absl12lts_2026052615status_internal9StatusRep17AddSourceLocationENS0_14SourceLocationE:
  141|  3.57k|void StatusRep::AddSourceLocation(absl::SourceLocation loc) {
  142|  3.57k|  source_locations_.push_back(loc);
  143|  3.57k|}

_ZN4absl12lts_2026052615status_internal9StatusRepC2ENS0_10StatusCodeENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEENS4_10unique_ptrINS0_13InlinedVectorINS1_7PayloadELm1ENS4_9allocatorISB_EEEENS4_14default_deleteISE_EEEE:
   82|  3.57k|      : ref_(int32_t{1}),
   83|  3.57k|        code_(code_arg),
   84|  3.57k|        message_(message_arg),
   85|  3.57k|        payloads_(std::move(payloads_arg)) {}

_ZN4absl12lts_2026052617internal_statusor12StatusOrDataIN8fuzztest8internal11CopyableAnyEED2Ev:
  358|  4.70k|  ~StatusOrData() {
  359|  4.70k|    if (ok()) {
  ------------------
  |  Branch (359:9): [True: 1.13k, False: 3.57k]
  ------------------
  360|  1.13k|      status_.~Status();
  361|  1.13k|      if constexpr (!std::is_trivially_destructible_v<T>) {
  362|  1.13k|        data_.~T();
  363|  1.13k|      }
  364|  3.57k|    } else {
  365|  3.57k|      status_.~Status();
  366|  3.57k|    }
  367|  4.70k|  }
_ZNK4absl12lts_2026052617internal_statusor12StatusOrDataIN8fuzztest8internal11CopyableAnyEE2okEv:
  386|  9.40k|  bool ok() const { return status_.ok(); }
_ZNO4absl12lts_2026052617internal_statusor12OperatorBaseIN8fuzztest8internal11CopyableAnyEEdeEv:
  473|  1.13k|  T&& operator*() && ABSL_ATTRIBUTE_LIFETIME_BOUND {
  474|  1.13k|    self().EnsureOk();
  475|  1.13k|    return std::move(self().data_);
  476|  1.13k|  }
_ZN4absl12lts_2026052617internal_statusor12OperatorBaseIN8fuzztest8internal11CopyableAnyEE4selfEv:
  459|  2.26k|  auto& self() { return static_cast<StatusOr<T>&>(*this); }
_ZNK4absl12lts_2026052617internal_statusor12StatusOrDataIN8fuzztest8internal11CopyableAnyEE8EnsureOkEv:
  413|  1.13k|  void EnsureOk() const {
  414|  1.13k|    if (ABSL_PREDICT_FALSE(!ok())) Helper::Crash(status_);
  ------------------
  |  |  190|  1.13k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 1.13k]
  |  |  |  Branch (190:49): [Folded, False: 1.13k]
  |  |  |  Branch (190:58): [True: 0, False: 1.13k]
  |  |  ------------------
  ------------------
  415|  1.13k|  }
_ZN4absl12lts_2026052617internal_statusor12StatusOrDataIN8fuzztest8internal11CopyableAnyEEC2INS0_6StatusETnNSt3__19enable_ifIXsr3std16is_constructibleIS8_OT_EE5valueEiE4typeELi0EEESC_:
  336|  3.57k|  explicit StatusOrData(U&& v) : status_(std::forward<U>(v)) {
  337|  3.57k|    EnsureNotOk();
  338|  3.57k|  }
_ZN4absl12lts_2026052617internal_statusor12StatusOrDataIN8fuzztest8internal11CopyableAnyEE11EnsureNotOkEv:
  417|  3.57k|  void EnsureNotOk() {
  418|  3.57k|    if (ABSL_PREDICT_FALSE(ok())) Helper::HandleInvalidStatusCtorArg(&status_);
  ------------------
  |  |  190|  3.57k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 3.57k]
  |  |  |  Branch (190:49): [Folded, False: 3.57k]
  |  |  |  Branch (190:58): [True: 0, False: 3.57k]
  |  |  ------------------
  ------------------
  419|  3.57k|  }
_ZN4absl12lts_2026052617internal_statusor12StatusOrDataIN8fuzztest8internal11CopyableAnyEEC2IJRS5_EEENSt3__110in_place_tEDpOT_:
  329|  1.13k|      : data_(std::forward<Args>(args)...) {
  330|  1.13k|    MakeStatus();
  331|  1.13k|  }
_ZN4absl12lts_2026052617internal_statusor12StatusOrDataIN8fuzztest8internal11CopyableAnyEE10MakeStatusIJEEEvDpOT_:
  432|  1.13k|  void MakeStatus(Args&&... args) {
  433|  1.13k|    internal_statusor::PlacementNew<Status>(&status_,
  434|  1.13k|                                            std::forward<Args>(args)...);
  435|  1.13k|  }
_ZN4absl12lts_2026052617internal_statusor12PlacementNewINS0_6StatusEJEEEvPvDpOT0_:
  246|  1.13k|void PlacementNew(void* absl_nonnull p, Args&&... args) {
  247|  1.13k|  new (p) T(std::forward<Args>(args)...);
  248|  1.13k|}

_ZN4absl12lts_2026052615status_internal13MakeErrorImplILi3EEENS0_6StatusENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEENS0_14SourceLocationE:
  164|  3.57k|Status MakeErrorImpl(string_view message, SourceLocation loc) {
  165|  3.57k|  return Status(static_cast<StatusCode>(error_code), message, loc);
  166|  3.57k|}
_ZN4absl12lts_202605266Status7MakeRepEmNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEENS0_14SourceLocationE:
  116|  3.57k|                          absl::SourceLocation loc) {
  117|  3.57k|  bool ok = inlined_rep == CodeToInlinedRep(absl::StatusCode::kOk);
  118|  3.57k|  if (ok) return inlined_rep;
  ------------------
  |  Branch (118:7): [True: 0, False: 3.57k]
  ------------------
  119|  3.57k|  if (msg.empty()
  ------------------
  |  Branch (119:7): [True: 0, False: 3.57k]
  ------------------
  120|  3.57k|  ) {
  121|      0|    return inlined_rep;
  122|      0|  }
  123|  3.57k|  auto* rep = new status_internal::StatusRep(InlinedRepToCode(inlined_rep), msg,
  124|  3.57k|                                             nullptr);
  125|  3.57k|  if (loc.file_name()[0] != '\0') {
  ------------------
  |  Branch (125:7): [True: 3.57k, False: 0]
  ------------------
  126|  3.57k|    rep->AddSourceLocation(loc);
  127|  3.57k|  }
  128|  3.57k|  return PointerToRep(rep);
  129|  3.57k|}

_ZN4absl12lts_2026052620InvalidArgumentErrorENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEENS0_14SourceLocationE:
 1133|  3.57k|                                   absl::SourceLocation loc) {
 1134|  3.57k|  return status_internal::MakeError<StatusCode::kInvalidArgument>(message, loc);
 1135|  3.57k|}
_ZN4absl12lts_2026052615status_internal9MakeErrorILNS0_10StatusCodeE3EEENS0_6StatusENSt3__117basic_string_viewIcNS5_11char_traitsIcEEEENS0_14SourceLocationE:
 1090|  3.57k|Status MakeError(string_view message, SourceLocation loc) {
 1091|  3.57k|  Status out = MakeErrorImpl<static_cast<int>(error_code)>(message, loc);
 1092|       |  // -Wassume warning complains about potential side effects of `ok()`, so use a
 1093|       |  // local to avoid that.
 1094|  3.57k|  ABSL_ATTRIBUTE_UNUSED bool ok = out.ok();
  ------------------
  |  |  582|  3.57k|#define ABSL_ATTRIBUTE_UNUSED __attribute__((__unused__))
  ------------------
 1095|  3.57k|  ABSL_ASSUME(!ok);
  ------------------
  |  |  271|  3.57k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1096|  3.57k|  return out;
 1097|  3.57k|}
_ZN4absl12lts_202605266StatusD2Ev:
  940|  9.63M|inline Status::~Status() { Unref(rep_); }
_ZN4absl12lts_202605266Status5UnrefEm:
 1046|  9.63M|inline void Status::Unref(uintptr_t rep) {
 1047|  9.63M|  if (!IsInlined(rep)) RepToPointer(rep)->Unref();
  ------------------
  |  Branch (1047:7): [True: 3.57k, False: 9.63M]
  ------------------
 1048|  9.63M|}
_ZN4absl12lts_202605266Status9IsInlinedEm:
 1014|  9.63M|constexpr bool Status::IsInlined(uintptr_t rep) { return (rep & 1) != 0; }
_ZN4absl12lts_202605266Status12RepToPointerEm:
 1032|  3.57k|    uintptr_t rep) {
 1033|       |  assert(!IsInlined(rep));
 1034|  3.57k|  return reinterpret_cast<const status_internal::StatusRep*>(rep);
 1035|  3.57k|}
_ZN4absl12lts_202605268OkStatusEv:
 1050|  9.62M|inline Status OkStatus() { return Status(); }
_ZN4absl12lts_202605266StatusC2Ev:
  894|  9.62M|inline Status::Status() : Status(absl::StatusCode::kOk) {}
_ZN4absl12lts_202605266StatusC2ENS0_10StatusCodeE:
  896|  9.62M|inline Status::Status(absl::StatusCode code) : Status(CodeToInlinedRep(code)) {}
_ZN4absl12lts_202605266Status16CodeToInlinedRepENS0_10StatusCodeE:
 1018|  19.2M|constexpr uintptr_t Status::CodeToInlinedRep(absl::StatusCode code) {
 1019|  19.2M|  return (static_cast<uintptr_t>(code) << 2) + 1;
 1020|  19.2M|}
_ZN4absl12lts_202605266StatusC2Em:
  714|  9.63M|  explicit Status(uintptr_t rep) : rep_(rep) {}
_ZN4absl12lts_202605266StatusaSEOS1_:
  918|  1.13k|inline Status& Status::operator=(Status&& x) noexcept {
  919|  1.13k|  uintptr_t old_rep = rep_;
  920|  1.13k|  if (x.rep_ != old_rep) {
  ------------------
  |  Branch (920:7): [True: 0, False: 1.13k]
  ------------------
  921|      0|    rep_ = x.rep_;
  922|      0|    x.rep_ = MovedFromRep();
  923|      0|    Unref(old_rep);
  924|      0|  }
  925|  1.13k|  return *this;
  926|  1.13k|}
_ZN4absl12lts_202605266Status12MovedFromRepEv:
 1027|  3.57k|constexpr uintptr_t Status::MovedFromRep() {
 1028|  3.57k|  return CodeToInlinedRep(absl::StatusCode::kInternal) | 2;
 1029|  3.57k|}
_ZNK4absl12lts_202605266Status2okEv:
  942|  9.64M|inline bool Status::ok() const {
  943|  9.64M|  return rep_ == CodeToInlinedRep(absl::StatusCode::kOk);
  944|  9.64M|}
_ZN4absl12lts_202605266Status16InlinedRepToCodeEm:
 1022|  3.57k|constexpr absl::StatusCode Status::InlinedRepToCode(uintptr_t rep) {
 1023|  3.57k|  ABSL_ASSERT(IsInlined(rep));
  ------------------
  |  |  127|  3.57k|#define ABSL_ASSERT(expr) ABSL_INTERNAL_UNEVALUATED((expr) ? void() : void())
  |  |  ------------------
  |  |  |  |   87|  3.57k|#define ABSL_INTERNAL_UNEVALUATED(expr) (false ? (void)(expr) : void())
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (87:42): [Folded, False: 3.57k]
  |  |  |  |  |  Branch (87:57): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1024|  3.57k|  return static_cast<absl::StatusCode>(rep >> 2);
 1025|  3.57k|}
_ZN4absl12lts_202605266Status12PointerToRepEPNS0_15status_internal9StatusRepE:
 1038|  3.57k|    status_internal::StatusRep* absl_nonnull rep) {
 1039|  3.57k|  return reinterpret_cast<uintptr_t>(rep);
 1040|  3.57k|}
_ZN4absl12lts_202605266Status3RefEm:
 1042|  1.13k|inline void Status::Ref(uintptr_t rep) {
 1043|  1.13k|  if (!IsInlined(rep)) RepToPointer(rep)->Ref();
  ------------------
  |  Branch (1043:7): [True: 0, False: 1.13k]
  ------------------
 1044|  1.13k|}
_ZN4absl12lts_202605266StatusC2EOS1_:
  914|  3.57k|inline Status::Status(Status&& x) noexcept : Status(x.rep_) {
  915|  3.57k|  x.rep_ = MovedFromRep();
  916|  3.57k|}
_ZN4absl12lts_202605266StatusC2ERKS1_:
  902|  1.13k|inline Status::Status(const Status& x) : Status(x.rep_) { Ref(rep_); }
_ZN4absl12lts_202605266StatusC2ENS0_10StatusCodeENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEENS0_14SourceLocationE:
  900|  3.57k|    : Status(MakeRep(CodeToInlinedRep(code), msg, loc)) {}

_ZNK4absl12lts_202605268StatusOrIN8fuzztest8internal11CopyableAnyEE2okEv:
  471|  4.70k|  ABSL_MUST_USE_RESULT bool ok() const { return this->status_.ok(); }
_ZN4absl12lts_202605268StatusOrIN8fuzztest8internal11CopyableAnyEEC2INS0_6StatusETnNSt3__19enable_ifIXsr17internal_statusor29IsConstructionFromStatusValidILb0ES4_T_EE5valueEiE4typeELi0EEEOSA_:
  367|  3.57k|  StatusOr(U&& v) : Base(std::forward<U>(v)) {}
_ZN4absl12lts_202605268StatusOrIN8fuzztest8internal11CopyableAnyEEC2IRS4_TnNSt3__19enable_ifIXsr17internal_statusor19IsConstructionValidILb0ES4_T_Lb0EEE5valueEiE4typeELi0EEEOSA_:
  436|  1.13k|      : StatusOr(std::in_place, std::forward<U>(u)) {}
_ZN4absl12lts_202605268StatusOrIN8fuzztest8internal11CopyableAnyEEC2IJRS4_EEENSt3__110in_place_tEDpOT_:
  751|  1.13k|    : Base(std::in_place, std::forward<Args>(args)...) {}

_ZN4absl12lts_2026052613ascii_isspaceEh:
  105|  71.3k|inline bool ascii_isspace(unsigned char c) {
  106|  71.3k|  return (ascii_internal::kPropertyBits[c] & 0x08) != 0;
  107|  71.3k|}
_ZN4absl12lts_2026052627StripLeadingAsciiWhitespaceENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  244|  25.1k|    absl::string_view str ABSL_ATTRIBUTE_LIFETIME_BOUND) {
  245|  25.1k|  auto it = std::find_if_not(str.begin(), str.end(), absl::ascii_isspace);
  246|  25.1k|  return str.substr(static_cast<size_t>(it - str.begin()));
  247|  25.1k|}
_ZN4absl12lts_2026052628StripTrailingAsciiWhitespaceENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  258|  25.1k|    absl::string_view str ABSL_ATTRIBUTE_LIFETIME_BOUND) {
  259|  25.1k|  auto it = std::find_if_not(str.rbegin(), str.rend(), absl::ascii_isspace);
  260|  25.1k|  return str.substr(0, static_cast<size_t>(str.rend() - it));
  261|  25.1k|}
_ZN4absl12lts_2026052620StripAsciiWhitespaceENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  272|  25.1k|    absl::string_view str ABSL_ATTRIBUTE_LIFETIME_BOUND) {
  273|  25.1k|  return StripTrailingAsciiWhitespace(StripLeadingAsciiWhitespace(str));
  274|  25.1k|}

_ZN4absl12lts_2026052610from_charsEPKcS2_RdNS0_12chars_formatE:
  949|  25.1k|                             chars_format fmt) {
  950|  25.1k|  return FromCharsImpl(first, last, value, fmt);
  951|  25.1k|}
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_113FromCharsImplIdEENS0_17from_chars_resultEPKcS5_RT_NS0_12chars_formatE:
  862|  25.1k|                                chars_format fmt_flags) {
  863|  25.1k|  from_chars_result result;
  864|  25.1k|  result.ptr = first;  // overwritten on successful parse
  865|  25.1k|  result.ec = std::errc();
  866|       |
  867|  25.1k|  bool negative = false;
  868|  25.1k|  if (first != last && *first == '-') {
  ------------------
  |  Branch (868:7): [True: 25.1k, False: 0]
  |  Branch (868:24): [True: 1.95k, False: 23.2k]
  ------------------
  869|  1.95k|    ++first;
  870|  1.95k|    negative = true;
  871|  1.95k|  }
  872|       |  // If the `hex` flag is *not* set, then we will accept a 0x prefix and try
  873|       |  // to parse a hexadecimal float.
  874|  25.1k|  if ((fmt_flags & chars_format::hex) == chars_format{} && last - first >= 2 &&
  ------------------
  |  Branch (874:7): [True: 25.1k, False: 0]
  |  Branch (874:60): [True: 23.2k, False: 1.94k]
  ------------------
  875|  23.2k|      *first == '0' && (first[1] == 'x' || first[1] == 'X')) {
  ------------------
  |  Branch (875:7): [True: 6.26k, False: 16.9k]
  |  Branch (875:25): [True: 555, False: 5.70k]
  |  Branch (875:44): [True: 4.56k, False: 1.14k]
  ------------------
  876|  5.12k|    const char* hex_first = first + 2;
  877|  5.12k|    strings_internal::ParsedFloat hex_parse =
  878|  5.12k|        strings_internal::ParseFloat<16>(hex_first, last, fmt_flags);
  879|  5.12k|    if (hex_parse.end == nullptr ||
  ------------------
  |  Branch (879:9): [True: 50, False: 5.07k]
  ------------------
  880|  5.07k|        hex_parse.type != strings_internal::FloatType::kNumber) {
  ------------------
  |  Branch (880:9): [True: 1, False: 5.06k]
  ------------------
  881|       |      // Either we failed to parse a hex float after the "0x", or we read
  882|       |      // "0xinf" or "0xnan" which we don't want to match.
  883|       |      //
  884|       |      // However, a string that begins with "0x" also begins with "0", which
  885|       |      // is normally a valid match for the number zero.  So we want these
  886|       |      // strings to match zero unless fmt_flags is `scientific`.  (This flag
  887|       |      // means an exponent is required, which the string "0" does not have.)
  888|     51|      if (fmt_flags == chars_format::scientific) {
  ------------------
  |  Branch (888:11): [True: 0, False: 51]
  ------------------
  889|      0|        result.ec = std::errc::invalid_argument;
  890|     51|      } else {
  891|     51|        result.ptr = first + 1;
  892|     51|        value = negative ? -0.0f : 0.0f;
  ------------------
  |  Branch (892:17): [True: 1, False: 50]
  ------------------
  893|     51|      }
  894|     51|      return result;
  895|     51|    }
  896|       |    // We matched a value.
  897|  5.06k|    result.ptr = hex_parse.end;
  898|  5.06k|    if (HandleEdgeCase(hex_parse, negative, &value)) {
  ------------------
  |  Branch (898:9): [True: 1.08k, False: 3.98k]
  ------------------
  899|  1.08k|      return result;
  900|  1.08k|    }
  901|  3.98k|    CalculatedFloat calculated =
  902|  3.98k|        CalculateFromParsedHexadecimal<FloatType>(hex_parse);
  903|  3.98k|    EncodeResult(calculated, negative, &result, &value);
  904|  3.98k|    return result;
  905|  5.06k|  }
  906|       |  // Otherwise, we choose the number base based on the flags.
  907|  20.0k|  if ((fmt_flags & chars_format::hex) == chars_format::hex) {
  ------------------
  |  Branch (907:7): [True: 0, False: 20.0k]
  ------------------
  908|      0|    strings_internal::ParsedFloat hex_parse =
  909|      0|        strings_internal::ParseFloat<16>(first, last, fmt_flags);
  910|      0|    if (hex_parse.end == nullptr) {
  ------------------
  |  Branch (910:9): [True: 0, False: 0]
  ------------------
  911|      0|      result.ec = std::errc::invalid_argument;
  912|      0|      return result;
  913|      0|    }
  914|      0|    result.ptr = hex_parse.end;
  915|      0|    if (HandleEdgeCase(hex_parse, negative, &value)) {
  ------------------
  |  Branch (915:9): [True: 0, False: 0]
  ------------------
  916|      0|      return result;
  917|      0|    }
  918|      0|    CalculatedFloat calculated =
  919|      0|        CalculateFromParsedHexadecimal<FloatType>(hex_parse);
  920|      0|    EncodeResult(calculated, negative, &result, &value);
  921|      0|    return result;
  922|  20.0k|  } else {
  923|  20.0k|    strings_internal::ParsedFloat decimal_parse =
  924|  20.0k|        strings_internal::ParseFloat<10>(first, last, fmt_flags);
  925|  20.0k|    if (decimal_parse.end == nullptr) {
  ------------------
  |  Branch (925:9): [True: 110, False: 19.9k]
  ------------------
  926|    110|      result.ec = std::errc::invalid_argument;
  927|    110|      return result;
  928|    110|    }
  929|  19.9k|    result.ptr = decimal_parse.end;
  930|  19.9k|    if (HandleEdgeCase(decimal_parse, negative, &value)) {
  ------------------
  |  Branch (930:9): [True: 3.51k, False: 16.4k]
  ------------------
  931|  3.51k|      return result;
  932|  3.51k|    }
  933|       |    // A nullptr subrange_begin means that the decimal_parse.mantissa is exact
  934|       |    // (not truncated), a precondition of the Eisel-Lemire algorithm.
  935|  16.4k|    if ((decimal_parse.subrange_begin == nullptr) &&
  ------------------
  |  Branch (935:9): [True: 7.82k, False: 8.60k]
  ------------------
  936|  7.82k|        EiselLemire<FloatType>(decimal_parse, negative, &value, &result.ec)) {
  ------------------
  |  Branch (936:9): [True: 4.47k, False: 3.35k]
  ------------------
  937|  4.47k|      return result;
  938|  4.47k|    }
  939|  11.9k|    CalculatedFloat calculated =
  940|  11.9k|        CalculateFromParsedDecimal<FloatType>(decimal_parse);
  941|  11.9k|    EncodeResult(calculated, negative, &result, &value);
  942|  11.9k|    return result;
  943|  16.4k|  }
  944|  20.0k|}
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_114HandleEdgeCaseIdEEbRKNS0_16strings_internal11ParsedFloatEbPT_:
  360|  25.0k|                    FloatType* absl_nonnull value) {
  361|  25.0k|  if (input.type == strings_internal::FloatType::kNan) {
  ------------------
  |  Branch (361:7): [True: 581, False: 24.4k]
  ------------------
  362|       |    // A bug in gcc would cause the compiler to optimize away the buffer we are
  363|       |    // building below.  Declaring the buffer volatile avoids the issue, and has
  364|       |    // no measurable performance impact in microbenchmarks.
  365|       |    //
  366|       |    // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=86113
  367|    581|    constexpr ptrdiff_t kNanBufferSize = 128;
  368|       |#if (defined(__GNUC__) && !defined(__clang__))
  369|       |    volatile char n_char_sequence[kNanBufferSize];
  370|       |#else
  371|    581|    char n_char_sequence[kNanBufferSize];
  372|    581|#endif
  373|    581|    if (input.subrange_begin == nullptr) {
  ------------------
  |  Branch (373:9): [True: 581, False: 0]
  ------------------
  374|    581|      n_char_sequence[0] = '\0';
  375|    581|    } else {
  376|      0|      ptrdiff_t nan_size = input.subrange_end - input.subrange_begin;
  377|      0|      nan_size = std::min(nan_size, kNanBufferSize - 1);
  378|      0|      std::copy_n(input.subrange_begin, nan_size, n_char_sequence);
  379|      0|      n_char_sequence[nan_size] = '\0';
  380|      0|    }
  381|    581|    char* nan_argument = const_cast<char*>(n_char_sequence);
  382|    581|    *value = negative ? -FloatTraits<FloatType>::MakeNan(nan_argument)
  ------------------
  |  Branch (382:14): [True: 194, False: 387]
  ------------------
  383|    581|                      : FloatTraits<FloatType>::MakeNan(nan_argument);
  384|    581|    return true;
  385|    581|  }
  386|  24.4k|  if (input.type == strings_internal::FloatType::kInfinity) {
  ------------------
  |  Branch (386:7): [True: 510, False: 23.9k]
  ------------------
  387|    510|    *value = negative ? -std::numeric_limits<FloatType>::infinity()
  ------------------
  |  Branch (387:14): [True: 0, False: 510]
  ------------------
  388|    510|                      : std::numeric_limits<FloatType>::infinity();
  389|    510|    return true;
  390|    510|  }
  391|  23.9k|  if (input.mantissa == 0) {
  ------------------
  |  Branch (391:7): [True: 3.50k, False: 20.4k]
  ------------------
  392|  3.50k|    *value = negative ? -0.0f : 0.0f;
  ------------------
  |  Branch (392:14): [True: 192, False: 3.31k]
  ------------------
  393|  3.50k|    return true;
  394|  3.50k|  }
  395|  20.4k|  return false;
  396|  23.9k|}
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_111FloatTraitsIdE7MakeNanEPKc:
  123|    581|  static double MakeNan(const char* absl_nonnull tagp) {
  124|    581|#if ABSL_HAVE_BUILTIN(__builtin_nan)
  125|       |    // Use __builtin_nan() if available since it has a fix for
  126|       |    // https://bugs.llvm.org/show_bug.cgi?id=37778
  127|       |    // std::nan may use the glibc implementation.
  128|    581|    return __builtin_nan(tagp);
  129|       |#else
  130|       |    // Support nan no matter which namespace it's in.  Some platforms
  131|       |    // incorrectly don't put it in namespace std.
  132|       |    using namespace std;  // NOLINT
  133|       |    return nan(tagp);
  134|       |#endif
  135|    581|  }
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_130CalculateFromParsedHexadecimalIdEENS1_15CalculatedFloatERKNS0_16strings_internal11ParsedFloatE:
  599|  3.98k|    const strings_internal::ParsedFloat& parsed_hex) {
  600|  3.98k|  uint64_t mantissa = parsed_hex.mantissa;
  601|  3.98k|  int exponent = parsed_hex.exponent;
  602|       |  // This static_cast is only needed when using a std::bit_width()
  603|       |  // implementation that does not have the fix for LWG 3656 applied.
  604|  3.98k|  int mantissa_width = static_cast<int>(bit_width(mantissa));
  605|  3.98k|  const int shift = NormalizedShiftSize<FloatType>(mantissa_width, exponent);
  606|  3.98k|  bool result_exact;
  607|  3.98k|  exponent += shift;
  608|  3.98k|  mantissa = ShiftRightAndRound(mantissa, shift,
  609|  3.98k|                                /* input exact= */ true, &result_exact);
  610|       |  // ParseFloat handles rounding in the hexadecimal case, so we don't have to
  611|       |  // check `result_exact` here.
  612|  3.98k|  return CalculatedFloatFromRawValues<FloatType>(mantissa, exponent);
  613|  3.98k|}
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_119NormalizedShiftSizeIdEEiii:
  335|  15.4k|int NormalizedShiftSize(int mantissa_width, int binary_exponent) {
  336|  15.4k|  const int normal_shift =
  337|  15.4k|      mantissa_width - FloatTraits<FloatType>::kTargetMantissaBits;
  338|  15.4k|  const int minimum_shift =
  339|  15.4k|      FloatTraits<FloatType>::kMinNormalExponent - binary_exponent;
  340|  15.4k|  return std::max(normal_shift, minimum_shift);
  341|  15.4k|}
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_118ShiftRightAndRoundENS0_7uint128EibPb:
  453|  15.4k|                            bool* absl_nonnull output_exact) {
  454|  15.4k|  if (shift <= 0) {
  ------------------
  |  Branch (454:7): [True: 2.28k, False: 13.2k]
  ------------------
  455|  2.28k|    *output_exact = input_exact;
  456|  2.28k|    return static_cast<uint64_t>(value << -shift);
  457|  2.28k|  }
  458|  13.2k|  if (shift >= 128) {
  ------------------
  |  Branch (458:7): [True: 233, False: 12.9k]
  ------------------
  459|       |    // Exponent is so small that we are shifting away all significant bits.
  460|       |    // Answer will not be representable, even as a subnormal, so return a zero
  461|       |    // mantissa (which represents underflow).
  462|    233|    *output_exact = true;
  463|    233|    return 0;
  464|    233|  }
  465|       |
  466|  12.9k|  *output_exact = true;
  467|  12.9k|  const uint128 shift_mask = (uint128(1) << shift) - 1;
  468|  12.9k|  const uint128 halfway_point = uint128(1) << (shift - 1);
  469|       |
  470|  12.9k|  const uint128 shifted_bits = value & shift_mask;
  471|  12.9k|  value >>= shift;
  472|  12.9k|  if (shifted_bits > halfway_point) {
  ------------------
  |  Branch (472:7): [True: 1.17k, False: 11.7k]
  ------------------
  473|       |    // Shifted bits greater than 10000... require rounding up.
  474|  1.17k|    return static_cast<uint64_t>(value + 1);
  475|  1.17k|  }
  476|  11.7k|  if (shifted_bits == halfway_point) {
  ------------------
  |  Branch (476:7): [True: 1.22k, False: 10.5k]
  ------------------
  477|       |    // In exact mode, shifted bits of 10000... mean we're exactly halfway
  478|       |    // between two numbers, and we must round to even.  So only round up if
  479|       |    // the low bit of `value` is set.
  480|       |    //
  481|       |    // In inexact mode, the nonzero error means the actual value is greater
  482|       |    // than the halfway point and we must always round up.
  483|  1.22k|    if ((value & 1) == 1 || !input_exact) {
  ------------------
  |  Branch (483:9): [True: 393, False: 835]
  |  Branch (483:29): [True: 194, False: 641]
  ------------------
  484|    587|      ++value;
  485|    587|    }
  486|  1.22k|    return static_cast<uint64_t>(value);
  487|  1.22k|  }
  488|  10.5k|  if (!input_exact && shifted_bits == halfway_point - 1) {
  ------------------
  |  Branch (488:7): [True: 9.85k, False: 705]
  |  Branch (488:23): [True: 9.45k, False: 402]
  ------------------
  489|       |    // Rounding direction is unclear, due to error.
  490|  9.45k|    *output_exact = false;
  491|  9.45k|  }
  492|       |  // Otherwise, round down.
  493|  10.5k|  return static_cast<uint64_t>(value);
  494|  11.7k|}
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_128CalculatedFloatFromRawValuesIdEENS1_15CalculatedFloatEmi:
  580|  15.4k|CalculatedFloat CalculatedFloatFromRawValues(uint64_t mantissa, int exponent) {
  581|  15.4k|  CalculatedFloat result;
  582|  15.4k|  if (mantissa == uint64_t{1} << FloatTraits<FloatType>::kTargetMantissaBits) {
  ------------------
  |  Branch (582:7): [True: 597, False: 14.8k]
  ------------------
  583|    597|    mantissa >>= 1;
  584|    597|    exponent += 1;
  585|    597|  }
  586|  15.4k|  if (exponent > FloatTraits<FloatType>::kMaxExponent) {
  ------------------
  |  Branch (586:7): [True: 1.71k, False: 13.7k]
  ------------------
  587|  1.71k|    result.exponent = kOverflow;
  588|  13.7k|  } else if (mantissa == 0) {
  ------------------
  |  Branch (588:14): [True: 758, False: 13.0k]
  ------------------
  589|    758|    result.exponent = kUnderflow;
  590|  13.0k|  } else {
  591|  13.0k|    result.exponent = exponent;
  592|  13.0k|    result.mantissa = mantissa;
  593|  13.0k|  }
  594|  15.4k|  return result;
  595|  15.4k|}
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_112EncodeResultIdEEvRKNS1_15CalculatedFloatEbPNS0_17from_chars_resultEPT_:
  407|  15.9k|                  FloatType* absl_nonnull value) {
  408|  15.9k|  if (calculated.exponent == kOverflow) {
  ------------------
  |  Branch (408:7): [True: 1.94k, False: 13.9k]
  ------------------
  409|  1.94k|    result->ec = std::errc::result_out_of_range;
  410|  1.94k|    *value = negative ? -std::numeric_limits<FloatType>::max()
  ------------------
  |  Branch (410:14): [True: 11, False: 1.93k]
  ------------------
  411|  1.94k|                      : std::numeric_limits<FloatType>::max();
  412|  1.94k|    return;
  413|  13.9k|  } else if (calculated.mantissa == 0 || calculated.exponent == kUnderflow) {
  ------------------
  |  Branch (413:14): [True: 990, False: 13.0k]
  |  Branch (413:42): [True: 0, False: 13.0k]
  ------------------
  414|    990|    result->ec = std::errc::result_out_of_range;
  415|    990|    *value = negative ? -0.0f : 0.0f;
  ------------------
  |  Branch (415:14): [True: 1, False: 989]
  ------------------
  416|    990|    return;
  417|    990|  }
  418|  13.0k|  *value = FloatTraits<FloatType>::Make(
  419|  13.0k|      static_cast<typename FloatTraits<FloatType>::mantissa_t>(
  420|  13.0k|          calculated.mantissa),
  421|  13.0k|      calculated.exponent, negative);
  422|  13.0k|}
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_111FloatTraitsIdE4MakeEmib:
  150|  13.0k|  static double Make(mantissa_t mantissa, int exponent, bool sign) {
  151|       |#ifndef ABSL_BIT_PACK_FLOATS
  152|       |    // Support ldexp no matter which namespace it's in.  Some platforms
  153|       |    // incorrectly don't put it in namespace std.
  154|       |    using namespace std;  // NOLINT
  155|       |    return sign ? -ldexp(mantissa, exponent) : ldexp(mantissa, exponent);
  156|       |#else
  157|  13.0k|    constexpr uint64_t kMantissaMask =
  158|  13.0k|        (uint64_t{1} << (kTargetMantissaBits - 1)) - 1;
  159|  13.0k|    uint64_t dbl = static_cast<uint64_t>(sign) << 63;
  160|  13.0k|    if (mantissa > kMantissaMask) {
  ------------------
  |  Branch (160:9): [True: 12.4k, False: 514]
  ------------------
  161|       |      // Normal value.
  162|       |      // Adjust by 1023 for the exponent representation bias, and an additional
  163|       |      // 52 due to the implied decimal point in the IEEE mantissa
  164|       |      // representation.
  165|  12.4k|      dbl += static_cast<uint64_t>(exponent + 1023 + kTargetMantissaBits - 1)
  166|  12.4k|             << 52;
  167|  12.4k|      mantissa &= kMantissaMask;
  168|  12.4k|    } else {
  169|       |      // subnormal value
  170|       |      assert(exponent == kMinNormalExponent);
  171|    514|    }
  172|  13.0k|    dbl += mantissa;
  173|  13.0k|    return absl::bit_cast<double>(dbl);
  174|  13.0k|#endif  // ABSL_BIT_PACK_FLOATS
  175|  13.0k|  }
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_111EiselLemireIdEEbRKNS0_16strings_internal11ParsedFloatEbPT_PNSt3__14errcE:
  687|  7.82k|                 FloatType* absl_nonnull value, std::errc* absl_nonnull ec) {
  688|  7.82k|  uint64_t man = input.mantissa;
  689|  7.82k|  int exp10 = input.exponent;
  690|  7.82k|  if (exp10 < FloatTraits<FloatType>::kEiselLemireMinInclusiveExp10) {
  ------------------
  |  Branch (690:7): [True: 236, False: 7.58k]
  ------------------
  691|    236|    *value = negative ? -0.0f : 0.0f;
  ------------------
  |  Branch (691:14): [True: 2, False: 234]
  ------------------
  692|    236|    *ec = std::errc::result_out_of_range;
  693|    236|    return true;
  694|  7.58k|  } else if (exp10 >= FloatTraits<FloatType>::kEiselLemireMaxExclusiveExp10) {
  ------------------
  |  Branch (694:14): [True: 568, False: 7.02k]
  ------------------
  695|       |    // Return max (a finite value) consistent with from_chars and DR 3081. For
  696|       |    // SimpleAtod and SimpleAtof, post-processing will return infinity.
  697|    568|    *value = negative ? -std::numeric_limits<FloatType>::max()
  ------------------
  |  Branch (697:14): [True: 194, False: 374]
  ------------------
  698|    568|                      : std::numeric_limits<FloatType>::max();
  699|    568|    *ec = std::errc::result_out_of_range;
  700|    568|    return true;
  701|    568|  }
  702|       |
  703|       |  // Assert kPower10TableMinInclusive <= exp10 < kPower10TableMaxExclusive.
  704|       |  // Equivalently, !Power10Underflow(exp10) and !Power10Overflow(exp10).
  705|  7.02k|  static_assert(
  706|  7.02k|      FloatTraits<FloatType>::kEiselLemireMinInclusiveExp10 >=
  707|  7.02k|          kPower10TableMinInclusive,
  708|  7.02k|      "(exp10-kPower10TableMinInclusive) in kPower10MantissaHighTable bounds");
  709|  7.02k|  static_assert(
  710|  7.02k|      FloatTraits<FloatType>::kEiselLemireMaxExclusiveExp10 <=
  711|  7.02k|          kPower10TableMaxExclusive,
  712|  7.02k|      "(exp10-kPower10TableMinInclusive) in kPower10MantissaHighTable bounds");
  713|       |
  714|       |  // The terse (+) comments in this function body refer to sections of the
  715|       |  // https://nigeltao.github.io/blog/2020/eisel-lemire.html blog post.
  716|       |  //
  717|       |  // That blog post discusses double precision (11 exponent bits with a -1023
  718|       |  // bias, 52 mantissa bits), but the same approach applies to single precision
  719|       |  // (8 exponent bits with a -127 bias, 23 mantissa bits). Either way, the
  720|       |  // computation here happens with 64-bit values (e.g. man) or 128-bit values
  721|       |  // (e.g. x) before finally converting to 64- or 32-bit floating point.
  722|       |  //
  723|       |  // See also "Number Parsing at a Gigabyte per Second, Software: Practice and
  724|       |  // Experience 51 (8), 2021" (https://arxiv.org/abs/2101.11408) for detail.
  725|       |
  726|       |  // (+) Normalization.
  727|  7.02k|  int clz = countl_zero(man);
  728|  7.02k|  man <<= static_cast<unsigned int>(clz);
  729|       |  // The 217706 etc magic numbers are from the Power10Exponent function.
  730|  7.02k|  uint64_t ret_exp2 =
  731|  7.02k|      static_cast<uint64_t>((217706 * exp10 >> 16) + 64 +
  732|  7.02k|                            FloatTraits<FloatType>::kExponentBias - clz);
  733|       |
  734|       |  // (+) Multiplication.
  735|  7.02k|  uint128 x = static_cast<uint128>(man) *
  736|  7.02k|              static_cast<uint128>(
  737|  7.02k|                  kPower10MantissaHighTable[exp10 - kPower10TableMinInclusive]);
  738|       |
  739|       |  // (+) Wider Approximation.
  740|  7.02k|  static constexpr uint64_t high64_mask =
  741|  7.02k|      FloatTraits<FloatType>::kEiselLemireMask;
  742|  7.02k|  if (((Uint128High64(x) & high64_mask) == high64_mask) &&
  ------------------
  |  Branch (742:7): [True: 2.52k, False: 4.49k]
  ------------------
  743|  2.52k|      (man > (std::numeric_limits<uint64_t>::max() - Uint128Low64(x)))) {
  ------------------
  |  Branch (743:7): [True: 2.15k, False: 367]
  ------------------
  744|  2.15k|    uint128 y =
  745|  2.15k|        static_cast<uint128>(man) *
  746|  2.15k|        static_cast<uint128>(
  747|  2.15k|            kPower10MantissaLowTable[exp10 - kPower10TableMinInclusive]);
  748|  2.15k|    x += Uint128High64(y);
  749|       |    // For example, parsing "4503599627370497.5" will take the if-true
  750|       |    // branch here (for double precision), since:
  751|       |    //  - x   = 0x8000000000000BFF_FFFFFFFFFFFFFFFF
  752|       |    //  - y   = 0x8000000000000BFF_7FFFFFFFFFFFF400
  753|       |    //  - man = 0xA000000000000F00
  754|       |    // Likewise, when parsing "0.0625" for single precision:
  755|       |    //  - x   = 0x7FFFFFFFFFFFFFFF_FFFFFFFFFFFFFFFF
  756|       |    //  - y   = 0x813FFFFFFFFFFFFF_8A00000000000000
  757|       |    //  - man = 0x9C40000000000000
  758|  2.15k|    if (((Uint128High64(x) & high64_mask) == high64_mask) &&
  ------------------
  |  Branch (758:9): [True: 1.49k, False: 662]
  ------------------
  759|  1.49k|        ((Uint128Low64(x) + 1) == 0) &&
  ------------------
  |  Branch (759:9): [True: 980, False: 515]
  ------------------
  760|    980|        (man > (std::numeric_limits<uint64_t>::max() - Uint128Low64(y)))) {
  ------------------
  |  Branch (760:9): [True: 980, False: 0]
  ------------------
  761|    980|      return false;
  762|    980|    }
  763|  2.15k|  }
  764|       |
  765|       |  // (+) Shifting to 54 Bits (or for single precision, to 25 bits).
  766|  6.04k|  uint64_t msb = Uint128High64(x) >> 63;
  767|  6.04k|  uint64_t ret_man =
  768|  6.04k|      Uint128High64(x) >> (msb + FloatTraits<FloatType>::kEiselLemireShift);
  769|  6.04k|  ret_exp2 -= 1 ^ msb;
  770|       |
  771|       |  // (+) Half-way Ambiguity.
  772|       |  //
  773|       |  // For example, parsing "1e+23" will take the if-true branch here (for double
  774|       |  // precision), since:
  775|       |  //  - x       = 0x54B40B1F852BDA00_0000000000000000
  776|       |  //  - ret_man = 0x002A5A058FC295ED
  777|       |  // Likewise, when parsing "20040229.0" for single precision:
  778|       |  //  - x       = 0x4C72894000000000_0000000000000000
  779|       |  //  - ret_man = 0x000000000131CA25
  780|  6.04k|  if ((Uint128Low64(x) == 0) && ((Uint128High64(x) & high64_mask) == 0) &&
  ------------------
  |  Branch (780:7): [True: 3.66k, False: 2.37k]
  |  Branch (780:33): [True: 2.60k, False: 1.06k]
  ------------------
  781|  2.60k|      ((ret_man & 3) == 1)) {
  ------------------
  |  Branch (781:7): [True: 449, False: 2.15k]
  ------------------
  782|    449|    return false;
  783|    449|  }
  784|       |
  785|       |  // (+) From 54 to 53 Bits (or for single precision, from 25 to 24 bits).
  786|  5.59k|  ret_man += ret_man & 1;  // Line From54a.
  787|  5.59k|  ret_man >>= 1;           // Line From54b.
  788|       |  // Incrementing ret_man (at line From54a) may have overflowed 54 bits (53
  789|       |  // bits after the right shift by 1 at line From54b), so adjust for that.
  790|       |  //
  791|       |  // For example, parsing "9223372036854775807" will take the if-true branch
  792|       |  // here (for double precision), since:
  793|       |  //  - ret_man = 0x0020000000000000 = (1 << 53)
  794|       |  // Likewise, when parsing "2147483647.0" for single precision:
  795|       |  //  - ret_man = 0x0000000001000000 = (1 << 24)
  796|  5.59k|  if ((ret_man >> FloatTraits<FloatType>::kTargetMantissaBits) > 0) {
  ------------------
  |  Branch (796:7): [True: 203, False: 5.38k]
  ------------------
  797|    203|    ret_exp2 += 1;
  798|       |    // Conceptually, we need a "ret_man >>= 1" in this if-block to balance
  799|       |    // incrementing ret_exp2 in the line immediately above. However, we only
  800|       |    // get here when line From54a overflowed (after adding a 1), so ret_man
  801|       |    // here is (1 << 53). Its low 53 bits are therefore all zeroes. The only
  802|       |    // remaining use of ret_man is to mask it with ((1 << 52) - 1), so only its
  803|       |    // low 52 bits matter. A "ret_man >>= 1" would have no effect in practice.
  804|       |    //
  805|       |    // We omit the "ret_man >>= 1", even if it is cheap (and this if-branch is
  806|       |    // rarely taken) and technically 'more correct', so that mutation tests
  807|       |    // that would otherwise modify or omit that "ret_man >>= 1" don't complain
  808|       |    // that such code mutations have no observable effect.
  809|    203|  }
  810|       |
  811|       |  // ret_exp2 is a uint64_t. Zero or underflow means that we're in subnormal
  812|       |  // space. max_exp2 (0x7FF for double precision, 0xFF for single precision) or
  813|       |  // above means that we're in Inf/NaN space.
  814|       |  //
  815|       |  // The if block is equivalent to (but has fewer branches than):
  816|       |  //   if ((ret_exp2 <= 0) || (ret_exp2 >= max_exp2)) { etc }
  817|       |  //
  818|       |  // For example, parsing "4.9406564584124654e-324" will take the if-true
  819|       |  // branch here, since ret_exp2 = -51.
  820|  5.59k|  static constexpr uint64_t max_exp2 =
  821|  5.59k|      (1 << FloatTraits<FloatType>::kTargetExponentBits) - 1;
  822|  5.59k|  if ((ret_exp2 - 1) >= (max_exp2 - 1)) {
  ------------------
  |  Branch (822:7): [True: 1.92k, False: 3.66k]
  ------------------
  823|  1.92k|    return false;
  824|  1.92k|  }
  825|       |
  826|       |#ifndef ABSL_BIT_PACK_FLOATS
  827|       |  if (FloatTraits<FloatType>::kTargetBits == 64) {
  828|       |    *value = FloatTraits<FloatType>::Make(
  829|       |        (ret_man & 0x000FFFFFFFFFFFFFu) | 0x0010000000000000u,
  830|       |        static_cast<int>(ret_exp2) - 1023 - 52, negative);
  831|       |    return true;
  832|       |  } else if (FloatTraits<FloatType>::kTargetBits == 32) {
  833|       |    *value = FloatTraits<FloatType>::Make(
  834|       |        (static_cast<uint32_t>(ret_man) & 0x007FFFFFu) | 0x00800000u,
  835|       |        static_cast<int>(ret_exp2) - 127 - 23, negative);
  836|       |    return true;
  837|       |  }
  838|       |#else
  839|  3.66k|  if (FloatTraits<FloatType>::kTargetBits == 64) {
  ------------------
  |  Branch (839:7): [True: 3.66k, Folded]
  ------------------
  840|  3.66k|    uint64_t ret_bits = (ret_exp2 << 52) | (ret_man & 0x000FFFFFFFFFFFFFu);
  841|  3.66k|    if (negative) {
  ------------------
  |  Branch (841:9): [True: 353, False: 3.31k]
  ------------------
  842|    353|      ret_bits |= 0x8000000000000000u;
  843|    353|    }
  844|  3.66k|    *value = static_cast<FloatType>(absl::bit_cast<double>(ret_bits));
  845|  3.66k|    return true;
  846|  3.66k|  } else if (FloatTraits<FloatType>::kTargetBits == 32) {
  ------------------
  |  Branch (846:14): [Folded, False: 0]
  ------------------
  847|      0|    uint32_t ret_bits = (static_cast<uint32_t>(ret_exp2) << 23) |
  848|      0|                        (static_cast<uint32_t>(ret_man) & 0x007FFFFFu);
  849|      0|    if (negative) {
  ------------------
  |  Branch (849:9): [True: 0, False: 0]
  ------------------
  850|      0|      ret_bits |= 0x80000000u;
  851|      0|    }
  852|      0|    *value = static_cast<FloatType>(absl::bit_cast<float>(ret_bits));
  853|      0|    return true;
  854|      0|  }
  855|      0|#endif  // ABSL_BIT_PACK_FLOATS
  856|      0|  return false;
  857|  3.66k|}
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_126CalculateFromParsedDecimalIdEENS1_15CalculatedFloatERKNS0_16strings_internal11ParsedFloatE:
  617|  11.9k|    const strings_internal::ParsedFloat& parsed_decimal) {
  618|  11.9k|  CalculatedFloat result;
  619|       |
  620|       |  // Large or small enough decimal exponents will always result in overflow
  621|       |  // or underflow.
  622|  11.9k|  if (Power10Underflow(parsed_decimal.exponent)) {
  ------------------
  |  Branch (622:7): [True: 232, False: 11.7k]
  ------------------
  623|    232|    result.exponent = kUnderflow;
  624|    232|    return result;
  625|  11.7k|  } else if (Power10Overflow(parsed_decimal.exponent)) {
  ------------------
  |  Branch (625:14): [True: 230, False: 11.4k]
  ------------------
  626|    230|    result.exponent = kOverflow;
  627|    230|    return result;
  628|    230|  }
  629|       |
  630|       |  // Otherwise convert our power of 10 into a power of 2 times an integer
  631|       |  // mantissa, and multiply this by our parsed decimal mantissa.
  632|  11.4k|  uint128 wide_binary_mantissa = parsed_decimal.mantissa;
  633|  11.4k|  wide_binary_mantissa *= Power10Mantissa(parsed_decimal.exponent);
  634|  11.4k|  int binary_exponent = Power10Exponent(parsed_decimal.exponent);
  635|       |
  636|       |  // Discard bits that are inaccurate due to truncation error.  The magic
  637|       |  // `mantissa_width` constants below are justified in
  638|       |  // https://abseil.io/about/design/charconv. They represent the number of bits
  639|       |  // in `wide_binary_mantissa` that are guaranteed to be unaffected by error
  640|       |  // propagation.
  641|  11.4k|  bool mantissa_exact;
  642|  11.4k|  int mantissa_width;
  643|  11.4k|  if (parsed_decimal.subrange_begin) {
  ------------------
  |  Branch (643:7): [True: 8.14k, False: 3.35k]
  ------------------
  644|       |    // Truncated mantissa
  645|  8.14k|    mantissa_width = 58;
  646|  8.14k|    mantissa_exact = false;
  647|  8.14k|    binary_exponent +=
  648|  8.14k|        TruncateToBitWidth(mantissa_width, &wide_binary_mantissa);
  649|  8.14k|  } else if (!Power10Exact(parsed_decimal.exponent)) {
  ------------------
  |  Branch (649:14): [True: 2.90k, False: 449]
  ------------------
  650|       |    // Exact mantissa, truncated power of ten
  651|  2.90k|    mantissa_width = 63;
  652|  2.90k|    mantissa_exact = false;
  653|  2.90k|    binary_exponent +=
  654|  2.90k|        TruncateToBitWidth(mantissa_width, &wide_binary_mantissa);
  655|  2.90k|  } else {
  656|       |    // Product is exact
  657|    449|    mantissa_width = BitWidth(wide_binary_mantissa);
  658|    449|    mantissa_exact = true;
  659|    449|  }
  660|       |
  661|       |  // Shift into an FloatType-sized mantissa, and round to nearest.
  662|  11.4k|  const int shift =
  663|  11.4k|      NormalizedShiftSize<FloatType>(mantissa_width, binary_exponent);
  664|  11.4k|  bool result_exact;
  665|  11.4k|  binary_exponent += shift;
  666|  11.4k|  uint64_t binary_mantissa = ShiftRightAndRound(wide_binary_mantissa, shift,
  667|  11.4k|                                                mantissa_exact, &result_exact);
  668|  11.4k|  if (!result_exact) {
  ------------------
  |  Branch (668:7): [True: 9.45k, False: 2.03k]
  ------------------
  669|       |    // We could not determine the rounding direction using int128 math.  Use
  670|       |    // full resolution math instead.
  671|  9.45k|    if (MustRoundUp(binary_mantissa, binary_exponent, parsed_decimal)) {
  ------------------
  |  Branch (671:9): [True: 2.29k, False: 7.16k]
  ------------------
  672|  2.29k|      binary_mantissa += 1;
  673|  2.29k|    }
  674|  9.45k|  }
  675|       |
  676|  11.4k|  return CalculatedFloatFromRawValues<FloatType>(binary_mantissa,
  677|  11.4k|                                                 binary_exponent);
  678|  11.9k|}
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_116Power10UnderflowEi:
  288|  11.9k|bool Power10Underflow(int n) { return n < kPower10TableMinInclusive; }
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_115Power10OverflowEi:
  284|  11.7k|bool Power10Overflow(int n) { return n >= kPower10TableMaxExclusive; }
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_115Power10MantissaEi:
  270|  11.4k|uint64_t Power10Mantissa(int n) {
  271|  11.4k|  return kPower10MantissaHighTable[n - kPower10TableMinInclusive];
  272|  11.4k|}
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_115Power10ExponentEi:
  274|  11.4k|int Power10Exponent(int n) {
  275|       |  // The 217706 etc magic numbers encode the results as a formula instead of a
  276|       |  // table. Their equivalence (over the kPower10TableMinInclusive ..
  277|       |  // kPower10TableMaxExclusive range) is confirmed by
  278|       |  // https://github.com/google/wuffs/blob/315b2e52625ebd7b02d8fac13e3cd85ea374fb80/script/print-mpb-powers-of-10.go
  279|  11.4k|  return (217706 * n >> 16) - 63;
  280|  11.4k|}
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_118TruncateToBitWidthEiPNS0_7uint128E:
  348|  11.0k|int TruncateToBitWidth(int bit_width, uint128* absl_nonnull value) {
  349|  11.0k|  const int current_bit_width = BitWidth(*value);
  350|  11.0k|  const int shift = current_bit_width - bit_width;
  351|  11.0k|  *value >>= shift;
  352|  11.0k|  return shift;
  353|  11.0k|}
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_112Power10ExactEi:
  293|  3.35k|bool Power10Exact(int n) { return n >= 0 && n <= 27; }
  ------------------
  |  Branch (293:35): [True: 1.93k, False: 1.41k]
  |  Branch (293:45): [True: 449, False: 1.48k]
  ------------------
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_18BitWidthENS0_7uint128E:
  317|  11.4k|int BitWidth(uint128 value) {
  318|  11.4k|  if (Uint128High64(value) == 0) {
  ------------------
  |  Branch (318:7): [True: 530, False: 10.9k]
  ------------------
  319|       |    // This static_cast is only needed when using a std::bit_width()
  320|       |    // implementation that does not have the fix for LWG 3656 applied.
  321|    530|    return static_cast<int>(bit_width(Uint128Low64(value)));
  322|    530|  }
  323|  10.9k|  return 128 - countl_zero(Uint128High64(value));
  324|  11.4k|}
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_111MustRoundUpEmiRKNS0_16strings_internal11ParsedFloatE:
  510|  9.45k|                 const strings_internal::ParsedFloat& parsed_decimal) {
  511|       |  // 768 is the number of digits needed in the worst case.  We could determine a
  512|       |  // better limit dynamically based on the value of parsed_decimal.exponent.
  513|       |  // This would optimize pathological input cases only.  (Sane inputs won't have
  514|       |  // hundreds of digits of mantissa.)
  515|  9.45k|  absl::strings_internal::BigUnsigned<84> exact_mantissa;
  516|  9.45k|  int exact_exponent = exact_mantissa.ReadFloatMantissa(parsed_decimal, 768);
  517|       |
  518|       |  // Adjust the `guess` arguments to be halfway between A and B.
  519|  9.45k|  guess_mantissa = guess_mantissa * 2 + 1;
  520|  9.45k|  guess_exponent -= 1;
  521|       |
  522|       |  // In our comparison:
  523|       |  // lhs = exact = exact_mantissa * 10**exact_exponent
  524|       |  //             = exact_mantissa * 5**exact_exponent * 2**exact_exponent
  525|       |  // rhs = guess = guess_mantissa * 2**guess_exponent
  526|       |  //
  527|       |  // Because we are doing integer math, we can't directly deal with negative
  528|       |  // exponents.  We instead move these to the other side of the inequality.
  529|  9.45k|  absl::strings_internal::BigUnsigned<84>& lhs = exact_mantissa;
  530|  9.45k|  int comparison;
  531|  9.45k|  if (exact_exponent >= 0) {
  ------------------
  |  Branch (531:7): [True: 3.29k, False: 6.16k]
  ------------------
  532|  3.29k|    lhs.MultiplyByFiveToTheNth(exact_exponent);
  533|  3.29k|    absl::strings_internal::BigUnsigned<84> rhs(guess_mantissa);
  534|       |    // There are powers of 2 on both sides of the inequality; reduce this to
  535|       |    // a single bit-shift.
  536|  3.29k|    if (exact_exponent > guess_exponent) {
  ------------------
  |  Branch (536:9): [True: 0, False: 3.29k]
  ------------------
  537|      0|      lhs.ShiftLeft(exact_exponent - guess_exponent);
  538|  3.29k|    } else {
  539|  3.29k|      rhs.ShiftLeft(guess_exponent - exact_exponent);
  540|  3.29k|    }
  541|  3.29k|    comparison = Compare(lhs, rhs);
  542|  6.16k|  } else {
  543|       |    // Move the power of 5 to the other side of the equation, giving us:
  544|       |    // lhs = exact_mantissa * 2**exact_exponent
  545|       |    // rhs = guess_mantissa * 5**(-exact_exponent) * 2**guess_exponent
  546|  6.16k|    absl::strings_internal::BigUnsigned<84> rhs =
  547|  6.16k|        absl::strings_internal::BigUnsigned<84>::FiveToTheNth(-exact_exponent);
  548|  6.16k|    rhs.MultiplyBy(guess_mantissa);
  549|  6.16k|    if (exact_exponent > guess_exponent) {
  ------------------
  |  Branch (549:9): [True: 2.06k, False: 4.09k]
  ------------------
  550|  2.06k|      lhs.ShiftLeft(exact_exponent - guess_exponent);
  551|  4.09k|    } else {
  552|  4.09k|      rhs.ShiftLeft(guess_exponent - exact_exponent);
  553|  4.09k|    }
  554|  6.16k|    comparison = Compare(lhs, rhs);
  555|  6.16k|  }
  556|  9.45k|  if (comparison < 0) {
  ------------------
  |  Branch (556:7): [True: 6.50k, False: 2.94k]
  ------------------
  557|  6.50k|    return false;
  558|  6.50k|  } else if (comparison > 0) {
  ------------------
  |  Branch (558:14): [True: 1.91k, False: 1.03k]
  ------------------
  559|  1.91k|    return true;
  560|  1.91k|  } else {
  561|       |    // When lhs == rhs, the decimal input is exactly between A and B.
  562|       |    // Round towards even -- round up only if the low bit of the initial
  563|       |    // `guess_mantissa` was a 1.  We shifted guess_mantissa left 1 bit at
  564|       |    // the beginning of this function, so test the 2nd bit here.
  565|  1.03k|    return (guess_mantissa & 2) == 2;
  566|  1.03k|  }
  567|  9.45k|}

_ZN4absl12lts_20260526anENS0_12chars_formatES1_:
   92|   119k|inline constexpr chars_format operator&(chars_format lhs, chars_format rhs) {
   93|   119k|  return static_cast<chars_format>(static_cast<int>(lhs) &
   94|   119k|                                   static_cast<int>(rhs));
   95|   119k|}

_ZN4absl12lts_2026052619WebSafeBase64EscapeENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
 1123|      2|std::string WebSafeBase64Escape(absl::string_view src) {
 1124|      2|  return Base64EscapeToStringInternal(
 1125|      2|      reinterpret_cast<const unsigned char*>(src.data()), src.size(), false,
 1126|      2|      kWebSafeBase64Chars);
 1127|      2|}
escaping.cc:_ZN4absl12lts_2026052612_GLOBAL__N_128Base64EscapeToStringInternalEPKhmbPKc:
  615|      2|                                         const char* base64_chars) {
  616|      2|  std::string escaped;
  617|      2|  const size_t calc_escaped_size =
  618|      2|      strings_internal::CalculateBase64EscapedLenInternal(szsrc, do_padding);
  619|      2|  StringResizeAndOverwrite(
  620|      2|      escaped, calc_escaped_size,
  621|      2|      [src, szsrc, base64_chars, do_padding](char* buf, size_t buf_size) {
  622|      2|        const size_t escaped_len = Base64EscapeInternal(
  623|      2|            src, szsrc, buf, buf_size, base64_chars, do_padding);
  624|      2|        assert(escaped_len == buf_size);
  625|      2|        return escaped_len;
  626|      2|      });
  627|      2|  return escaped;
  628|      2|}
escaping.cc:_ZZN4absl12lts_2026052612_GLOBAL__N_128Base64EscapeToStringInternalEPKhmbPKcENK3$_0clEPcm:
  621|      2|      [src, szsrc, base64_chars, do_padding](char* buf, size_t buf_size) {
  622|      2|        const size_t escaped_len = Base64EscapeInternal(
  623|      2|            src, szsrc, buf, buf_size, base64_chars, do_padding);
  624|       |        assert(escaped_len == buf_size);
  625|      2|        return escaped_len;
  626|      2|      });
escaping.cc:_ZN4absl12lts_2026052612_GLOBAL__N_120Base64EscapeInternalEPKhmPcmPKcb:
  498|      2|                            bool do_padding) {
  499|      2|  constexpr char kPad64 = '=';
  500|       |
  501|      2|  constexpr size_t kMaxSize = (std::numeric_limits<size_t>::max() - 1) / 4 * 3;
  502|      2|  if (ABSL_PREDICT_FALSE(szsrc > kMaxSize || szsrc * 4 > szdest * 3)) return 0;
  ------------------
  |  |  190|      4|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 2]
  |  |  |  Branch (190:49): [Folded, False: 2]
  |  |  |  Branch (190:59): [True: 0, False: 2]
  |  |  |  Branch (190:59): [True: 0, False: 2]
  |  |  ------------------
  ------------------
  503|       |
  504|      2|  char* cur_dest = dest;
  505|      2|  const unsigned char* cur_src = src;
  506|       |
  507|      2|  char* const limit_dest = dest + szdest;
  508|      2|  const unsigned char* const limit_src = src + szsrc;
  509|       |
  510|       |  // (from https://tools.ietf.org/html/rfc3548)
  511|       |  // Special processing is performed if fewer than 24 bits are available
  512|       |  // at the end of the data being encoded.  A full encoding quantum is
  513|       |  // always completed at the end of a quantity.  When fewer than 24 input
  514|       |  // bits are available in an input group, zero bits are added (on the
  515|       |  // right) to form an integral number of 6-bit groups.
  516|       |  //
  517|       |  // If do_padding is true, padding at the end of the data is performed. This
  518|       |  // output padding uses the '=' character.
  519|       |
  520|       |  // Three bytes of data encodes to four characters of cyphertext.
  521|       |  // So we can pump through three-byte chunks atomically.
  522|      2|  if (szsrc >= 3) {                    // "limit_src - 3" is UB if szsrc < 3.
  ------------------
  |  Branch (522:7): [True: 2, False: 0]
  ------------------
  523|     22|    while (cur_src < limit_src - 3) {  // While we have >= 32 bits.
  ------------------
  |  Branch (523:12): [True: 20, False: 2]
  ------------------
  524|     20|      uint32_t in = absl::big_endian::Load32(cur_src) >> 8;
  525|       |
  526|     20|      cur_dest[0] = base64[in >> 18];
  527|     20|      in &= 0x3FFFF;
  528|     20|      cur_dest[1] = base64[in >> 12];
  529|     20|      in &= 0xFFF;
  530|     20|      cur_dest[2] = base64[in >> 6];
  531|     20|      in &= 0x3F;
  532|     20|      cur_dest[3] = base64[in];
  533|       |
  534|     20|      cur_dest += 4;
  535|     20|      cur_src += 3;
  536|     20|    }
  537|      2|  }
  538|       |  // To save time, we didn't update szdest or szsrc in the loop.  So do it now.
  539|      2|  szdest = static_cast<size_t>(limit_dest - cur_dest);
  540|      2|  szsrc = static_cast<size_t>(limit_src - cur_src);
  541|       |
  542|       |  /* now deal with the tail (<=3 bytes) */
  543|      2|  switch (szsrc) {
  544|      0|    case 0:
  ------------------
  |  Branch (544:5): [True: 0, False: 2]
  ------------------
  545|       |      // Nothing left; nothing more to do.
  546|      0|      break;
  547|      0|    case 1: {
  ------------------
  |  Branch (547:5): [True: 0, False: 2]
  ------------------
  548|       |      // One byte left: this encodes to two characters, and (optionally)
  549|       |      // two pad characters to round out the four-character cypherblock.
  550|      0|      if (szdest < 2) return 0;
  ------------------
  |  Branch (550:11): [True: 0, False: 0]
  ------------------
  551|      0|      uint32_t in = cur_src[0];
  552|      0|      cur_dest[0] = base64[in >> 2];
  553|      0|      in &= 0x3;
  554|      0|      cur_dest[1] = base64[in << 4];
  555|      0|      cur_dest += 2;
  556|      0|      szdest -= 2;
  557|      0|      if (do_padding) {
  ------------------
  |  Branch (557:11): [True: 0, False: 0]
  ------------------
  558|      0|        if (szdest < 2) return 0;
  ------------------
  |  Branch (558:13): [True: 0, False: 0]
  ------------------
  559|      0|        cur_dest[0] = kPad64;
  560|      0|        cur_dest[1] = kPad64;
  561|      0|        cur_dest += 2;
  562|      0|        szdest -= 2;
  563|      0|      }
  564|      0|      break;
  565|      0|    }
  566|      2|    case 2: {
  ------------------
  |  Branch (566:5): [True: 2, False: 0]
  ------------------
  567|       |      // Two bytes left: this encodes to three characters, and (optionally)
  568|       |      // one pad character to round out the four-character cypherblock.
  569|      2|      if (szdest < 3) return 0;
  ------------------
  |  Branch (569:11): [True: 0, False: 2]
  ------------------
  570|      2|      uint32_t in = absl::big_endian::Load16(cur_src);
  571|      2|      cur_dest[0] = base64[in >> 10];
  572|      2|      in &= 0x3FF;
  573|      2|      cur_dest[1] = base64[in >> 4];
  574|      2|      in &= 0x00F;
  575|      2|      cur_dest[2] = base64[in << 2];
  576|      2|      cur_dest += 3;
  577|      2|      szdest -= 3;
  578|      2|      if (do_padding) {
  ------------------
  |  Branch (578:11): [True: 0, False: 2]
  ------------------
  579|      0|        if (szdest < 1) return 0;
  ------------------
  |  Branch (579:13): [True: 0, False: 0]
  ------------------
  580|      0|        cur_dest[0] = kPad64;
  581|      0|        cur_dest += 1;
  582|      0|        szdest -= 1;
  583|      0|      }
  584|      2|      break;
  585|      2|    }
  586|      2|    case 3: {
  ------------------
  |  Branch (586:5): [True: 0, False: 2]
  ------------------
  587|       |      // Three bytes left: same as in the big loop above.  We can't do this in
  588|       |      // the loop because the loop above always reads 4 bytes, and the fourth
  589|       |      // byte is past the end of the input.
  590|      0|      if (szdest < 4) return 0;
  ------------------
  |  Branch (590:11): [True: 0, False: 0]
  ------------------
  591|      0|      uint32_t in =
  592|      0|          (uint32_t{cur_src[0]} << 16) + absl::big_endian::Load16(cur_src + 1);
  593|      0|      cur_dest[0] = base64[in >> 18];
  594|      0|      in &= 0x3FFFF;
  595|      0|      cur_dest[1] = base64[in >> 12];
  596|      0|      in &= 0xFFF;
  597|      0|      cur_dest[2] = base64[in >> 6];
  598|      0|      in &= 0x3F;
  599|      0|      cur_dest[3] = base64[in];
  600|      0|      cur_dest += 4;
  601|      0|      szdest -= 4;
  602|      0|      break;
  603|      0|    }
  604|      0|    default:
  ------------------
  |  Branch (604:5): [True: 0, False: 2]
  ------------------
  605|       |      // Should not be reached: blocks of 4 bytes are handled
  606|       |      // in the while loop before this switch statement.
  607|      0|      ABSL_RAW_LOG(FATAL, "Logic problem? szsrc = %zu", szsrc);
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  608|      0|      break;
  609|      2|  }
  610|      2|  return static_cast<size_t>(cur_dest - dest);
  611|      2|}

_ZN4absl12lts_2026052616strings_internal11BigUnsignedILi84EE17ReadFloatMantissaERKNS1_11ParsedFloatEi:
  172|  9.45k|                                              int significant_digits) {
  173|  9.45k|  SetToZero();
  174|  9.45k|  assert(fp.type == FloatType::kNumber);
  175|       |
  176|  9.45k|  if (fp.subrange_begin == nullptr) {
  ------------------
  |  Branch (176:7): [True: 1.80k, False: 7.64k]
  ------------------
  177|       |    // We already exactly parsed the mantissa, so no more work is necessary.
  178|  1.80k|    words_[0] = fp.mantissa & 0xffffffffu;
  179|  1.80k|    words_[1] = fp.mantissa >> 32;
  180|  1.80k|    if (words_[1]) {
  ------------------
  |  Branch (180:9): [True: 557, False: 1.25k]
  ------------------
  181|    557|      size_ = 2;
  182|  1.25k|    } else if (words_[0]) {
  ------------------
  |  Branch (182:16): [True: 1.25k, False: 0]
  ------------------
  183|  1.25k|      size_ = 1;
  184|  1.25k|    }
  185|  1.80k|    return fp.exponent;
  186|  1.80k|  }
  187|  7.64k|  int exponent_adjust =
  188|  7.64k|      ReadDigits(fp.subrange_begin, fp.subrange_end, significant_digits);
  189|  7.64k|  return fp.literal_exponent + exponent_adjust;
  190|  9.45k|}
_ZN4absl12lts_2026052616strings_internal11BigUnsignedILi84EE12FiveToTheNthEi:
  289|  6.16k|    int n) {
  290|  6.16k|  BigUnsigned answer(1u);
  291|       |
  292|       |  // Seed from the table of large powers, if possible.
  293|  6.16k|  bool first_pass = true;
  294|  12.5k|  while (n >= kLargePowerOfFiveStep) {
  ------------------
  |  Branch (294:10): [True: 6.38k, False: 6.16k]
  ------------------
  295|  6.38k|    int big_power =
  296|  6.38k|        std::min(n / kLargePowerOfFiveStep, kLargestPowerOfFiveIndex);
  297|  6.38k|    if (first_pass) {
  ------------------
  |  Branch (297:9): [True: 3.86k, False: 2.52k]
  ------------------
  298|       |      // just copy, rather than multiplying by 1
  299|  3.86k|      std::copy_n(LargePowerOfFiveData(big_power),
  300|  3.86k|                  LargePowerOfFiveSize(big_power), answer.words_);
  301|  3.86k|      answer.size_ = LargePowerOfFiveSize(big_power);
  302|  3.86k|      first_pass = false;
  303|  3.86k|    } else {
  304|  2.52k|      answer.MultiplyBy(LargePowerOfFiveSize(big_power),
  305|  2.52k|                        LargePowerOfFiveData(big_power));
  306|  2.52k|    }
  307|  6.38k|    n -= kLargePowerOfFiveStep * big_power;
  308|  6.38k|  }
  309|  6.16k|  answer.MultiplyByFiveToTheNth(n);
  310|  6.16k|  return answer;
  311|  6.16k|}
_ZN4absl12lts_2026052616strings_internal11BigUnsignedILi84EE10ReadDigitsEPKcS5_i:
  194|  7.64k|                                       int significant_digits) {
  195|  7.64k|  assert(significant_digits <= Digits10() + 1);
  196|  7.64k|  SetToZero();
  197|       |
  198|  7.64k|  bool after_decimal_point = false;
  199|       |  // Discard any leading zeroes before the decimal point
  200|  7.84k|  while (begin < end && *begin == '0') {
  ------------------
  |  Branch (200:10): [True: 7.84k, False: 0]
  |  Branch (200:25): [True: 199, False: 7.64k]
  ------------------
  201|    199|    ++begin;
  202|    199|  }
  203|  7.64k|  int dropped_digits = 0;
  204|       |  // Discard any trailing zeroes.  These may or may not be after the decimal
  205|       |  // point.
  206|   490k|  while (begin < end && *std::prev(end) == '0') {
  ------------------
  |  Branch (206:10): [True: 490k, False: 0]
  |  Branch (206:25): [True: 482k, False: 7.64k]
  ------------------
  207|   482k|    --end;
  208|   482k|    ++dropped_digits;
  209|   482k|  }
  210|  7.64k|  if (begin < end && *std::prev(end) == '.') {
  ------------------
  |  Branch (210:7): [True: 7.64k, False: 0]
  |  Branch (210:22): [True: 279, False: 7.37k]
  ------------------
  211|       |    // If the string ends in '.', either before or after dropping zeroes, then
  212|       |    // drop the decimal point and look for more digits to drop.
  213|    279|    dropped_digits = 0;
  214|    279|    --end;
  215|    493|    while (begin < end && *std::prev(end) == '0') {
  ------------------
  |  Branch (215:12): [True: 493, False: 0]
  |  Branch (215:27): [True: 214, False: 279]
  ------------------
  216|    214|      --end;
  217|    214|      ++dropped_digits;
  218|    214|    }
  219|  7.37k|  } else if (dropped_digits) {
  ------------------
  |  Branch (219:14): [True: 439, False: 6.93k]
  ------------------
  220|       |    // We dropped digits, and aren't sure if they're before or after the decimal
  221|       |    // point.  Figure that out now.
  222|    439|    const char* dp = std::find(begin, end, '.');
  223|    439|    if (dp != end) {
  ------------------
  |  Branch (223:9): [True: 231, False: 208]
  ------------------
  224|       |      // The dropped trailing digits were after the decimal point, so don't
  225|       |      // count them.
  226|    231|      dropped_digits = 0;
  227|    231|    }
  228|    439|  }
  229|       |  // Any non-fraction digits we dropped need to be accounted for in our exponent
  230|       |  // adjustment.
  231|  7.64k|  int exponent_adjust = dropped_digits;
  232|       |
  233|  7.64k|  uint32_t queued = 0;
  234|  7.64k|  int digits_queued = 0;
  235|  1.97M|  for (; begin != end && significant_digits > 0; ++begin) {
  ------------------
  |  Branch (235:10): [True: 1.96M, False: 6.74k]
  |  Branch (235:26): [True: 1.96M, False: 903]
  ------------------
  236|  1.96M|    if (*begin == '.') {
  ------------------
  |  Branch (236:9): [True: 5.38k, False: 1.95M]
  ------------------
  237|  5.38k|      after_decimal_point = true;
  238|  5.38k|      continue;
  239|  5.38k|    }
  240|  1.95M|    if (after_decimal_point) {
  ------------------
  |  Branch (240:9): [True: 1.86M, False: 97.1k]
  ------------------
  241|       |      // For each fractional digit we emit in our parsed integer, adjust our
  242|       |      // decimal exponent to compensate.
  243|  1.86M|      --exponent_adjust;
  244|  1.86M|    }
  245|  1.95M|    char digit = (*begin - '0');
  246|  1.95M|    --significant_digits;
  247|  1.95M|    if (significant_digits == 0 && std::next(begin) != end &&
  ------------------
  |  Branch (247:9): [True: 1.10k, False: 1.95M]
  |  Branch (247:36): [True: 903, False: 199]
  ------------------
  248|    903|        (digit == 0 || digit == 5)) {
  ------------------
  |  Branch (248:10): [True: 207, False: 696]
  |  Branch (248:24): [True: 431, False: 265]
  ------------------
  249|       |      // If this is the very last significant digit, but insignificant digits
  250|       |      // remain, we know that the last of those remaining significant digits is
  251|       |      // nonzero.  (If it wasn't, we would have stripped it before we got here.)
  252|       |      // So if this final digit is a 0 or 5, adjust it upward by 1.
  253|       |      //
  254|       |      // This adjustment is what allows incredibly large mantissas ending in
  255|       |      // 500000...000000000001 to correctly round up, rather than to nearest.
  256|    638|      ++digit;
  257|    638|    }
  258|  1.95M|    queued = 10 * queued + static_cast<uint32_t>(digit);
  259|  1.95M|    ++digits_queued;
  260|  1.95M|    if (digits_queued == kMaxSmallPowerOfTen) {
  ------------------
  |  Branch (260:9): [True: 215k, False: 1.74M]
  ------------------
  261|   215k|      MultiplyBy(kTenToNth[kMaxSmallPowerOfTen]);
  262|   215k|      AddWithCarry(0, queued);
  263|   215k|      queued = digits_queued = 0;
  264|   215k|    }
  265|  1.95M|  }
  266|       |  // Encode any remaining digits.
  267|  7.64k|  if (digits_queued) {
  ------------------
  |  Branch (267:7): [True: 6.32k, False: 1.32k]
  ------------------
  268|  6.32k|    MultiplyBy(kTenToNth[digits_queued]);
  269|  6.32k|    AddWithCarry(0, queued);
  270|  6.32k|  }
  271|       |
  272|       |  // If any insignificant digits remain, we will drop them.  But if we have not
  273|       |  // yet read the decimal point, then we have to adjust the exponent to account
  274|       |  // for the dropped digits.
  275|  7.64k|  if (begin < end && !after_decimal_point) {
  ------------------
  |  Branch (275:7): [True: 903, False: 6.74k]
  |  Branch (275:22): [True: 2, False: 901]
  ------------------
  276|       |    // This call to std::find will result in a pointer either to the decimal
  277|       |    // point, or to the end of our buffer if there was none.
  278|       |    //
  279|       |    // Either way, [begin, decimal_point) will contain the set of dropped digits
  280|       |    // that require an exponent adjustment.
  281|      2|    const char* decimal_point = std::find(begin, end, '.');
  282|      2|    exponent_adjust += static_cast<int>(decimal_point - begin);
  283|      2|  }
  284|  7.64k|  return exponent_adjust;
  285|  7.64k|}
_ZN4absl12lts_2026052616strings_internal11BigUnsignedILi84EE12MultiplyStepEiPKjii:
  316|   282k|                                          int other_size, int step) {
  317|   282k|  int this_i = std::min(original_size - 1, step);
  318|   282k|  int other_i = step - this_i;
  319|       |
  320|   282k|  uint64_t this_word = 0;
  321|   282k|  uint64_t carry = 0;
  322|  1.75M|  for (; this_i >= 0 && other_i < other_size; --this_i, ++other_i) {
  ------------------
  |  Branch (322:10): [True: 1.71M, False: 41.7k]
  |  Branch (322:25): [True: 1.47M, False: 240k]
  ------------------
  323|  1.47M|    uint64_t product = words_[this_i];
  324|  1.47M|    product *= other_words[other_i];
  325|  1.47M|    this_word += product;
  326|  1.47M|    carry += (this_word >> 32);
  327|  1.47M|    this_word &= 0xffffffff;
  328|  1.47M|  }
  329|   282k|  AddWithCarry(step + 1, carry);
  330|   282k|  words_[step] = this_word & 0xffffffff;
  331|   282k|  if (this_word > 0 && size_ <= step) {
  ------------------
  |  Branch (331:7): [True: 282k, False: 0]
  |  Branch (331:24): [True: 4.64k, False: 277k]
  ------------------
  332|  4.64k|    size_ = step + 1;
  333|  4.64k|  }
  334|   282k|}
charconv_bigint.cc:_ZN4absl12lts_2026052616strings_internal12_GLOBAL__N_120LargePowerOfFiveDataEi:
  152|  6.38k|const uint32_t* LargePowerOfFiveData(int i) {
  153|  6.38k|  return kLargePowersOfFive + i * (i - 1);
  154|  6.38k|}
charconv_bigint.cc:_ZN4absl12lts_2026052616strings_internal12_GLOBAL__N_120LargePowerOfFiveSizeEi:
  158|  10.2k|int LargePowerOfFiveSize(int i) { return 2 * i; }

_ZN4absl12lts_2026052616strings_internal11BigUnsignedILi84EEC2Ev:
   62|  9.45k|  BigUnsigned() : size_(0), words_{} {}
_ZN4absl12lts_2026052616strings_internal11BigUnsignedILi84EE22MultiplyByFiveToTheNthEi:
  174|  9.45k|  void MultiplyByFiveToTheNth(int n) {
  175|  52.3k|    while (n >= kMaxSmallPowerOfFive) {
  ------------------
  |  Branch (175:12): [True: 42.8k, False: 9.45k]
  ------------------
  176|  42.8k|      MultiplyBy(kFiveToNth[kMaxSmallPowerOfFive]);
  177|  42.8k|      n -= kMaxSmallPowerOfFive;
  178|  42.8k|    }
  179|  9.45k|    if (n > 0) {
  ------------------
  |  Branch (179:9): [True: 7.29k, False: 2.16k]
  ------------------
  180|  7.29k|      MultiplyBy(kFiveToNth[n]);
  181|  7.29k|    }
  182|  9.45k|  }
_ZN4absl12lts_2026052616strings_internal11BigUnsignedILi84EE10MultiplyByEj:
  140|   271k|  void MultiplyBy(uint32_t v) {
  141|   271k|    if (size_ == 0 || v == 1) {
  ------------------
  |  Branch (141:9): [True: 7.72k, False: 264k]
  |  Branch (141:23): [True: 0, False: 264k]
  ------------------
  142|  7.72k|      return;
  143|  7.72k|    }
  144|   264k|    if (v == 0) {
  ------------------
  |  Branch (144:9): [True: 0, False: 264k]
  ------------------
  145|      0|      SetToZero();
  146|      0|      return;
  147|      0|    }
  148|   264k|    const uint64_t factor = v;
  149|   264k|    uint64_t window = 0;
  150|  8.40M|    for (int i = 0; i < size_; ++i) {
  ------------------
  |  Branch (150:21): [True: 8.13M, False: 264k]
  ------------------
  151|  8.13M|      window += factor * words_[i];
  152|  8.13M|      words_[i] = window & 0xffffffff;
  153|  8.13M|      window >>= 32;
  154|  8.13M|    }
  155|       |    // If carry bits remain and there's space for them, grow size_.
  156|   264k|    if (window && size_ < max_words) {
  ------------------
  |  Branch (156:9): [True: 242k, False: 22.0k]
  |  Branch (156:19): [True: 242k, False: 0]
  ------------------
  157|   242k|      words_[size_] = window & 0xffffffff;
  158|   242k|      ++size_;
  159|   242k|    }
  160|   264k|  }
_ZN4absl12lts_2026052616strings_internal11BigUnsignedILi84EE9SetToZeroEv:
  209|  17.1k|  void SetToZero() {
  210|  17.1k|    std::fill_n(words_, size_, 0u);
  211|  17.1k|    size_ = 0;
  212|  17.1k|  }
_ZN4absl12lts_2026052616strings_internal11BigUnsignedILi84EEC2Em:
   64|  9.45k|      : size_((v >> 32) ? 2 : v ? 1 : 0),
  ------------------
  |  Branch (64:15): [True: 3.29k, False: 6.16k]
  |  Branch (64:31): [True: 6.16k, False: 0]
  ------------------
   65|  9.45k|        words_{static_cast<uint32_t>(v & 0xffffffffu),
   66|  9.45k|               static_cast<uint32_t>(v >> 32)} {}
_ZN4absl12lts_2026052616strings_internal11BigUnsignedILi84EE9ShiftLeftEi:
  102|  9.45k|  void ShiftLeft(int count) {
  103|  9.45k|    if (count > 0) {
  ------------------
  |  Branch (103:9): [True: 9.10k, False: 349]
  ------------------
  104|  9.10k|      const int word_shift = count / 32;
  105|  9.10k|      if (word_shift >= max_words) {
  ------------------
  |  Branch (105:11): [True: 0, False: 9.10k]
  ------------------
  106|      0|        SetToZero();
  107|      0|        return;
  108|      0|      }
  109|  9.10k|      size_ = (std::min)(size_ + word_shift, max_words);
  110|  9.10k|      count %= 32;
  111|  9.10k|      if (count == 0) {
  ------------------
  |  Branch (111:11): [True: 259, False: 8.84k]
  ------------------
  112|       |// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=warray-bounds
  113|       |// shows a lot of bogus -Warray-bounds warnings under GCC.
  114|       |// This is not the only one in Abseil.
  115|       |#if ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(14, 0)
  116|       |#pragma GCC diagnostic push
  117|       |#pragma GCC diagnostic ignored "-Warray-bounds"
  118|       |#endif
  119|    259|        std::copy_backward(words_, words_ + size_ - word_shift, words_ + size_);
  120|       |#if ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(14, 0)
  121|       |#pragma GCC diagnostic pop
  122|       |#endif
  123|  8.84k|      } else {
  124|   161k|        for (int i = (std::min)(size_, max_words - 1); i > word_shift; --i) {
  ------------------
  |  Branch (124:56): [True: 152k, False: 8.84k]
  ------------------
  125|   152k|          words_[i] = (words_[i - word_shift] << count) |
  126|   152k|                      (words_[i - word_shift - 1] >> (32 - count));
  127|   152k|        }
  128|  8.84k|        words_[word_shift] = words_[0] << count;
  129|       |        // Grow size_ if necessary.
  130|  8.84k|        if (size_ < max_words && words_[size_]) {
  ------------------
  |  Branch (130:13): [True: 8.84k, False: 0]
  |  Branch (130:34): [True: 4.44k, False: 4.40k]
  ------------------
  131|  4.44k|          ++size_;
  132|  4.44k|        }
  133|  8.84k|      }
  134|  9.10k|      std::fill_n(words_, word_shift, 0u);
  135|  9.10k|    }
  136|  9.45k|  }
_ZN4absl12lts_2026052616strings_internal7CompareILi84ELi84EEEiRKNS1_11BigUnsignedIXT_EEERKNS3_IXT0_EEE:
  363|  9.45k|int Compare(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs) {
  364|  9.45k|  int limit = (std::max)(lhs.size(), rhs.size());
  365|  26.8k|  for (int i = limit - 1; i >= 0; --i) {
  ------------------
  |  Branch (365:27): [True: 25.7k, False: 1.03k]
  ------------------
  366|  25.7k|    const uint32_t lhs_word = lhs.GetWord(i);
  367|  25.7k|    const uint32_t rhs_word = rhs.GetWord(i);
  368|  25.7k|    if (lhs_word < rhs_word) {
  ------------------
  |  Branch (368:9): [True: 6.50k, False: 19.2k]
  ------------------
  369|  6.50k|      return -1;
  370|  19.2k|    } else if (lhs_word > rhs_word) {
  ------------------
  |  Branch (370:16): [True: 1.91k, False: 17.3k]
  ------------------
  371|  1.91k|      return 1;
  372|  1.91k|    }
  373|  25.7k|  }
  374|  1.03k|  return 0;
  375|  9.45k|}
_ZNK4absl12lts_2026052616strings_internal11BigUnsignedILi84EE4sizeEv:
  227|  18.9k|  int size() const { return size_; }
_ZNK4absl12lts_2026052616strings_internal11BigUnsignedILi84EE7GetWordEi:
  216|  51.5k|  uint32_t GetWord(int index) const {
  217|  51.5k|    if (index < 0 || index >= size_) {
  ------------------
  |  Branch (217:9): [True: 0, False: 51.5k]
  |  Branch (217:22): [True: 194, False: 51.3k]
  ------------------
  218|    194|      return 0;
  219|    194|    }
  220|  51.3k|    return words_[index];
  221|  51.5k|  }
_ZN4absl12lts_2026052616strings_internal11BigUnsignedILi84EE10MultiplyByEm:
  162|  6.16k|  void MultiplyBy(uint64_t v) {
  163|  6.16k|    uint32_t words[2];
  164|  6.16k|    words[0] = static_cast<uint32_t>(v);
  165|  6.16k|    words[1] = static_cast<uint32_t>(v >> 32);
  166|  6.16k|    if (words[1] == 0) {
  ------------------
  |  Branch (166:9): [True: 0, False: 6.16k]
  ------------------
  167|      0|      MultiplyBy(words[0]);
  168|  6.16k|    } else {
  169|  6.16k|      MultiplyBy(2, words);
  170|  6.16k|    }
  171|  6.16k|  }
_ZN4absl12lts_2026052616strings_internal11BigUnsignedILi84EE10MultiplyByEiPKj:
  280|  8.68k|  void MultiplyBy(int other_size, const uint32_t* other_words) {
  281|  8.68k|    const int original_size = size_;
  282|  8.68k|    const int first_step =
  283|  8.68k|        (std::min)(original_size + other_size - 2, max_words - 1);
  284|   291k|    for (int step = first_step; step >= 0; --step) {
  ------------------
  |  Branch (284:33): [True: 282k, False: 8.68k]
  ------------------
  285|   282k|      MultiplyStep(original_size, other_words, other_size, step);
  286|   282k|    }
  287|  8.68k|  }
_ZN4absl12lts_2026052616strings_internal11BigUnsignedILi84EE12AddWithCarryEij:
  290|   367k|  void AddWithCarry(int index, uint32_t value) {
  291|   367k|    if (value) {
  ------------------
  |  Branch (291:9): [True: 366k, False: 964]
  ------------------
  292|   761k|      while (index < max_words && value > 0) {
  ------------------
  |  Branch (292:14): [True: 761k, False: 0]
  |  Branch (292:35): [True: 394k, False: 366k]
  ------------------
  293|   394k|        words_[index] += value;
  294|       |        // carry if we overflowed in this word:
  295|   394k|        if (value > words_[index]) {
  ------------------
  |  Branch (295:13): [True: 28.3k, False: 366k]
  ------------------
  296|  28.3k|          value = 1;
  297|  28.3k|          ++index;
  298|   366k|        } else {
  299|   366k|          value = 0;
  300|   366k|        }
  301|   394k|      }
  302|   366k|      size_ = (std::min)(max_words, (std::max)(index + 1, size_));
  303|   366k|    }
  304|   367k|  }
_ZN4absl12lts_2026052616strings_internal11BigUnsignedILi84EE12AddWithCarryEim:
  306|   282k|  void AddWithCarry(int index, uint64_t value) {
  307|   282k|    if (value && index < max_words) {
  ------------------
  |  Branch (307:9): [True: 277k, False: 4.89k]
  |  Branch (307:18): [True: 277k, False: 0]
  ------------------
  308|   277k|      uint32_t high = value >> 32;
  309|   277k|      uint32_t low = value & 0xffffffff;
  310|   277k|      words_[index] += low;
  311|   277k|      if (words_[index] < low) {
  ------------------
  |  Branch (311:11): [True: 101k, False: 175k]
  ------------------
  312|   101k|        ++high;
  313|   101k|        if (high == 0) {
  ------------------
  |  Branch (313:13): [True: 0, False: 101k]
  ------------------
  314|       |          // Carry from the low word caused our high word to overflow.
  315|       |          // Short circuit here to do the right thing.
  316|      0|          AddWithCarry(index + 2, static_cast<uint32_t>(1));
  317|      0|          return;
  318|      0|        }
  319|   101k|      }
  320|   277k|      if (high > 0) {
  ------------------
  |  Branch (320:11): [True: 145k, False: 131k]
  ------------------
  321|   145k|        AddWithCarry(index + 1, high);
  322|   145k|      } else {
  323|       |        // Normally 32-bit AddWithCarry() sets size_, but since we don't call
  324|       |        // it when `high` is 0, do it ourselves here.
  325|   131k|        size_ = (std::min)(max_words, (std::max)(index + 1, size_));
  326|   131k|      }
  327|   277k|    }
  328|   282k|  }

_ZN4absl12lts_2026052616strings_internal10ParseFloatILi10EEENS1_11ParsedFloatEPKcS5_NS0_12chars_formatE:
  356|  20.0k|                                         chars_format format_flags) {
  357|  20.0k|  strings_internal::ParsedFloat result;
  358|       |
  359|       |  // Exit early if we're given an empty range.
  360|  20.0k|  if (begin == end) return result;
  ------------------
  |  Branch (360:7): [True: 8, False: 20.0k]
  ------------------
  361|       |
  362|       |  // Handle the infinity and NaN cases.
  363|  20.0k|  if (ParseInfinityOrNan(begin, end, &result)) {
  ------------------
  |  Branch (363:7): [True: 1.09k, False: 18.9k]
  ------------------
  364|  1.09k|    return result;
  365|  1.09k|  }
  366|       |
  367|  18.9k|  const char* const mantissa_begin = begin;
  368|  21.4k|  while (begin < end && *begin == '0') {
  ------------------
  |  Branch (368:10): [True: 20.4k, False: 976]
  |  Branch (368:25): [True: 2.48k, False: 17.9k]
  ------------------
  369|  2.48k|    ++begin;  // skip leading zeros
  370|  2.48k|  }
  371|  18.9k|  uint64_t mantissa = 0;
  372|       |
  373|  18.9k|  int exponent_adjustment = 0;
  374|  18.9k|  bool mantissa_is_inexact = false;
  375|  18.9k|  int pre_decimal_digits = ConsumeDigits<base>(
  376|  18.9k|      begin, end, MantissaDigitsMax<base>(), &mantissa, &mantissa_is_inexact);
  377|  18.9k|  begin += pre_decimal_digits;
  378|  18.9k|  int digits_left;
  379|  18.9k|  if (pre_decimal_digits >= DigitLimit<base>()) {
  ------------------
  |  Branch (379:7): [True: 0, False: 18.9k]
  ------------------
  380|       |    // refuse to parse pathological inputs
  381|      0|    return result;
  382|  18.9k|  } else if (pre_decimal_digits > MantissaDigitsMax<base>()) {
  ------------------
  |  Branch (382:14): [True: 4.23k, False: 14.7k]
  ------------------
  383|       |    // We dropped some non-fraction digits on the floor.  Adjust our exponent
  384|       |    // to compensate.
  385|  4.23k|    exponent_adjustment =
  386|  4.23k|        static_cast<int>(pre_decimal_digits - MantissaDigitsMax<base>());
  387|  4.23k|    digits_left = 0;
  388|  14.7k|  } else {
  389|  14.7k|    digits_left =
  390|  14.7k|        static_cast<int>(MantissaDigitsMax<base>() - pre_decimal_digits);
  391|  14.7k|  }
  392|  18.9k|  if (begin < end && *begin == '.') {
  ------------------
  |  Branch (392:7): [True: 15.8k, False: 3.14k]
  |  Branch (392:22): [True: 8.45k, False: 7.34k]
  ------------------
  393|  8.45k|    ++begin;
  394|  8.45k|    if (mantissa == 0) {
  ------------------
  |  Branch (394:9): [True: 4.14k, False: 4.30k]
  ------------------
  395|       |      // If we haven't seen any nonzero digits yet, keep skipping zeros.  We
  396|       |      // have to adjust the exponent to reflect the changed place value.
  397|  4.14k|      const char* begin_zeros = begin;
  398|  5.47k|      while (begin < end && *begin == '0') {
  ------------------
  |  Branch (398:14): [True: 4.80k, False: 669]
  |  Branch (398:29): [True: 1.32k, False: 3.48k]
  ------------------
  399|  1.32k|        ++begin;
  400|  1.32k|      }
  401|  4.14k|      int zeros_skipped = static_cast<int>(begin - begin_zeros);
  402|  4.14k|      if (zeros_skipped >= DigitLimit<base>()) {
  ------------------
  |  Branch (402:11): [True: 0, False: 4.14k]
  ------------------
  403|       |        // refuse to parse pathological inputs
  404|      0|        return result;
  405|      0|      }
  406|  4.14k|      exponent_adjustment -= static_cast<int>(zeros_skipped);
  407|  4.14k|    }
  408|  8.45k|    int post_decimal_digits = ConsumeDigits<base>(
  409|  8.45k|        begin, end, digits_left, &mantissa, &mantissa_is_inexact);
  410|  8.45k|    begin += post_decimal_digits;
  411|       |
  412|       |    // Since `mantissa` is an integer, each significant digit we read after
  413|       |    // the decimal point requires an adjustment to the exponent. "1.23e0" will
  414|       |    // be stored as `mantissa` == 123 and `exponent` == -2 (that is,
  415|       |    // "123e-2").
  416|  8.45k|    if (post_decimal_digits >= DigitLimit<base>()) {
  ------------------
  |  Branch (416:9): [True: 0, False: 8.45k]
  ------------------
  417|       |      // refuse to parse pathological inputs
  418|      0|      return result;
  419|  8.45k|    } else if (post_decimal_digits > digits_left) {
  ------------------
  |  Branch (419:16): [True: 5.45k, False: 3.00k]
  ------------------
  420|  5.45k|      exponent_adjustment -= digits_left;
  421|  5.45k|    } else {
  422|  3.00k|      exponent_adjustment -= post_decimal_digits;
  423|  3.00k|    }
  424|  8.45k|  }
  425|       |  // If we've found no mantissa whatsoever, this isn't a number.
  426|  18.9k|  if (mantissa_begin == begin) {
  ------------------
  |  Branch (426:7): [True: 79, False: 18.8k]
  ------------------
  427|     79|    return result;
  428|     79|  }
  429|       |  // A bare "." doesn't count as a mantissa either.
  430|  18.8k|  if (begin - mantissa_begin == 1 && *mantissa_begin == '.') {
  ------------------
  |  Branch (430:7): [True: 5.73k, False: 13.1k]
  |  Branch (430:38): [True: 23, False: 5.71k]
  ------------------
  431|     23|    return result;
  432|     23|  }
  433|       |
  434|  18.8k|  if (mantissa_is_inexact) {
  ------------------
  |  Branch (434:7): [True: 8.60k, False: 10.2k]
  ------------------
  435|       |    // We dropped significant digits on the floor.  Handle this appropriately.
  436|  8.60k|    if (base == 10) {
  ------------------
  |  Branch (436:9): [True: 8.60k, Folded]
  ------------------
  437|       |      // If we truncated significant decimal digits, store the full range of the
  438|       |      // mantissa for future big integer math for exact rounding.
  439|  8.60k|      result.subrange_begin = mantissa_begin;
  440|  8.60k|      result.subrange_end = begin;
  441|  8.60k|    } else if (base == 16) {
  ------------------
  |  Branch (441:16): [Folded, False: 0]
  ------------------
  442|       |      // If we truncated hex digits, reflect this fact by setting the low
  443|       |      // ("sticky") bit.  This allows for correct rounding in all cases.
  444|      0|      mantissa |= 1;
  445|      0|    }
  446|  8.60k|  }
  447|  18.8k|  result.mantissa = mantissa;
  448|       |
  449|  18.8k|  const char* const exponent_begin = begin;
  450|  18.8k|  result.literal_exponent = 0;
  451|  18.8k|  bool found_exponent = false;
  452|  18.8k|  if (AllowExponent(format_flags) && begin < end &&
  ------------------
  |  Branch (452:7): [True: 18.8k, False: 0]
  |  Branch (452:38): [True: 8.58k, False: 10.2k]
  ------------------
  453|  8.58k|      IsExponentCharacter<base>(*begin)) {
  ------------------
  |  Branch (453:7): [True: 8.49k, False: 87]
  ------------------
  454|  8.49k|    bool negative_exponent = false;
  455|  8.49k|    ++begin;
  456|  8.49k|    if (begin < end && *begin == '-') {
  ------------------
  |  Branch (456:9): [True: 8.48k, False: 14]
  |  Branch (456:24): [True: 2.13k, False: 6.34k]
  ------------------
  457|  2.13k|      negative_exponent = true;
  458|  2.13k|      ++begin;
  459|  6.36k|    } else if (begin < end && *begin == '+') {
  ------------------
  |  Branch (459:16): [True: 6.34k, False: 14]
  |  Branch (459:31): [True: 963, False: 5.38k]
  ------------------
  460|    963|      ++begin;
  461|    963|    }
  462|  8.49k|    const char* const exponent_digits_begin = begin;
  463|       |    // Exponent is always expressed in decimal, even for hexadecimal floats.
  464|  8.49k|    begin += ConsumeDigits<10>(begin, end, kDecimalExponentDigitsMax,
  465|  8.49k|                               &result.literal_exponent, nullptr);
  466|  8.49k|    if (begin == exponent_digits_begin) {
  ------------------
  |  Branch (466:9): [True: 37, False: 8.46k]
  ------------------
  467|       |      // there were no digits where we expected an exponent.  We failed to read
  468|       |      // an exponent and should not consume the 'e' after all.  Rewind 'begin'.
  469|     37|      found_exponent = false;
  470|     37|      begin = exponent_begin;
  471|  8.46k|    } else {
  472|  8.46k|      found_exponent = true;
  473|  8.46k|      if (negative_exponent) {
  ------------------
  |  Branch (473:11): [True: 2.13k, False: 6.32k]
  ------------------
  474|  2.13k|        result.literal_exponent = -result.literal_exponent;
  475|  2.13k|      }
  476|  8.46k|    }
  477|  8.49k|  }
  478|       |
  479|  18.8k|  if (!found_exponent && RequireExponent(format_flags)) {
  ------------------
  |  Branch (479:7): [True: 10.3k, False: 8.46k]
  |  Branch (479:26): [True: 0, False: 10.3k]
  ------------------
  480|       |    // Provided flags required an exponent, but none was found.  This results
  481|       |    // in a failure to scan.
  482|      0|    return result;
  483|      0|  }
  484|       |
  485|       |  // Success!
  486|  18.8k|  result.type = strings_internal::FloatType::kNumber;
  487|  18.8k|  if (result.mantissa > 0) {
  ------------------
  |  Branch (487:7): [True: 16.4k, False: 2.42k]
  ------------------
  488|  16.4k|    result.exponent = result.literal_exponent +
  489|  16.4k|                      (DigitMagnitude<base>() * exponent_adjustment);
  490|  16.4k|  } else {
  491|  2.42k|    result.exponent = 0;
  492|  2.42k|  }
  493|  18.8k|  result.end = begin;
  494|  18.8k|  return result;
  495|  18.8k|}
_ZN4absl12lts_2026052616strings_internal10ParseFloatILi16EEENS1_11ParsedFloatEPKcS5_NS0_12chars_formatE:
  356|  5.12k|                                         chars_format format_flags) {
  357|  5.12k|  strings_internal::ParsedFloat result;
  358|       |
  359|       |  // Exit early if we're given an empty range.
  360|  5.12k|  if (begin == end) return result;
  ------------------
  |  Branch (360:7): [True: 13, False: 5.10k]
  ------------------
  361|       |
  362|       |  // Handle the infinity and NaN cases.
  363|  5.10k|  if (ParseInfinityOrNan(begin, end, &result)) {
  ------------------
  |  Branch (363:7): [True: 1, False: 5.10k]
  ------------------
  364|      1|    return result;
  365|      1|  }
  366|       |
  367|  5.10k|  const char* const mantissa_begin = begin;
  368|  6.18k|  while (begin < end && *begin == '0') {
  ------------------
  |  Branch (368:10): [True: 5.88k, False: 302]
  |  Branch (368:25): [True: 1.08k, False: 4.80k]
  ------------------
  369|  1.08k|    ++begin;  // skip leading zeros
  370|  1.08k|  }
  371|  5.10k|  uint64_t mantissa = 0;
  372|       |
  373|  5.10k|  int exponent_adjustment = 0;
  374|  5.10k|  bool mantissa_is_inexact = false;
  375|  5.10k|  int pre_decimal_digits = ConsumeDigits<base>(
  376|  5.10k|      begin, end, MantissaDigitsMax<base>(), &mantissa, &mantissa_is_inexact);
  377|  5.10k|  begin += pre_decimal_digits;
  378|  5.10k|  int digits_left;
  379|  5.10k|  if (pre_decimal_digits >= DigitLimit<base>()) {
  ------------------
  |  Branch (379:7): [True: 0, False: 5.10k]
  ------------------
  380|       |    // refuse to parse pathological inputs
  381|      0|    return result;
  382|  5.10k|  } else if (pre_decimal_digits > MantissaDigitsMax<base>()) {
  ------------------
  |  Branch (382:14): [True: 379, False: 4.72k]
  ------------------
  383|       |    // We dropped some non-fraction digits on the floor.  Adjust our exponent
  384|       |    // to compensate.
  385|    379|    exponent_adjustment =
  386|    379|        static_cast<int>(pre_decimal_digits - MantissaDigitsMax<base>());
  387|    379|    digits_left = 0;
  388|  4.72k|  } else {
  389|  4.72k|    digits_left =
  390|  4.72k|        static_cast<int>(MantissaDigitsMax<base>() - pre_decimal_digits);
  391|  4.72k|  }
  392|  5.10k|  if (begin < end && *begin == '.') {
  ------------------
  |  Branch (392:7): [True: 3.59k, False: 1.51k]
  |  Branch (392:22): [True: 1.51k, False: 2.08k]
  ------------------
  393|  1.51k|    ++begin;
  394|  1.51k|    if (mantissa == 0) {
  ------------------
  |  Branch (394:9): [True: 907, False: 606]
  ------------------
  395|       |      // If we haven't seen any nonzero digits yet, keep skipping zeros.  We
  396|       |      // have to adjust the exponent to reflect the changed place value.
  397|    907|      const char* begin_zeros = begin;
  398|  1.37k|      while (begin < end && *begin == '0') {
  ------------------
  |  Branch (398:14): [True: 955, False: 416]
  |  Branch (398:29): [True: 464, False: 491]
  ------------------
  399|    464|        ++begin;
  400|    464|      }
  401|    907|      int zeros_skipped = static_cast<int>(begin - begin_zeros);
  402|    907|      if (zeros_skipped >= DigitLimit<base>()) {
  ------------------
  |  Branch (402:11): [True: 0, False: 907]
  ------------------
  403|       |        // refuse to parse pathological inputs
  404|      0|        return result;
  405|      0|      }
  406|    907|      exponent_adjustment -= static_cast<int>(zeros_skipped);
  407|    907|    }
  408|  1.51k|    int post_decimal_digits = ConsumeDigits<base>(
  409|  1.51k|        begin, end, digits_left, &mantissa, &mantissa_is_inexact);
  410|  1.51k|    begin += post_decimal_digits;
  411|       |
  412|       |    // Since `mantissa` is an integer, each significant digit we read after
  413|       |    // the decimal point requires an adjustment to the exponent. "1.23e0" will
  414|       |    // be stored as `mantissa` == 123 and `exponent` == -2 (that is,
  415|       |    // "123e-2").
  416|  1.51k|    if (post_decimal_digits >= DigitLimit<base>()) {
  ------------------
  |  Branch (416:9): [True: 0, False: 1.51k]
  ------------------
  417|       |      // refuse to parse pathological inputs
  418|      0|      return result;
  419|  1.51k|    } else if (post_decimal_digits > digits_left) {
  ------------------
  |  Branch (419:16): [True: 289, False: 1.22k]
  ------------------
  420|    289|      exponent_adjustment -= digits_left;
  421|  1.22k|    } else {
  422|  1.22k|      exponent_adjustment -= post_decimal_digits;
  423|  1.22k|    }
  424|  1.51k|  }
  425|       |  // If we've found no mantissa whatsoever, this isn't a number.
  426|  5.10k|  if (mantissa_begin == begin) {
  ------------------
  |  Branch (426:7): [True: 17, False: 5.08k]
  ------------------
  427|     17|    return result;
  428|     17|  }
  429|       |  // A bare "." doesn't count as a mantissa either.
  430|  5.08k|  if (begin - mantissa_begin == 1 && *mantissa_begin == '.') {
  ------------------
  |  Branch (430:7): [True: 2.63k, False: 2.45k]
  |  Branch (430:38): [True: 20, False: 2.61k]
  ------------------
  431|     20|    return result;
  432|     20|  }
  433|       |
  434|  5.06k|  if (mantissa_is_inexact) {
  ------------------
  |  Branch (434:7): [True: 516, False: 4.55k]
  ------------------
  435|       |    // We dropped significant digits on the floor.  Handle this appropriately.
  436|    516|    if (base == 10) {
  ------------------
  |  Branch (436:9): [Folded, False: 516]
  ------------------
  437|       |      // If we truncated significant decimal digits, store the full range of the
  438|       |      // mantissa for future big integer math for exact rounding.
  439|      0|      result.subrange_begin = mantissa_begin;
  440|      0|      result.subrange_end = begin;
  441|    516|    } else if (base == 16) {
  ------------------
  |  Branch (441:16): [True: 516, Folded]
  ------------------
  442|       |      // If we truncated hex digits, reflect this fact by setting the low
  443|       |      // ("sticky") bit.  This allows for correct rounding in all cases.
  444|    516|      mantissa |= 1;
  445|    516|    }
  446|    516|  }
  447|  5.06k|  result.mantissa = mantissa;
  448|       |
  449|  5.06k|  const char* const exponent_begin = begin;
  450|  5.06k|  result.literal_exponent = 0;
  451|  5.06k|  bool found_exponent = false;
  452|  5.06k|  if (AllowExponent(format_flags) && begin < end &&
  ------------------
  |  Branch (452:7): [True: 5.06k, False: 0]
  |  Branch (452:38): [True: 2.27k, False: 2.79k]
  ------------------
  453|  2.27k|      IsExponentCharacter<base>(*begin)) {
  ------------------
  |  Branch (453:7): [True: 2.23k, False: 35]
  ------------------
  454|  2.23k|    bool negative_exponent = false;
  455|  2.23k|    ++begin;
  456|  2.23k|    if (begin < end && *begin == '-') {
  ------------------
  |  Branch (456:9): [True: 2.22k, False: 15]
  |  Branch (456:24): [True: 1.09k, False: 1.12k]
  ------------------
  457|  1.09k|      negative_exponent = true;
  458|  1.09k|      ++begin;
  459|  1.13k|    } else if (begin < end && *begin == '+') {
  ------------------
  |  Branch (459:16): [True: 1.12k, False: 15]
  |  Branch (459:31): [True: 194, False: 929]
  ------------------
  460|    194|      ++begin;
  461|    194|    }
  462|  2.23k|    const char* const exponent_digits_begin = begin;
  463|       |    // Exponent is always expressed in decimal, even for hexadecimal floats.
  464|  2.23k|    begin += ConsumeDigits<10>(begin, end, kDecimalExponentDigitsMax,
  465|  2.23k|                               &result.literal_exponent, nullptr);
  466|  2.23k|    if (begin == exponent_digits_begin) {
  ------------------
  |  Branch (466:9): [True: 32, False: 2.20k]
  ------------------
  467|       |      // there were no digits where we expected an exponent.  We failed to read
  468|       |      // an exponent and should not consume the 'e' after all.  Rewind 'begin'.
  469|     32|      found_exponent = false;
  470|     32|      begin = exponent_begin;
  471|  2.20k|    } else {
  472|  2.20k|      found_exponent = true;
  473|  2.20k|      if (negative_exponent) {
  ------------------
  |  Branch (473:11): [True: 1.09k, False: 1.10k]
  ------------------
  474|  1.09k|        result.literal_exponent = -result.literal_exponent;
  475|  1.09k|      }
  476|  2.20k|    }
  477|  2.23k|  }
  478|       |
  479|  5.06k|  if (!found_exponent && RequireExponent(format_flags)) {
  ------------------
  |  Branch (479:7): [True: 2.86k, False: 2.20k]
  |  Branch (479:26): [True: 0, False: 2.86k]
  ------------------
  480|       |    // Provided flags required an exponent, but none was found.  This results
  481|       |    // in a failure to scan.
  482|      0|    return result;
  483|      0|  }
  484|       |
  485|       |  // Success!
  486|  5.06k|  result.type = strings_internal::FloatType::kNumber;
  487|  5.06k|  if (result.mantissa > 0) {
  ------------------
  |  Branch (487:7): [True: 3.98k, False: 1.08k]
  ------------------
  488|  3.98k|    result.exponent = result.literal_exponent +
  489|  3.98k|                      (DigitMagnitude<base>() * exponent_adjustment);
  490|  3.98k|  } else {
  491|  1.08k|    result.exponent = 0;
  492|  1.08k|  }
  493|  5.06k|  result.end = begin;
  494|  5.06k|  return result;
  495|  5.06k|}
charconv_parse.cc:_ZN4absl12lts_2026052612_GLOBAL__N_113AllowExponentENS0_12chars_formatE:
  122|  23.9k|bool AllowExponent(chars_format flags) {
  123|  23.9k|  bool fixed = (flags & chars_format::fixed) == chars_format::fixed;
  124|  23.9k|  bool scientific =
  125|  23.9k|      (flags & chars_format::scientific) == chars_format::scientific;
  126|  23.9k|  return scientific || !fixed;
  ------------------
  |  Branch (126:10): [True: 23.9k, False: 0]
  |  Branch (126:24): [True: 0, False: 0]
  ------------------
  127|  23.9k|}
charconv_parse.cc:_ZN4absl12lts_2026052612_GLOBAL__N_115RequireExponentENS0_12chars_formatE:
  130|  13.2k|bool RequireExponent(chars_format flags) {
  131|  13.2k|  bool fixed = (flags & chars_format::fixed) == chars_format::fixed;
  132|  13.2k|  bool scientific =
  133|  13.2k|      (flags & chars_format::scientific) == chars_format::scientific;
  134|  13.2k|  return scientific && !fixed;
  ------------------
  |  Branch (134:10): [True: 13.2k, False: 0]
  |  Branch (134:24): [True: 0, False: 13.2k]
  ------------------
  135|  13.2k|}
charconv_parse.cc:_ZN4absl12lts_2026052612_GLOBAL__N_119IsExponentCharacterILi10EEEbc:
  201|  8.58k|bool IsExponentCharacter<10>(char ch) {
  202|  8.58k|  return ch == 'e' || ch == 'E';
  ------------------
  |  Branch (202:10): [True: 6.99k, False: 1.58k]
  |  Branch (202:23): [True: 1.50k, False: 87]
  ------------------
  203|  8.58k|}
charconv_parse.cc:_ZN4absl12lts_2026052612_GLOBAL__N_119IsExponentCharacterILi16EEEbc:
  206|  2.27k|bool IsExponentCharacter<16>(char ch) {
  207|  2.27k|  return ch == 'p' || ch == 'P';
  ------------------
  |  Branch (207:10): [True: 1.46k, False: 806]
  |  Branch (207:23): [True: 771, False: 35]
  ------------------
  208|  2.27k|}
charconv_parse.cc:_ZN4absl12lts_2026052612_GLOBAL__N_117MantissaDigitsMaxILi10EEEiv:
  211|  56.8k|constexpr int MantissaDigitsMax<10>() {
  212|  56.8k|  return kDecimalMantissaDigitsMax;
  213|  56.8k|}
charconv_parse.cc:_ZN4absl12lts_2026052612_GLOBAL__N_117MantissaDigitsMaxILi16EEEiv:
  215|  15.3k|constexpr int MantissaDigitsMax<16>() {
  216|  15.3k|  return kHexadecimalMantissaDigitsMax;
  217|  15.3k|}
charconv_parse.cc:_ZN4absl12lts_2026052612_GLOBAL__N_110DigitLimitILi10EEEiv:
  220|  31.5k|constexpr int DigitLimit<10>() {
  221|  31.5k|  return kDecimalDigitLimit;
  222|  31.5k|}
charconv_parse.cc:_ZN4absl12lts_2026052612_GLOBAL__N_110DigitLimitILi16EEEiv:
  224|  7.52k|constexpr int DigitLimit<16>() {
  225|  7.52k|  return kHexadecimalDigitLimit;
  226|  7.52k|}
charconv_parse.cc:_ZN4absl12lts_2026052612_GLOBAL__N_114DigitMagnitudeILi10EEEiv:
  229|  16.4k|constexpr int DigitMagnitude<10>() {
  230|  16.4k|  return 1;
  231|  16.4k|}
charconv_parse.cc:_ZN4absl12lts_2026052612_GLOBAL__N_114DigitMagnitudeILi16EEEiv:
  233|  3.98k|constexpr int DigitMagnitude<16>() {
  234|  3.98k|  return 4;
  235|  3.98k|}
charconv_parse.cc:_ZN4absl12lts_2026052612_GLOBAL__N_118ParseInfinityOrNanEPKcS3_PNS0_16strings_internal11ParsedFloatE:
  298|  25.1k|                        strings_internal::ParsedFloat* out) {
  299|  25.1k|  if (end - begin < 3) {
  ------------------
  |  Branch (299:7): [True: 4.81k, False: 20.3k]
  ------------------
  300|  4.81k|    return false;
  301|  4.81k|  }
  302|  20.3k|  switch (*begin) {
  303|    297|    case 'i':
  ------------------
  |  Branch (303:5): [True: 297, False: 20.0k]
  ------------------
  304|    521|    case 'I': {
  ------------------
  |  Branch (304:5): [True: 224, False: 20.1k]
  ------------------
  305|       |      // An infinity string consists of the characters "inf" or "infinity",
  306|       |      // case insensitive.
  307|    521|      if (strings_internal::memcasecmp(begin + 1, "nf", 2) != 0) {
  ------------------
  |  Branch (307:11): [True: 11, False: 510]
  ------------------
  308|     11|        return false;
  309|     11|      }
  310|    510|      out->type = strings_internal::FloatType::kInfinity;
  311|    510|      if (end - begin >= 8 &&
  ------------------
  |  Branch (311:11): [True: 35, False: 475]
  ------------------
  312|     35|          strings_internal::memcasecmp(begin + 3, "inity", 5) == 0) {
  ------------------
  |  Branch (312:11): [True: 1, False: 34]
  ------------------
  313|      1|        out->end = begin + 8;
  314|    509|      } else {
  315|    509|        out->end = begin + 3;
  316|    509|      }
  317|    510|      return true;
  318|    521|    }
  319|    198|    case 'n':
  ------------------
  |  Branch (319:5): [True: 198, False: 20.1k]
  ------------------
  320|    596|    case 'N': {
  ------------------
  |  Branch (320:5): [True: 398, False: 19.9k]
  ------------------
  321|       |      // A NaN consists of the characters "nan", case insensitive, optionally
  322|       |      // followed by a parenthesized sequence of zero or more alphanumeric
  323|       |      // characters and/or underscores.
  324|    596|      if (strings_internal::memcasecmp(begin + 1, "an", 2) != 0) {
  ------------------
  |  Branch (324:11): [True: 14, False: 582]
  ------------------
  325|     14|        return false;
  326|     14|      }
  327|    582|      out->type = strings_internal::FloatType::kNan;
  328|    582|      out->end = begin + 3;
  329|       |      // NaN is allowed to be followed by a parenthesized string, consisting of
  330|       |      // only the characters [a-zA-Z0-9_].  Match that if it's present.
  331|    582|      begin += 3;
  332|    582|      if (begin < end && *begin == '(') {
  ------------------
  |  Branch (332:11): [True: 1, False: 581]
  |  Branch (332:26): [True: 0, False: 1]
  ------------------
  333|      0|        const char* nan_begin = begin + 1;
  334|      0|        while (nan_begin < end && IsNanChar(*nan_begin)) {
  ------------------
  |  Branch (334:16): [True: 0, False: 0]
  |  Branch (334:35): [True: 0, False: 0]
  ------------------
  335|      0|          ++nan_begin;
  336|      0|        }
  337|      0|        if (nan_begin < end && *nan_begin == ')') {
  ------------------
  |  Branch (337:13): [True: 0, False: 0]
  |  Branch (337:32): [True: 0, False: 0]
  ------------------
  338|       |          // We found an extra NaN specifier range
  339|      0|          out->subrange_begin = begin + 1;
  340|      0|          out->subrange_end = nan_begin;
  341|      0|          out->end = nan_begin + 1;
  342|      0|        }
  343|      0|      }
  344|    582|      return true;
  345|    596|    }
  346|  19.2k|    default:
  ------------------
  |  Branch (346:5): [True: 19.2k, False: 1.11k]
  ------------------
  347|  19.2k|      return false;
  348|  20.3k|  }
  349|  20.3k|}
charconv_parse.cc:_ZN4absl12lts_2026052612_GLOBAL__N_113ConsumeDigitsILi10EmEEiPKcS4_iPT0_Pb:
  250|  27.4k|                  bool* dropped_nonzero_digit) {
  251|  27.4k|  if (base == 10) {
  ------------------
  |  Branch (251:7): [True: 27.4k, Folded]
  ------------------
  252|  27.4k|    assert(max_digits <= std::numeric_limits<T>::digits10);
  253|  27.4k|  } else if (base == 16) {
  ------------------
  |  Branch (253:14): [Folded, False: 0]
  ------------------
  254|      0|    assert(max_digits * 4 <= std::numeric_limits<T>::digits);
  255|      0|  }
  256|  27.4k|  const char* const original_begin = begin;
  257|       |
  258|       |  // Skip leading zeros, but only if *out is zero.
  259|       |  // They don't cause an overflow so we don't have to count them for
  260|       |  // `max_digits`.
  261|  27.4k|  while (!*out && end != begin && *begin == '0') ++begin;
  ------------------
  |  Branch (261:10): [True: 23.1k, False: 4.30k]
  |  Branch (261:19): [True: 21.4k, False: 1.64k]
  |  Branch (261:35): [True: 0, False: 21.4k]
  ------------------
  262|       |
  263|  27.4k|  T accumulator = *out;
  264|  27.4k|  const char* significant_digits_end =
  265|  27.4k|      (end - begin > max_digits) ? begin + max_digits : end;
  ------------------
  |  Branch (265:7): [True: 14.2k, False: 13.1k]
  ------------------
  266|   223k|  while (begin < significant_digits_end && IsDigit<base>(*begin)) {
  ------------------
  |  Branch (266:10): [True: 208k, False: 14.8k]
  |  Branch (266:44): [True: 196k, False: 12.5k]
  ------------------
  267|       |    // Do not guard against *out overflow; max_digits was chosen to avoid this.
  268|       |    // Do assert against it, to detect problems in debug builds.
  269|   196k|    auto digit = static_cast<T>(ToDigit<base>(*begin));
  270|   196k|    assert(accumulator * base >= accumulator);
  271|   196k|    accumulator *= base;
  272|   196k|    assert(accumulator + digit >= accumulator);
  273|   196k|    accumulator += digit;
  274|   196k|    ++begin;
  275|   196k|  }
  276|  27.4k|  bool dropped_nonzero = false;
  277|  15.1M|  while (begin < end && IsDigit<base>(*begin)) {
  ------------------
  |  Branch (277:10): [True: 15.1M, False: 10.2k]
  |  Branch (277:25): [True: 15.1M, False: 17.1k]
  ------------------
  278|  15.1M|    dropped_nonzero = dropped_nonzero || (*begin != '0');
  ------------------
  |  Branch (278:23): [True: 15.1M, False: 14.9k]
  |  Branch (278:42): [True: 9.66k, False: 5.31k]
  ------------------
  279|  15.1M|    ++begin;
  280|  15.1M|  }
  281|  27.4k|  if (dropped_nonzero && dropped_nonzero_digit != nullptr) {
  ------------------
  |  Branch (281:7): [True: 9.66k, False: 17.7k]
  |  Branch (281:26): [True: 9.66k, False: 0]
  ------------------
  282|  9.66k|    *dropped_nonzero_digit = true;
  283|  9.66k|  }
  284|  27.4k|  *out = accumulator;
  285|  27.4k|  return static_cast<int>(begin - original_begin);
  286|  27.4k|}
charconv_parse.cc:_ZN4absl12lts_2026052612_GLOBAL__N_17IsDigitILi10EEEbc:
  183|  24.2M|bool IsDigit<10>(char ch) {
  184|  24.2M|  return ch >= '0' && ch <= '9';
  ------------------
  |  Branch (184:10): [True: 24.2M, False: 15.5k]
  |  Branch (184:23): [True: 24.2M, False: 14.2k]
  ------------------
  185|  24.2M|}
charconv_parse.cc:_ZN4absl12lts_2026052612_GLOBAL__N_17ToDigitILi10EEEjc:
  192|   220k|unsigned ToDigit<10>(char ch) {
  193|   220k|  return static_cast<unsigned>(ch - '0');
  194|   220k|}
charconv_parse.cc:_ZN4absl12lts_2026052612_GLOBAL__N_113ConsumeDigitsILi10EiEEiPKcS4_iPT0_Pb:
  250|  10.7k|                  bool* dropped_nonzero_digit) {
  251|  10.7k|  if (base == 10) {
  ------------------
  |  Branch (251:7): [True: 10.7k, Folded]
  ------------------
  252|  10.7k|    assert(max_digits <= std::numeric_limits<T>::digits10);
  253|  10.7k|  } else if (base == 16) {
  ------------------
  |  Branch (253:14): [Folded, False: 0]
  ------------------
  254|      0|    assert(max_digits * 4 <= std::numeric_limits<T>::digits);
  255|      0|  }
  256|  10.7k|  const char* const original_begin = begin;
  257|       |
  258|       |  // Skip leading zeros, but only if *out is zero.
  259|       |  // They don't cause an overflow so we don't have to count them for
  260|       |  // `max_digits`.
  261|  12.3k|  while (!*out && end != begin && *begin == '0') ++begin;
  ------------------
  |  Branch (261:10): [True: 12.3k, False: 0]
  |  Branch (261:19): [True: 10.8k, False: 1.48k]
  |  Branch (261:35): [True: 1.64k, False: 9.25k]
  ------------------
  262|       |
  263|  10.7k|  T accumulator = *out;
  264|  10.7k|  const char* significant_digits_end =
  265|  10.7k|      (end - begin > max_digits) ? begin + max_digits : end;
  ------------------
  |  Branch (265:7): [True: 307, False: 10.4k]
  ------------------
  266|  35.4k|  while (begin < significant_digits_end && IsDigit<base>(*begin)) {
  ------------------
  |  Branch (266:10): [True: 24.7k, False: 10.6k]
  |  Branch (266:44): [True: 24.7k, False: 40]
  ------------------
  267|       |    // Do not guard against *out overflow; max_digits was chosen to avoid this.
  268|       |    // Do assert against it, to detect problems in debug builds.
  269|  24.7k|    auto digit = static_cast<T>(ToDigit<base>(*begin));
  270|  24.7k|    assert(accumulator * base >= accumulator);
  271|  24.7k|    accumulator *= base;
  272|  24.7k|    assert(accumulator + digit >= accumulator);
  273|  24.7k|    accumulator += digit;
  274|  24.7k|    ++begin;
  275|  24.7k|  }
  276|  10.7k|  bool dropped_nonzero = false;
  277|  8.90M|  while (begin < end && IsDigit<base>(*begin)) {
  ------------------
  |  Branch (277:10): [True: 8.89M, False: 10.6k]
  |  Branch (277:25): [True: 8.89M, False: 46]
  ------------------
  278|  8.89M|    dropped_nonzero = dropped_nonzero || (*begin != '0');
  ------------------
  |  Branch (278:23): [True: 8.89M, False: 305]
  |  Branch (278:42): [True: 280, False: 25]
  ------------------
  279|  8.89M|    ++begin;
  280|  8.89M|  }
  281|  10.7k|  if (dropped_nonzero && dropped_nonzero_digit != nullptr) {
  ------------------
  |  Branch (281:7): [True: 280, False: 10.4k]
  |  Branch (281:26): [True: 0, False: 280]
  ------------------
  282|      0|    *dropped_nonzero_digit = true;
  283|      0|  }
  284|  10.7k|  *out = accumulator;
  285|  10.7k|  return static_cast<int>(begin - original_begin);
  286|  10.7k|}
charconv_parse.cc:_ZN4absl12lts_2026052612_GLOBAL__N_113ConsumeDigitsILi16EmEEiPKcS4_iPT0_Pb:
  250|  6.61k|                  bool* dropped_nonzero_digit) {
  251|  6.61k|  if (base == 10) {
  ------------------
  |  Branch (251:7): [Folded, False: 6.61k]
  ------------------
  252|      0|    assert(max_digits <= std::numeric_limits<T>::digits10);
  253|  6.61k|  } else if (base == 16) {
  ------------------
  |  Branch (253:14): [True: 6.61k, Folded]
  ------------------
  254|  6.61k|    assert(max_digits * 4 <= std::numeric_limits<T>::digits);
  255|  6.61k|  }
  256|  6.61k|  const char* const original_begin = begin;
  257|       |
  258|       |  // Skip leading zeros, but only if *out is zero.
  259|       |  // They don't cause an overflow so we don't have to count them for
  260|       |  // `max_digits`.
  261|  6.61k|  while (!*out && end != begin && *begin == '0') ++begin;
  ------------------
  |  Branch (261:10): [True: 6.01k, False: 606]
  |  Branch (261:19): [True: 5.29k, False: 718]
  |  Branch (261:35): [True: 0, False: 5.29k]
  ------------------
  262|       |
  263|  6.61k|  T accumulator = *out;
  264|  6.61k|  const char* significant_digits_end =
  265|  6.61k|      (end - begin > max_digits) ? begin + max_digits : end;
  ------------------
  |  Branch (265:7): [True: 847, False: 5.77k]
  ------------------
  266|  26.9k|  while (begin < significant_digits_end && IsDigit<base>(*begin)) {
  ------------------
  |  Branch (266:10): [True: 23.9k, False: 2.99k]
  |  Branch (266:44): [True: 20.3k, False: 3.62k]
  ------------------
  267|       |    // Do not guard against *out overflow; max_digits was chosen to avoid this.
  268|       |    // Do assert against it, to detect problems in debug builds.
  269|  20.3k|    auto digit = static_cast<T>(ToDigit<base>(*begin));
  270|  20.3k|    assert(accumulator * base >= accumulator);
  271|  20.3k|    accumulator *= base;
  272|  20.3k|    assert(accumulator + digit >= accumulator);
  273|  20.3k|    accumulator += digit;
  274|  20.3k|    ++begin;
  275|  20.3k|  }
  276|  6.61k|  bool dropped_nonzero = false;
  277|  12.7M|  while (begin < end && IsDigit<base>(*begin)) {
  ------------------
  |  Branch (277:10): [True: 12.7M, False: 2.80k]
  |  Branch (277:25): [True: 12.7M, False: 3.81k]
  ------------------
  278|  12.7M|    dropped_nonzero = dropped_nonzero || (*begin != '0');
  ------------------
  |  Branch (278:23): [True: 12.7M, False: 1.04k]
  |  Branch (278:42): [True: 647, False: 397]
  ------------------
  279|  12.7M|    ++begin;
  280|  12.7M|  }
  281|  6.61k|  if (dropped_nonzero && dropped_nonzero_digit != nullptr) {
  ------------------
  |  Branch (281:7): [True: 647, False: 5.97k]
  |  Branch (281:26): [True: 647, False: 0]
  ------------------
  282|    647|    *dropped_nonzero_digit = true;
  283|    647|  }
  284|  6.61k|  *out = accumulator;
  285|  6.61k|  return static_cast<int>(begin - original_begin);
  286|  6.61k|}
charconv_parse.cc:_ZN4absl12lts_2026052612_GLOBAL__N_17IsDigitILi16EEEbc:
  187|  12.7M|bool IsDigit<16>(char ch) {
  188|  12.7M|  return kAsciiToInt[static_cast<unsigned char>(ch)] >= 0;
  189|  12.7M|}
charconv_parse.cc:_ZN4absl12lts_2026052612_GLOBAL__N_17ToDigitILi16EEEjc:
  196|  20.3k|unsigned ToDigit<16>(char ch) {
  197|  20.3k|  return static_cast<unsigned>(kAsciiToInt[static_cast<unsigned char>(ch)]);
  198|  20.3k|}

_ZN4absl12lts_2026052616strings_internal33CalculateBase64EscapedLenInternalEmb:
   26|      2|size_t CalculateBase64EscapedLenInternal(size_t input_len, bool do_padding) {
   27|       |  // Base64 encodes three bytes of input at a time. If the input is not
   28|       |  // divisible by three, we pad as appropriate.
   29|       |  //
   30|       |  // Base64 encodes each three bytes of input into four bytes of output.
   31|      2|  constexpr size_t kMaxSize = (std::numeric_limits<size_t>::max() - 1) / 4 * 3;
   32|      2|  ABSL_INTERNAL_CHECK(input_len <= kMaxSize,
  ------------------
  |  |   85|      2|  do {                                                             \
  |  |   86|      2|    if (ABSL_PREDICT_FALSE(!(condition))) {                        \
  |  |  ------------------
  |  |  |  |  190|      2|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 2]
  |  |  |  |  |  Branch (190:49): [Folded, False: 2]
  |  |  |  |  |  Branch (190:58): [True: 0, False: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   87|      0|      std::string death_message = "Check " #condition " failed: "; \
  |  |   88|      0|      death_message += std::string(message);                       \
  |  |   89|      0|      ABSL_INTERNAL_LOG(FATAL, death_message);                     \
  |  |  ------------------
  |  |  |  |   76|      0|  do {                                                                    \
  |  |  |  |   77|      0|    constexpr const char* absl_raw_log_internal_filename = __FILE__;      \
  |  |  |  |   78|      0|    ::absl::raw_log_internal::internal_log_function(                      \
  |  |  |  |   79|      0|        ABSL_RAW_LOG_INTERNAL_##severity, absl_raw_log_internal_filename, \
  |  |  |  |  ------------------
  |  |  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  |  |  ------------------
  |  |  |  |   80|      0|        __LINE__, message);                                               \
  |  |  |  |   81|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                   \
  |  |  |  |  ------------------
  |  |  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   82|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (82:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   90|      0|    }                                                              \
  |  |   91|      2|  } while (0)
  |  |  ------------------
  |  |  |  Branch (91:12): [Folded, False: 2]
  |  |  ------------------
  ------------------
   33|      2|                      "CalculateBase64EscapedLenInternal() overflow");
   34|      2|  size_t len = (input_len / 3) * 4;
   35|       |
   36|       |  // Since all base 64 input is an integral number of octets, only the following
   37|       |  // cases can arise:
   38|      2|  if (input_len % 3 == 0) {
  ------------------
  |  Branch (38:7): [True: 0, False: 2]
  ------------------
   39|       |    // (from https://tools.ietf.org/html/rfc3548)
   40|       |    // (1) the final quantum of encoding input is an integral multiple of 24
   41|       |    // bits; here, the final unit of encoded output will be an integral
   42|       |    // multiple of 4 characters with no "=" padding,
   43|      2|  } else if (input_len % 3 == 1) {
  ------------------
  |  Branch (43:14): [True: 0, False: 2]
  ------------------
   44|       |    // (from https://tools.ietf.org/html/rfc3548)
   45|       |    // (2) the final quantum of encoding input is exactly 8 bits; here, the
   46|       |    // final unit of encoded output will be two characters followed by two
   47|       |    // "=" padding characters, or
   48|      0|    len += 2;
   49|      0|    if (do_padding) {
  ------------------
  |  Branch (49:9): [True: 0, False: 0]
  ------------------
   50|      0|      len += 2;
   51|      0|    }
   52|      2|  } else {  // (input_len % 3 == 2)
   53|       |    // (from https://tools.ietf.org/html/rfc3548)
   54|       |    // (3) the final quantum of encoding input is exactly 16 bits; here, the
   55|       |    // final unit of encoded output will be three characters followed by one
   56|       |    // "=" padding character.
   57|      2|    len += 3;
   58|      2|    if (do_padding) {
  ------------------
  |  Branch (58:9): [True: 0, False: 2]
  ------------------
   59|      0|      len += 1;
   60|      0|    }
   61|      2|  }
   62|       |
   63|      2|  return len;
   64|      2|}

_ZN4absl12lts_2026052616strings_internal10memcasecmpEPKcS3_m:
   25|  1.15k|int memcasecmp(const char* s1, const char* s2, size_t len) {
   26|  1.15k|  const unsigned char* us1 = reinterpret_cast<const unsigned char*>(s1);
   27|  1.15k|  const unsigned char* us2 = reinterpret_cast<const unsigned char*>(s2);
   28|       |
   29|  3.38k|  for (size_t i = 0; i < len; i++) {
  ------------------
  |  Branch (29:22): [True: 2.29k, False: 1.09k]
  ------------------
   30|  2.29k|    unsigned char c1 = us1[i];
   31|  2.29k|    unsigned char c2 = us2[i];
   32|       |    // If bytes are the same, they will be the same when converted to lower.
   33|       |    // So we only need to convert if bytes are not equal.
   34|       |    // NOTE(b/308193381): We do not use `absl::ascii_tolower` here in order
   35|       |    // to avoid its lookup table and improve performance.
   36|  2.29k|    if (c1 != c2) {
  ------------------
  |  Branch (36:9): [True: 556, False: 1.74k]
  ------------------
   37|    556|      c1 = c1 >= 'A' && c1 <= 'Z' ? c1 - 'A' + 'a' : c1;
  ------------------
  |  Branch (37:12): [True: 542, False: 14]
  |  Branch (37:25): [True: 521, False: 21]
  ------------------
   38|    556|      c2 = c2 >= 'A' && c2 <= 'Z' ? c2 - 'A' + 'a' : c2;
  ------------------
  |  Branch (38:12): [True: 556, False: 0]
  |  Branch (38:25): [True: 0, False: 556]
  ------------------
   39|    556|      const int diff = int{c1} - int{c2};
   40|    556|      if (diff != 0) return diff;
  ------------------
  |  Branch (40:11): [True: 59, False: 497]
  ------------------
   41|    556|    }
   42|  2.29k|  }
   43|  1.09k|  return 0;
   44|  1.15k|}

_ZN4absl12lts_2026052610StartsWithENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEES5_:
   59|      8|                                 absl::string_view prefix) noexcept {
   60|      8|  if (prefix.empty()) {
  ------------------
  |  Branch (60:7): [True: 0, False: 8]
  ------------------
   61|      0|    return true;
   62|      0|  }
   63|      8|  if (text.size() < prefix.size()) {
  ------------------
  |  Branch (63:7): [True: 0, False: 8]
  ------------------
   64|      0|    return false;
   65|      0|  }
   66|      8|  absl::string_view possible_match = text.substr(0, prefix.size());
   67|       |
   68|      8|  return possible_match == prefix;
   69|      8|}
_ZN4absl12lts_2026052611StrContainsENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEES5_:
   47|      2|                        absl::string_view needle) noexcept {
   48|      2|  return haystack.find(needle, 0) != haystack.npos;
   49|      2|}

_ZN4absl12lts_2026052610SimpleAtodENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEPd:
   86|  25.1k|bool SimpleAtod(absl::string_view str, double* absl_nonnull out) {
   87|  25.1k|  *out = 0.0;
   88|  25.1k|  str = StripAsciiWhitespace(str);
   89|  25.1k|  if (str.empty()) {
  ------------------
  |  Branch (89:7): [True: 8, False: 25.1k]
  ------------------
   90|       |    // absl::from_chars doesn't accept empty strings.
   91|      8|    return false;
   92|      8|  }
   93|       |  // std::from_chars doesn't accept an initial +, but SimpleAtod does, so if one
   94|       |  // is present, skip it, while avoiding accepting "+-0" as valid.
   95|  25.1k|  if (str[0] == '+') {
  ------------------
  |  Branch (95:7): [True: 340, False: 24.8k]
  ------------------
   96|    340|    str.remove_prefix(1);
   97|    340|    if (str.empty() || str[0] == '-') {
  ------------------
  |  Branch (97:9): [True: 1, False: 339]
  |  Branch (97:24): [True: 1, False: 338]
  ------------------
   98|      2|      return false;
   99|      2|    }
  100|    340|  }
  101|  25.1k|  auto result = absl::from_chars(str.data(), str.data() + str.size(), *out);
  102|  25.1k|  if (result.ec == std::errc::invalid_argument) {
  ------------------
  |  Branch (102:7): [True: 110, False: 25.0k]
  ------------------
  103|    110|    return false;
  104|    110|  }
  105|  25.0k|  if (result.ptr != str.data() + str.size()) {
  ------------------
  |  Branch (105:7): [True: 306, False: 24.7k]
  ------------------
  106|       |    // not all non-whitespace characters consumed
  107|    306|    return false;
  108|    306|  }
  109|       |  // from_chars() with DR 3081's current wording will return max() on
  110|       |  // overflow.  SimpleAtod returns infinity instead.
  111|  24.7k|  if (result.ec == std::errc::result_out_of_range) {
  ------------------
  |  Branch (111:7): [True: 3.72k, False: 21.0k]
  ------------------
  112|  3.72k|    if (*out > 1.0) {
  ------------------
  |  Branch (112:9): [True: 2.30k, False: 1.42k]
  ------------------
  113|  2.30k|      *out = std::numeric_limits<double>::infinity();
  114|  2.30k|    } else if (*out < -1.0) {
  ------------------
  |  Branch (114:16): [True: 203, False: 1.22k]
  ------------------
  115|    203|      *out = -std::numeric_limits<double>::infinity();
  116|    203|    }
  117|  3.72k|  }
  118|  24.7k|  return true;
  119|  25.0k|}
_ZN4absl12lts_2026052616numbers_internal18safe_strtou64_baseENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPmi:
 1625|  10.3k|                        int base) {
 1626|  10.3k|  return safe_uint_internal<uint64_t>(text, value, base);
 1627|  10.3k|}
numbers.cc:_ZN4absl12lts_2026052612_GLOBAL__N_124safe_parse_sign_and_baseEPNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPiPb:
 1168|  10.3k|    bool* absl_nonnull negative_ptr /*output*/) {
 1169|  10.3k|  if (text->data() == nullptr) {
  ------------------
  |  Branch (1169:7): [True: 0, False: 10.3k]
  ------------------
 1170|      0|    return false;
 1171|      0|  }
 1172|       |
 1173|  10.3k|  const char* start = text->data();
 1174|  10.3k|  const char* end = start + text->size();
 1175|  10.3k|  int base = *base_ptr;
 1176|       |
 1177|       |  // Consume whitespace.
 1178|  10.3k|  while (start < end &&
  ------------------
  |  Branch (1178:10): [True: 10.3k, False: 8]
  ------------------
 1179|  10.3k|         absl::ascii_isspace(static_cast<unsigned char>(start[0]))) {
  ------------------
  |  Branch (1179:10): [True: 0, False: 10.3k]
  ------------------
 1180|      0|    ++start;
 1181|      0|  }
 1182|  10.5k|  while (start < end &&
  ------------------
  |  Branch (1182:10): [True: 10.5k, False: 8]
  ------------------
 1183|  10.5k|         absl::ascii_isspace(static_cast<unsigned char>(end[-1]))) {
  ------------------
  |  Branch (1183:10): [True: 194, False: 10.3k]
  ------------------
 1184|    194|    --end;
 1185|    194|  }
 1186|  10.3k|  if (start >= end) {
  ------------------
  |  Branch (1186:7): [True: 8, False: 10.3k]
  ------------------
 1187|      8|    return false;
 1188|      8|  }
 1189|       |
 1190|       |  // Consume sign.
 1191|  10.3k|  *negative_ptr = (start[0] == '-');
 1192|  10.3k|  if (*negative_ptr || start[0] == '+') {
  ------------------
  |  Branch (1192:7): [True: 2, False: 10.3k]
  |  Branch (1192:24): [True: 235, False: 10.0k]
  ------------------
 1193|    237|    ++start;
 1194|    237|    if (start >= end) {
  ------------------
  |  Branch (1194:9): [True: 6, False: 231]
  ------------------
 1195|      6|      return false;
 1196|      6|    }
 1197|    237|  }
 1198|       |
 1199|       |  // Consume base-dependent prefix.
 1200|       |  //  base 0: "0x" -> base 16, "0" -> base 8, default -> base 10
 1201|       |  //  base 16: "0x" -> base 16
 1202|       |  // Also validate the base.
 1203|  10.3k|  if (base == 0) {
  ------------------
  |  Branch (1203:7): [True: 0, False: 10.3k]
  ------------------
 1204|      0|    if (end - start >= 2 && start[0] == '0' &&
  ------------------
  |  Branch (1204:9): [True: 0, False: 0]
  |  Branch (1204:29): [True: 0, False: 0]
  ------------------
 1205|      0|        (start[1] == 'x' || start[1] == 'X')) {
  ------------------
  |  Branch (1205:10): [True: 0, False: 0]
  |  Branch (1205:29): [True: 0, False: 0]
  ------------------
 1206|      0|      base = 16;
 1207|      0|      start += 2;
 1208|      0|      if (start >= end) {
  ------------------
  |  Branch (1208:11): [True: 0, False: 0]
  ------------------
 1209|       |        // "0x" with no digits after is invalid.
 1210|      0|        return false;
 1211|      0|      }
 1212|      0|    } else if (end - start >= 1 && start[0] == '0') {
  ------------------
  |  Branch (1212:16): [True: 0, False: 0]
  |  Branch (1212:36): [True: 0, False: 0]
  ------------------
 1213|      0|      base = 8;
 1214|      0|      start += 1;
 1215|      0|    } else {
 1216|      0|      base = 10;
 1217|      0|    }
 1218|  10.3k|  } else if (base == 16) {
  ------------------
  |  Branch (1218:14): [True: 0, False: 10.3k]
  ------------------
 1219|      0|    if (end - start >= 2 && start[0] == '0' &&
  ------------------
  |  Branch (1219:9): [True: 0, False: 0]
  |  Branch (1219:29): [True: 0, False: 0]
  ------------------
 1220|      0|        (start[1] == 'x' || start[1] == 'X')) {
  ------------------
  |  Branch (1220:10): [True: 0, False: 0]
  |  Branch (1220:29): [True: 0, False: 0]
  ------------------
 1221|      0|      start += 2;
 1222|      0|      if (start >= end) {
  ------------------
  |  Branch (1222:11): [True: 0, False: 0]
  ------------------
 1223|       |        // "0x" with no digits after is invalid.
 1224|      0|        return false;
 1225|      0|      }
 1226|      0|    }
 1227|  10.3k|  } else if (base >= 2 && base <= 36) {
  ------------------
  |  Branch (1227:14): [True: 10.3k, False: 0]
  |  Branch (1227:27): [True: 10.3k, False: 0]
  ------------------
 1228|       |    // okay
 1229|  10.3k|  } else {
 1230|      0|    return false;
 1231|      0|  }
 1232|  10.3k|  *text = absl::string_view(start, static_cast<size_t>(end - start));
 1233|  10.3k|  *base_ptr = base;
 1234|  10.3k|  return true;
 1235|  10.3k|}
numbers.cc:_ZN4absl12lts_2026052612_GLOBAL__N_118safe_uint_internalImEEbNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPT_i:
 1550|  10.3k|                               IntType* absl_nonnull value_p, int base) {
 1551|  10.3k|  *value_p = 0;
 1552|  10.3k|  bool negative;
 1553|  10.3k|  if (!safe_parse_sign_and_base(&text, &base, &negative) || negative) {
  ------------------
  |  Branch (1553:7): [True: 14, False: 10.3k]
  |  Branch (1553:61): [True: 1, False: 10.3k]
  ------------------
 1554|     15|    return false;
 1555|     15|  }
 1556|  10.3k|  return safe_parse_positive_int(text, base, value_p);
 1557|  10.3k|}
numbers.cc:_ZN4absl12lts_2026052612_GLOBAL__N_123safe_parse_positive_intImEEbNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEiPT_:
 1453|  10.3k|                                    IntType* absl_nonnull value_p) {
 1454|  10.3k|  IntType value = 0;
 1455|  10.3k|  const IntType vmax = std::numeric_limits<IntType>::max();
 1456|  10.3k|  assert(vmax > 0);
 1457|  10.3k|  assert(base >= 0);
 1458|  10.3k|  const IntType base_inttype = static_cast<IntType>(base);
 1459|  10.3k|  assert(vmax >= base_inttype);
 1460|  10.3k|  const IntType vmax_over_base = LookupTables<IntType>::kVmaxOverBase[base];
 1461|  10.3k|  assert(base < 2 ||
 1462|  10.3k|         std::numeric_limits<IntType>::max() / base_inttype == vmax_over_base);
 1463|  10.3k|  const char* start = text.data();
 1464|  10.3k|  const char* end = start + text.size();
 1465|       |  // loop over digits
 1466|  23.2k|  for (; start < end; ++start) {
  ------------------
  |  Branch (1466:10): [True: 13.0k, False: 10.2k]
  ------------------
 1467|  13.0k|    unsigned char c = static_cast<unsigned char>(start[0]);
 1468|  13.0k|    IntType digit = static_cast<IntType>(kAsciiToInt[c]);
 1469|  13.0k|    if (digit >= base_inttype) {
  ------------------
  |  Branch (1469:9): [True: 33, False: 13.0k]
  ------------------
 1470|     33|      *value_p = value;
 1471|     33|      return false;
 1472|     33|    }
 1473|  13.0k|    if (value > vmax_over_base) {
  ------------------
  |  Branch (1473:9): [True: 74, False: 12.9k]
  ------------------
 1474|     74|      *value_p = vmax;
 1475|     74|      return false;
 1476|     74|    }
 1477|  12.9k|    value *= base_inttype;
 1478|  12.9k|    if (value > vmax - digit) {
  ------------------
  |  Branch (1478:9): [True: 1, False: 12.9k]
  ------------------
 1479|      1|      *value_p = vmax;
 1480|      1|      return false;
 1481|      1|    }
 1482|  12.9k|    value += digit;
 1483|  12.9k|  }
 1484|  10.2k|  *value_p = value;
 1485|  10.2k|  return true;
 1486|  10.3k|}

_ZN4absl12lts_2026052616numbers_internal16safe_strtoi_baseImEEbNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPT_i:
  247|  10.3k|                                    int_type* absl_nonnull out, int base) {
  248|  10.3k|  static_assert(sizeof(*out) == 1 || sizeof(*out) == 2 || sizeof(*out) == 4 ||
  249|  10.3k|                    sizeof(*out) == 8,
  250|  10.3k|                "SimpleAtoi works only with 8, 16, 32, or 64-bit integers.");
  251|  10.3k|  static_assert(!std::is_floating_point<int_type>::value,
  252|  10.3k|                "Use SimpleAtof or SimpleAtod instead.");
  253|  10.3k|  bool parsed;
  254|       |  // These conditions are constexpr bools to suppress MSVC warning C4127.
  255|  10.3k|  constexpr bool kIsSigned = is_signed<int_type>();
  256|  10.3k|  constexpr int kIntTypeSize = sizeof(*out) * 8;
  257|  10.3k|  if (kIsSigned) {
  ------------------
  |  Branch (257:7): [Folded, False: 10.3k]
  ------------------
  258|      0|    if (kIntTypeSize == 64) {
  ------------------
  |  Branch (258:9): [True: 0, Folded]
  ------------------
  259|      0|      int64_t val;
  260|      0|      parsed = numbers_internal::safe_strto64_base(s, &val, base);
  261|      0|      *out = static_cast<int_type>(val);
  262|      0|    } else if (kIntTypeSize == 32) {
  ------------------
  |  Branch (262:16): [Folded, False: 0]
  ------------------
  263|      0|      int32_t val;
  264|      0|      parsed = numbers_internal::safe_strto32_base(s, &val, base);
  265|      0|      *out = static_cast<int_type>(val);
  266|      0|    } else if (kIntTypeSize == 16) {
  ------------------
  |  Branch (266:16): [Folded, False: 0]
  ------------------
  267|      0|      int16_t val;
  268|      0|      parsed = numbers_internal::safe_strto16_base(s, &val, base);
  269|      0|      *out = static_cast<int_type>(val);
  270|      0|    } else if (kIntTypeSize == 8) {
  ------------------
  |  Branch (270:16): [Folded, False: 0]
  ------------------
  271|      0|      int8_t val;
  272|      0|      parsed = numbers_internal::safe_strto8_base(s, &val, base);
  273|      0|      *out = static_cast<int_type>(val);
  274|      0|    }
  275|  10.3k|  } else {
  276|  10.3k|    if (kIntTypeSize == 64) {
  ------------------
  |  Branch (276:9): [True: 10.3k, Folded]
  ------------------
  277|  10.3k|      uint64_t val;
  278|  10.3k|      parsed = numbers_internal::safe_strtou64_base(s, &val, base);
  279|  10.3k|      *out = static_cast<int_type>(val);
  280|  10.3k|    } else if (kIntTypeSize == 32) {
  ------------------
  |  Branch (280:16): [Folded, False: 0]
  ------------------
  281|      0|      uint32_t val;
  282|      0|      parsed = numbers_internal::safe_strtou32_base(s, &val, base);
  283|      0|      *out = static_cast<int_type>(val);
  284|      0|    } else if (kIntTypeSize == 16) {
  ------------------
  |  Branch (284:16): [Folded, False: 0]
  ------------------
  285|      0|      uint16_t val;
  286|      0|      parsed = numbers_internal::safe_strtou16_base(s, &val, base);
  287|      0|      *out = static_cast<int_type>(val);
  288|      0|    } else if (kIntTypeSize == 8) {
  ------------------
  |  Branch (288:16): [Folded, False: 0]
  ------------------
  289|      0|      uint8_t val;
  290|      0|      parsed = numbers_internal::safe_strtou8_base(s, &val, base);
  291|      0|      *out = static_cast<int_type>(val);
  292|      0|    }
  293|  10.3k|  }
  294|  10.3k|  return parsed;
  295|  10.3k|}
_ZN4absl12lts_2026052610SimpleAtoiImEEbNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPT_:
  330|  10.3k|                              int_type* absl_nonnull out) {
  331|  10.3k|  return numbers_internal::safe_strtoi_base(str, out, 10);
  332|  10.3k|}

escaping.cc:_ZN4absl12lts_2026052624StringResizeAndOverwriteINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEZNS0_12_GLOBAL__N_128Base64EscapeToStringInternalEPKhmbPKcE3$_0EEvRT_NSF_9size_typeET0_:
  186|      2|void StringResizeAndOverwrite(T& str, typename T::size_type n, Op op) {
  187|      2|  strings_internal::StringResizeAndOverwriteImpl(str, n, std::move(op));
  188|       |#if defined(ABSL_HAVE_MEMORY_SANITIZER)
  189|       |  __msan_check_mem_is_initialized(str.data(), str.size());
  190|       |#endif
  191|      2|}
escaping.cc:_ZN4absl12lts_2026052616strings_internal28StringResizeAndOverwriteImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEZNS0_12_GLOBAL__N_128Base64EscapeToStringInternalEPKhmbPKcE3$_0EEvRT_NSG_9size_typeET0_:
  149|      2|void StringResizeAndOverwriteImpl(T& str, typename T::size_type n, Op op) {
  150|       |#ifdef ABSL_INTERNAL_HAS_RESIZE_AND_OVERWRITE
  151|       |  str.resize_and_overwrite(n, std::move(op));
  152|       |#else
  153|       |  if constexpr (strings_internal::
  154|       |                    has__google_nonstandard_backport_resize_and_overwrite<
  155|       |                        T>::value) {
  156|       |    str.__google_nonstandard_backport_resize_and_overwrite(n, std::move(op));
  157|       |  } else if constexpr (strings_internal::has__resize_and_overwrite<T>::value) {
  158|       |    str.__resize_and_overwrite(n, std::move(op));
  159|      2|  } else if constexpr (strings_internal::has__resize_default_init<T>::value) {
  160|      2|    str.__resize_default_init(n);
  161|      2|    str.__resize_default_init(
  162|      2|        static_cast<typename T::size_type>(std::move(op)(str.data(), n)));
  163|       |  } else if constexpr (strings_internal::has_Resize_and_overwrite<T>::value) {
  164|       |    str._Resize_and_overwrite(n, std::move(op));
  165|       |  } else {
  166|       |    strings_internal::StringResizeAndOverwriteFallback(str, n, std::move(op));
  167|       |  }
  168|      2|#endif
  169|      2|}
str_cat.cc:_ZN4absl12lts_2026052624StringResizeAndOverwriteINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEZNS0_6StrCatERKNS0_8AlphaNumESB_SB_E3$_0EEvRT_NSD_9size_typeET0_:
  186|      8|void StringResizeAndOverwrite(T& str, typename T::size_type n, Op op) {
  187|      8|  strings_internal::StringResizeAndOverwriteImpl(str, n, std::move(op));
  188|       |#if defined(ABSL_HAVE_MEMORY_SANITIZER)
  189|       |  __msan_check_mem_is_initialized(str.data(), str.size());
  190|       |#endif
  191|      8|}
str_cat.cc:_ZN4absl12lts_2026052616strings_internal28StringResizeAndOverwriteImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEZNS0_6StrCatERKNS0_8AlphaNumESC_SC_E3$_0EEvRT_NSE_9size_typeET0_:
  149|      8|void StringResizeAndOverwriteImpl(T& str, typename T::size_type n, Op op) {
  150|       |#ifdef ABSL_INTERNAL_HAS_RESIZE_AND_OVERWRITE
  151|       |  str.resize_and_overwrite(n, std::move(op));
  152|       |#else
  153|       |  if constexpr (strings_internal::
  154|       |                    has__google_nonstandard_backport_resize_and_overwrite<
  155|       |                        T>::value) {
  156|       |    str.__google_nonstandard_backport_resize_and_overwrite(n, std::move(op));
  157|       |  } else if constexpr (strings_internal::has__resize_and_overwrite<T>::value) {
  158|       |    str.__resize_and_overwrite(n, std::move(op));
  159|      8|  } else if constexpr (strings_internal::has__resize_default_init<T>::value) {
  160|      8|    str.__resize_default_init(n);
  161|      8|    str.__resize_default_init(
  162|      8|        static_cast<typename T::size_type>(std::move(op)(str.data(), n)));
  163|       |  } else if constexpr (strings_internal::has_Resize_and_overwrite<T>::value) {
  164|       |    str._Resize_and_overwrite(n, std::move(op));
  165|       |  } else {
  166|       |    strings_internal::StringResizeAndOverwriteFallback(str, n, std::move(op));
  167|       |  }
  168|      8|#endif
  169|      8|}

_ZN4absl12lts_202605266StrCatERKNS0_8AlphaNumES3_S3_:
   77|      8|std::string StrCat(const AlphaNum& a, const AlphaNum& b, const AlphaNum& c) {
   78|      8|  std::string result;
   79|       |  // Use uint64_t to prevent size_t overflow. We assume it is not possible for
   80|       |  // in memory strings to overflow a uint64_t.
   81|      8|  constexpr uint64_t kMaxSize = uint64_t{std::numeric_limits<size_t>::max()};
   82|      8|  const uint64_t result_size = static_cast<uint64_t>(a.size()) +
   83|      8|                               static_cast<uint64_t>(b.size()) +
   84|      8|                               static_cast<uint64_t>(c.size());
   85|      8|  ABSL_INTERNAL_CHECK(result_size <= kMaxSize, "size_t overflow");
  ------------------
  |  |   85|      8|  do {                                                             \
  |  |   86|      8|    if (ABSL_PREDICT_FALSE(!(condition))) {                        \
  |  |  ------------------
  |  |  |  |  190|      8|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 8]
  |  |  |  |  |  Branch (190:49): [Folded, False: 8]
  |  |  |  |  |  Branch (190:58): [True: 0, False: 8]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   87|      0|      std::string death_message = "Check " #condition " failed: "; \
  |  |   88|      0|      death_message += std::string(message);                       \
  |  |   89|      0|      ABSL_INTERNAL_LOG(FATAL, death_message);                     \
  |  |  ------------------
  |  |  |  |   76|      0|  do {                                                                    \
  |  |  |  |   77|      0|    constexpr const char* absl_raw_log_internal_filename = __FILE__;      \
  |  |  |  |   78|      0|    ::absl::raw_log_internal::internal_log_function(                      \
  |  |  |  |   79|      0|        ABSL_RAW_LOG_INTERNAL_##severity, absl_raw_log_internal_filename, \
  |  |  |  |  ------------------
  |  |  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  |  |  ------------------
  |  |  |  |   80|      0|        __LINE__, message);                                               \
  |  |  |  |   81|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                   \
  |  |  |  |  ------------------
  |  |  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   82|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (82:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   90|      0|    }                                                              \
  |  |   91|      8|  } while (0)
  |  |  ------------------
  |  |  |  Branch (91:12): [Folded, False: 8]
  |  |  ------------------
  ------------------
   86|      8|  absl::StringResizeAndOverwrite(
   87|      8|      result, static_cast<size_t>(result_size),
   88|      8|      [&a, &b, &c](char* const begin, size_t buf_size) {
   89|      8|        char* out = begin;
   90|      8|        out = Append(out, a);
   91|      8|        out = Append(out, b);
   92|      8|        out = Append(out, c);
   93|      8|        assert(out == begin + buf_size);
   94|      8|        return buf_size;
   95|      8|      });
   96|      8|  return result;
   97|      8|}
str_cat.cc:_ZN4absl12lts_2026052612_GLOBAL__N_16AppendEPcRKNS0_8AlphaNumE:
   46|     24|inline char* absl_nonnull Append(char* absl_nonnull out, const AlphaNum& x) {
   47|       |  // memcpy is allowed to overwrite arbitrary memory, so doing this after the
   48|       |  // call would force an extra fetch of x.size().
   49|     24|  char* after = out + x.size();
   50|     24|  if (x.size() != 0) {
  ------------------
  |  Branch (50:7): [True: 24, False: 0]
  ------------------
   51|     24|    memcpy(out, x.data(), x.size());
   52|     24|  }
   53|     24|  return after;
   54|     24|}
str_cat.cc:_ZZN4absl12lts_202605266StrCatERKNS0_8AlphaNumES3_S3_ENK3$_0clEPcm:
   88|      8|      [&a, &b, &c](char* const begin, size_t buf_size) {
   89|      8|        char* out = begin;
   90|      8|        out = Append(out, a);
   91|      8|        out = Append(out, b);
   92|      8|        out = Append(out, c);
   93|       |        assert(out == begin + buf_size);
   94|      8|        return buf_size;
   95|      8|      });

_ZN4absl12lts_202605268AlphaNumC2EPKc:
  400|     12|      : piece_(NullSafeStringView(c_str)) {}
_ZNK4absl12lts_202605268AlphaNum4sizeEv:
  430|     96|  absl::string_view::size_type size() const { return piece_.size(); }
_ZNK4absl12lts_202605268AlphaNum4dataEv:
  431|     24|  const char* absl_nullable data() const { return piece_.data(); }
_ZN4absl12lts_202605268AlphaNumC2INSt3__19allocatorIcEEEERKNS3_12basic_stringIcNS3_11char_traitsIcEET_EE:
  422|     12|      : piece_(str) {}

_ZN4absl12lts_2026052618NullSafeStringViewEPKc:
   53|     12|constexpr string_view NullSafeStringView(const char* absl_nullable p) {
   54|     12|  return p ? string_view(p) : string_view();
  ------------------
  |  Branch (54:10): [True: 12, False: 0]
  ------------------
   55|     12|}

_ZN4absl12lts_2026052613ConsumePrefixEPNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEES5_:
   49|      8|                                    absl::string_view expected) {
   50|      8|  if (!absl::StartsWith(*str, expected)) return false;
  ------------------
  |  Branch (50:7): [True: 0, False: 8]
  ------------------
   51|      8|  str->remove_prefix(expected.size());
   52|      8|  return true;
   53|      8|}

_ZN4absl12lts_2026052624synchronization_internal14InvalidGraphIdEv:
   58|    236|inline GraphId InvalidGraphId() {
   59|    236|  return GraphId{0};
   60|    236|}

_ZN4absl12lts_202605265Mutex4lockEv:
 1530|    236|void Mutex::lock() {
 1531|    236|  ABSL_TSAN_MUTEX_PRE_LOCK(this, 0);
 1532|    236|  GraphId id = DebugOnlyDeadlockCheck(this);
 1533|    236|  intptr_t v = mu_.load(std::memory_order_relaxed);
 1534|       |  // try fast acquire, then spin loop
 1535|    236|  if (ABSL_PREDICT_FALSE((v & (kMuWriter | kMuReader | kMuEvent)) != 0) ||
  ------------------
  |  |  190|    472|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 236]
  |  |  |  Branch (190:49): [Folded, False: 236]
  |  |  |  Branch (190:58): [True: 0, False: 236]
  |  |  ------------------
  ------------------
 1536|    236|      ABSL_PREDICT_FALSE(!mu_.compare_exchange_strong(
  ------------------
  |  |  190|    236|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 236]
  |  |  |  Branch (190:49): [Folded, False: 236]
  |  |  |  Branch (190:58): [True: 0, False: 236]
  |  |  ------------------
  ------------------
 1537|    236|          v, kMuWriter | v, std::memory_order_acquire,
 1538|    236|          std::memory_order_relaxed))) {
 1539|       |    // try spin acquire, then slow loop
 1540|      0|    if (ABSL_PREDICT_FALSE(!TryAcquireWithSpinning(&this->mu_))) {
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1541|      0|      this->LockSlow(kExclusive, nullptr, 0);
 1542|      0|    }
 1543|      0|  }
 1544|    236|  DebugOnlyLockEnter(this, id);
 1545|    236|  ABSL_TSAN_MUTEX_POST_LOCK(this, 0, 0);
 1546|    236|}
_ZN4absl12lts_202605265Mutex6unlockEv:
 1708|    236|void Mutex::unlock() {
 1709|    236|  ABSL_TSAN_MUTEX_PRE_UNLOCK(this, 0);
 1710|    236|  DebugOnlyLockLeave(this);
 1711|    236|  intptr_t v = mu_.load(std::memory_order_relaxed);
 1712|       |
 1713|    236|  if (kDebugMode && ((v & (kMuWriter | kMuReader)) != kMuWriter)) {
  ------------------
  |  Branch (1713:7): [Folded, False: 236]
  |  Branch (1713:21): [True: 0, False: 0]
  ------------------
 1714|      0|    ABSL_RAW_LOG(FATAL, "Mutex unlocked when destroyed or not locked: v=0x%x",
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1715|      0|                 static_cast<unsigned>(v));
 1716|      0|  }
 1717|       |
 1718|       |  // should_try_cas is whether we'll try a compare-and-swap immediately.
 1719|       |  // NOTE: optimized out when kDebugMode is false.
 1720|    236|  bool should_try_cas = ((v & (kMuEvent | kMuWriter)) == kMuWriter &&
  ------------------
  |  Branch (1720:26): [True: 236, False: 0]
  ------------------
 1721|    236|                         (v & (kMuWait | kMuDesig)) != kMuWait);
  ------------------
  |  Branch (1721:26): [True: 236, False: 0]
  ------------------
 1722|       |
 1723|       |  // But, we can use an alternate computation of it, that compilers
 1724|       |  // currently don't find on their own.  When that changes, this function
 1725|       |  // can be simplified.
 1726|       |  //
 1727|       |  // should_try_cas is true iff the bits satisfy the following conditions:
 1728|       |  //
 1729|       |  //                   Ev Wr Wa De
 1730|       |  // equal to           0  1
 1731|       |  // and not equal to         1  0
 1732|       |  //
 1733|       |  // after xoring by    0  1  0  1,  this is equivalent to:
 1734|       |  //
 1735|       |  // equal to           0  0
 1736|       |  // and not equal to         1  1,  which is the same as:
 1737|       |  //
 1738|       |  // smaller than       0  0  1  1
 1739|    236|  static_assert(kMuEvent > kMuWait, "Needed for should_try_cas_fast");
 1740|    236|  static_assert(kMuEvent > kMuDesig, "Needed for should_try_cas_fast");
 1741|    236|  static_assert(kMuWriter > kMuWait, "Needed for should_try_cas_fast");
 1742|    236|  static_assert(kMuWriter > kMuDesig, "Needed for should_try_cas_fast");
 1743|       |
 1744|    236|  bool should_try_cas_fast =
 1745|    236|      ((v ^ (kMuWriter | kMuDesig)) &
 1746|    236|       (kMuEvent | kMuWriter | kMuWait | kMuDesig)) < (kMuWait | kMuDesig);
 1747|       |
 1748|    236|  if (kDebugMode && should_try_cas != should_try_cas_fast) {
  ------------------
  |  Branch (1748:7): [Folded, False: 236]
  |  Branch (1748:21): [True: 0, False: 0]
  ------------------
 1749|       |    // We would usually use PRIdPTR here, but is not correctly implemented
 1750|       |    // within the android toolchain.
 1751|      0|    ABSL_RAW_LOG(FATAL, "internal logic error %llx %llx %llx\n",
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1752|      0|                 static_cast<long long>(v),
 1753|      0|                 static_cast<long long>(should_try_cas),
 1754|      0|                 static_cast<long long>(should_try_cas_fast));
 1755|      0|  }
 1756|    236|  if (should_try_cas_fast &&
  ------------------
  |  Branch (1756:7): [True: 236, False: 0]
  ------------------
 1757|    236|      mu_.compare_exchange_strong(v, v & ~(kMuWrWait | kMuWriter),
  ------------------
  |  Branch (1757:7): [True: 236, False: 0]
  ------------------
 1758|    236|                                  std::memory_order_release,
 1759|    236|                                  std::memory_order_relaxed)) {
 1760|       |    // fast writer release (writer with no waiters or with designated waker)
 1761|    236|  } else {
 1762|      0|    this->UnlockSlow(nullptr /*no waitp*/);  // take slow path
 1763|      0|  }
 1764|    236|  ABSL_TSAN_MUTEX_POST_UNLOCK(this, 0);
 1765|    236|}
mutex.cc:_ZN4absl12lts_20260526L22DebugOnlyDeadlockCheckEPNS0_5MutexE:
 1472|    236|static inline GraphId DebugOnlyDeadlockCheck(Mutex* mu) {
 1473|    236|  if (kDebugMode && synch_deadlock_detection.load(std::memory_order_acquire) !=
  ------------------
  |  Branch (1473:7): [Folded, False: 236]
  |  Branch (1473:21): [True: 0, False: 0]
  ------------------
 1474|      0|                        OnDeadlockCycle::kIgnore) {
 1475|      0|    return DeadlockCheck(mu);
 1476|    236|  } else {
 1477|    236|    return InvalidGraphId();
 1478|    236|  }
 1479|    236|}
mutex.cc:_ZN4absl12lts_20260526L18DebugOnlyLockEnterEPNS0_5MutexENS0_24synchronization_internal7GraphIdE:
 1305|    236|static inline void DebugOnlyLockEnter(Mutex* mu, GraphId id) {
 1306|    236|  if (kDebugMode) {
  ------------------
  |  Branch (1306:7): [Folded, False: 236]
  ------------------
 1307|      0|    if (synch_deadlock_detection.load(std::memory_order_acquire) !=
  ------------------
  |  Branch (1307:9): [True: 0, False: 0]
  ------------------
 1308|      0|        OnDeadlockCycle::kIgnore) {
 1309|      0|      LockEnter(mu, id, Synch_GetAllLocks());
 1310|      0|    }
 1311|      0|  }
 1312|    236|}
mutex.cc:_ZN4absl12lts_20260526L18DebugOnlyLockLeaveEPNS0_5MutexE:
 1315|    236|static inline void DebugOnlyLockLeave(Mutex* mu) {
 1316|    236|  if (kDebugMode) {
  ------------------
  |  Branch (1316:7): [Folded, False: 236]
  ------------------
 1317|      0|    if (synch_deadlock_detection.load(std::memory_order_acquire) !=
  ------------------
  |  Branch (1317:9): [True: 0, False: 0]
  ------------------
 1318|      0|        OnDeadlockCycle::kIgnore) {
 1319|      0|      LockLeave(mu, GetGraphId(mu), Synch_GetAllLocks());
 1320|      0|    }
 1321|      0|  }
 1322|    236|}

_ZN4absl12lts_202605269MutexLockC2ERNS0_5MutexE:
  626|    170|      : mu_(mu) {
  627|    170|    this->mu_.lock();
  628|    170|  }
_ZN4absl12lts_202605269MutexLockD2Ev:
  658|    170|  ~MutexLock() ABSL_UNLOCK_FUNCTION() { this->mu_.unlock(); }
_ZN4absl12lts_202605265MutexC2Ev:
 1186|     74|inline Mutex::Mutex() : mu_(0) {
 1187|     74|  ABSL_TSAN_MUTEX_CREATE(this, __tsan_mutex_not_static);
 1188|     74|}

_ZN4absl12lts_202605263NowEv:
   39|  3.40k|Time Now() {
   40|       |  // TODO(bww): Get a timespec instead so we don't have to divide.
   41|  3.40k|  int64_t n = absl::GetCurrentTimeNanos();
   42|  3.40k|  if (n >= 0) {
  ------------------
  |  Branch (42:7): [True: 3.40k, False: 0]
  ------------------
   43|  3.40k|    return time_internal::FromUnixDuration(
   44|  3.40k|        time_internal::MakeDuration(n / 1000000000, n % 1000000000 * 4));
   45|  3.40k|  }
   46|      0|  return time_internal::FromUnixDuration(absl::Nanoseconds(n));
   47|  3.40k|}
_ZN4absl12lts_2026052619GetCurrentTimeNanosEv:
   77|  3.40k|int64_t GetCurrentTimeNanos() { return GET_CURRENT_TIME_NANOS_FROM_SYSTEM(); }
  ------------------
  |  |   71|  3.40k|  ::absl::time_internal::GetCurrentTimeNanosFromSystem()
  ------------------

_ZN4absl12lts_202605268DurationmIES1_:
  436|  2.26k|Duration& Duration::operator-=(Duration rhs) {
  437|  2.26k|  if (time_internal::IsInfiniteDuration(*this)) return *this;
  ------------------
  |  Branch (437:7): [True: 0, False: 2.26k]
  ------------------
  438|  2.26k|  if (time_internal::IsInfiniteDuration(rhs)) {
  ------------------
  |  Branch (438:7): [True: 0, False: 2.26k]
  ------------------
  439|      0|    return *this = rhs.rep_hi_.Get() >= 0 ? -InfiniteDuration()
  ------------------
  |  Branch (439:20): [True: 0, False: 0]
  ------------------
  440|      0|                                          : InfiniteDuration();
  441|      0|  }
  442|  2.26k|  const int64_t orig_rep_hi = rep_hi_.Get();
  443|  2.26k|  rep_hi_ = DecodeTwosComp(EncodeTwosComp(rep_hi_.Get()) -
  444|  2.26k|                           EncodeTwosComp(rhs.rep_hi_.Get()));
  445|  2.26k|  if (rep_lo_ < rhs.rep_lo_) {
  ------------------
  |  Branch (445:7): [True: 0, False: 2.26k]
  ------------------
  446|      0|    rep_hi_ = DecodeTwosComp(EncodeTwosComp(rep_hi_.Get()) - 1);
  447|      0|    rep_lo_ += kTicksPerSecond;
  448|      0|  }
  449|  2.26k|  rep_lo_ -= rhs.rep_lo_;
  450|  2.26k|  if (rhs.rep_hi_.Get() < 0 ? rep_hi_.Get() < orig_rep_hi
  ------------------
  |  Branch (450:7): [True: 0, False: 2.26k]
  |  Branch (450:7): [True: 0, False: 2.26k]
  ------------------
  451|  2.26k|                            : rep_hi_.Get() > orig_rep_hi) {
  452|      0|    return *this = rhs.rep_hi_.Get() >= 0 ? -InfiniteDuration()
  ------------------
  |  Branch (452:20): [True: 0, False: 0]
  ------------------
  453|      0|                                          : InfiniteDuration();
  454|      0|  }
  455|  2.26k|  return *this;
  456|  2.26k|}
duration.cc:_ZN4absl12lts_2026052612_GLOBAL__N_114DecodeTwosCompEm:
  187|  2.26k|inline int64_t DecodeTwosComp(uint64_t v) { return absl::bit_cast<int64_t>(v); }
duration.cc:_ZN4absl12lts_2026052612_GLOBAL__N_114EncodeTwosCompEl:
  184|  4.53k|inline uint64_t EncodeTwosComp(int64_t v) {
  185|  4.53k|  return absl::bit_cast<uint64_t>(v);
  186|  4.53k|}

clock.cc:_ZN4absl12lts_2026052613time_internalL29GetCurrentTimeNanosFromSystemEv:
   13|  3.40k|static int64_t GetCurrentTimeNanosFromSystem() {
   14|  3.40k|  const int64_t kNanosPerSecond = 1000 * 1000 * 1000;
   15|  3.40k|  struct timespec ts;
   16|  3.40k|  ABSL_RAW_CHECK(clock_gettime(CLOCK_REALTIME, &ts) == 0,
  ------------------
  |  |   60|  3.40k|  do {                                                                 \
  |  |   61|  3.40k|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  190|  3.40k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 3.40k]
  |  |  |  |  |  Branch (190:49): [Folded, False: 3.40k]
  |  |  |  |  |  Branch (190:58): [True: 0, False: 3.40k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   62|      0|      ABSL_RAW_LOG(FATAL, "Check %s failed: %s", #condition, message); \
  |  |  ------------------
  |  |  |  |   45|      0|  do {                                                                         \
  |  |  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  |  |  ------------------
  |  |  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  |  |  ------------------
  |  |  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  |  |  ------------------
  |  |  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   52|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|      0|    }                                                                  \
  |  |   64|  3.40k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 3.40k]
  |  |  ------------------
  ------------------
   17|  3.40k|                 "Failed to read real-time clock.");
   18|  3.40k|  return (int64_t{ts.tv_sec} * kNanosPerSecond +
   19|  3.40k|          int64_t{ts.tv_nsec});
   20|  3.40k|}

_ZN4absl12lts_202605268DurationC2Ev:
  186|  2.28k|  constexpr Duration() : rep_hi_(0), rep_lo_(0) {}  // zero-length duration
_ZN4absl12lts_202605268DurationC2Elj:
  248|  8.12k|  constexpr Duration(int64_t hi, uint32_t lo) : rep_hi_(hi), rep_lo_(lo) {}
_ZN4absl12lts_202605268Duration5HiRepC2El:
  268|  10.4k|          lo_(0),
  269|  10.4k|          hi_(0)
  270|       |#endif
  271|  10.4k|    {
  272|  10.4k|      *this = value;
  273|  10.4k|    }
_ZNK4absl12lts_202605268Duration5HiRep3GetEv:
  275|  25.2k|    constexpr int64_t Get() const {
  276|  25.2k|      const uint64_t unsigned_value =
  277|  25.2k|          (static_cast<uint64_t>(hi_) << 32) | static_cast<uint64_t>(lo_);
  278|       |      // `static_cast<int64_t>(unsigned_value)` is implementation-defined
  279|       |      // before c++20. On all supported platforms the behaviour is that mandated
  280|       |      // by c++20, i.e. "If the destination type is signed, [...] the result is
  281|       |      // the unique value of the destination type equal to the source value
  282|       |      // modulo 2^n, where n is the number of bits used to represent the
  283|       |      // destination type."
  284|  25.2k|      static_assert(
  285|  25.2k|          (static_cast<int64_t>((std::numeric_limits<uint64_t>::max)()) ==
  286|  25.2k|           int64_t{-1}) &&
  287|  25.2k|              (static_cast<int64_t>(static_cast<uint64_t>(
  288|  25.2k|                                        (std::numeric_limits<int64_t>::max)()) +
  289|  25.2k|                                    1) ==
  290|  25.2k|               (std::numeric_limits<int64_t>::min)()),
  291|  25.2k|          "static_cast<int64_t>(uint64_t) does not have c++20 semantics");
  292|  25.2k|      return static_cast<int64_t>(unsigned_value);
  293|  25.2k|    }
_ZN4absl12lts_202605268Duration5HiRepaSEl:
  295|  12.6k|    constexpr HiRep& operator=(const int64_t value) {
  296|       |      // "If the destination type is unsigned, the resulting value is the
  297|       |      // smallest unsigned value equal to the source value modulo 2^n
  298|       |      // where `n` is the number of bits used to represent the destination
  299|       |      // type".
  300|  12.6k|      const auto unsigned_value = static_cast<uint64_t>(value);
  301|  12.6k|      hi_ = static_cast<uint32_t>(unsigned_value >> 32);
  302|  12.6k|      lo_ = static_cast<uint32_t>(unsigned_value);
  303|  12.6k|      return *this;
  304|  12.6k|    }
_ZN4absl12lts_202605264TimeC2ENS0_8DurationE:
  878|  8.10k|  constexpr explicit Time(Duration rep) : rep_(rep) {}
_ZN4absl12lts_2026052613time_internal9FromInt64ILl1EEENS0_8DurationElNSt3__15ratioILl1EXT_EEE:
 1672|      2|                                                           std::ratio<1, N>) {
 1673|      2|  static_assert(0 < N && N <= 1000 * 1000 * 1000, "Unsupported ratio");
 1674|       |  // Subsecond ratios cannot overflow.
 1675|      2|  return MakeNormalizedDuration(
 1676|      2|      v / N, v % N * kTicksPerNanosecond * 1000 * 1000 * 1000 / N);
 1677|      2|}
_ZN4absl12lts_20260526gtENS0_8DurationES1_:
  337|  2.26k|                                                       Duration rhs) {
  338|  2.26k|  return rhs < lhs;
  339|  2.26k|}
_ZN4absl12lts_20260526leENS0_8DurationES1_:
  345|      8|                                                        Duration rhs) {
  346|      8|  return !(rhs < lhs);
  347|      8|}
_ZN4absl12lts_20260526miENS0_8DurationES1_:
  362|  2.26k|                                                        Duration rhs) {
  363|  2.26k|  return lhs -= rhs;
  364|  2.26k|}
_ZN4absl12lts_2026052612ZeroDurationEv:
  438|  2.27k|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr Duration ZeroDuration() {
  439|  2.27k|  return Duration();
  440|  2.27k|}
_ZN4absl12lts_20260526eqENS0_4TimeES1_:
  904|  4.70k|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr bool operator==(Time lhs, Time rhs) {
  905|  4.70k|  return lhs.rep_ == rhs.rep_;
  906|  4.70k|}
_ZN4absl12lts_20260526neENS0_4TimeES1_:
  907|  4.70k|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr bool operator!=(Time lhs, Time rhs) {
  908|  4.70k|  return !(lhs == rhs);
  909|  4.70k|}
_ZN4absl12lts_20260526miENS0_4TimeES1_:
  921|  2.26k|ABSL_ATTRIBUTE_CONST_FUNCTION inline Duration operator-(Time lhs, Time rhs) {
  922|  2.26k|  return lhs.rep_ - rhs.rep_;
  923|  2.26k|}
_ZN4absl12lts_2026052614InfiniteFutureEv:
  944|  4.70k|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr Time InfiniteFuture() {
  945|  4.70k|  return Time(time_internal::MakeDuration((std::numeric_limits<int64_t>::max)(),
  946|  4.70k|                                          ~uint32_t{0}));
  947|  4.70k|}
_ZN4absl12lts_2026052613time_internal12MakeDurationElj:
 1598|  8.12k|                                                              uint32_t lo = 0) {
 1599|  8.12k|  return Duration(hi, lo);
 1600|  8.12k|}
_ZN4absl12lts_2026052613time_internal12MakeDurationEll:
 1603|  3.40k|                                                              int64_t lo) {
 1604|  3.40k|  return MakeDuration(hi, static_cast<uint32_t>(lo));
 1605|  3.40k|}
_ZN4absl12lts_2026052613time_internal22MakeNormalizedDurationEll:
 1624|      2|    int64_t sec, int64_t ticks) {
 1625|      2|  return (ticks < 0) ? MakeDuration(sec - 1, ticks + kTicksPerSecond)
  ------------------
  |  Branch (1625:10): [True: 0, False: 2]
  ------------------
 1626|      2|                     : MakeDuration(sec, ticks);
 1627|      2|}
_ZN4absl12lts_2026052613time_internal8GetRepHiENS0_8DurationE:
 1630|  13.9k|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr int64_t GetRepHi(Duration d) {
 1631|  13.9k|  return d.rep_hi_.Get();
 1632|  13.9k|}
_ZN4absl12lts_2026052613time_internal8GetRepLoENS0_8DurationE:
 1633|  13.9k|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr uint32_t GetRepLo(Duration d) {
 1634|  13.9k|  return d.rep_lo_;
 1635|  13.9k|}
_ZN4absl12lts_2026052613time_internal18IsInfiniteDurationENS0_8DurationE:
 1638|  4.53k|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr bool IsInfiniteDuration(Duration d) {
 1639|  4.53k|  return GetRepLo(d) == ~uint32_t{0};
 1640|  4.53k|}
_ZN4absl12lts_2026052613time_internal16FromUnixDurationENS0_8DurationE:
 1663|  3.40k|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr Time FromUnixDuration(Duration d) {
 1664|  3.40k|  return Time(d);
 1665|  3.40k|}
_ZN4absl12lts_20260526ltENS0_8DurationES1_:
 1760|  2.27k|                                                       Duration rhs) {
 1761|  2.27k|  return time_internal::GetRepHi(lhs) != time_internal::GetRepHi(rhs)
  ------------------
  |  Branch (1761:10): [True: 2.27k, False: 6]
  ------------------
 1762|  2.27k|             ? time_internal::GetRepHi(lhs) < time_internal::GetRepHi(rhs)
 1763|  2.27k|         : time_internal::GetRepHi(lhs) == (std::numeric_limits<int64_t>::min)()
  ------------------
  |  Branch (1763:12): [True: 0, False: 6]
  ------------------
 1764|      6|             ? time_internal::GetRepLo(lhs) + 1 <
 1765|      0|                   time_internal::GetRepLo(rhs) + 1
 1766|      6|             : time_internal::GetRepLo(lhs) < time_internal::GetRepLo(rhs);
 1767|  2.27k|}
_ZN4absl12lts_20260526eqENS0_8DurationES1_:
 1788|  4.70k|                                                        Duration rhs) {
 1789|  4.70k|  return time_internal::GetRepHi(lhs) == time_internal::GetRepHi(rhs) &&
  ------------------
  |  Branch (1789:10): [True: 4.70k, False: 0]
  ------------------
 1790|  4.70k|         time_internal::GetRepLo(lhs) == time_internal::GetRepLo(rhs);
  ------------------
  |  Branch (1790:10): [True: 4.70k, False: 0]
  ------------------
 1791|  4.70k|}
_ZN4absl12lts_2026052616InfiniteDurationEv:
 1818|     10|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr Duration InfiniteDuration() {
 1819|     10|  return time_internal::MakeDuration((std::numeric_limits<int64_t>::max)(),
 1820|     10|                                     ~uint32_t{0});
 1821|     10|}
_ZN4absl12lts_202605267SecondsIiTnNSt3__19enable_ifIXoosr3std11is_integralIT_EE5valuesr3std7is_enumIS4_EE5valueEiE4typeELi0EEENS0_8DurationES4_:
  551|      2|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr Duration Seconds(T n) {
  552|      2|  return time_internal::FromInt64(n, std::ratio<1>{});
  553|      2|}
_ZN4absl12lts_202605264TimeC2Ev:
  803|      4|  constexpr Time() = default;

_ZN4absl12lts_2026052613span_internal7GetDataIKNSt3__16vectorIN8fuzztest8internal6no_adl8IRObjectENS3_9allocatorIS8_EEEEEEDTcl11GetDataImplfp_Li0EEERT_:
   50|  1.26k|    -> decltype(GetDataImpl(c, 0)) {
   51|  1.26k|  return GetDataImpl(c, 0);
   52|  1.26k|}
_ZN4absl12lts_2026052613span_internal11GetDataImplIKNSt3__16vectorIN8fuzztest8internal6no_adl8IRObjectENS3_9allocatorIS8_EEEEEEDTcldtfp_4dataEERT_c:
   38|  1.26k|    -> decltype(c.data()) {
   39|  1.26k|  return c.data();
   40|  1.26k|}
_ZN4absl12lts_2026052613span_internal7GetDataIKNSt3__16vectorIjNS3_9allocatorIjEEEEEEDTcl11GetDataImplfp_Li0EEERT_:
   50|      2|    -> decltype(GetDataImpl(c, 0)) {
   51|      2|  return GetDataImpl(c, 0);
   52|      2|}
_ZN4absl12lts_2026052613span_internal11GetDataImplIKNSt3__16vectorIjNS3_9allocatorIjEEEEEEDTcldtfp_4dataEERT_c:
   38|      2|    -> decltype(c.data()) {
   39|      2|  return c.data();
   40|      2|}
_ZN4absl12lts_2026052613span_internal7GetDataIKNS0_4SpanIjEEEEDTcl11GetDataImplfp_Li0EEERT_:
   50|     16|    -> decltype(GetDataImpl(c, 0)) {
   51|     16|  return GetDataImpl(c, 0);
   52|     16|}
_ZN4absl12lts_2026052613span_internal11GetDataImplIKNS0_4SpanIjEEEEDTcldtfp_4dataEERT_c:
   38|     16|    -> decltype(c.data()) {
   39|     16|  return c.data();
   40|     16|}

_ZN4absl12lts_2026052614SourceLocation7currentENS1_10PrivateTagEjPKc:
  113|  3.57k|      const char* absl_nonnull file_name = __builtin_FILE()) {
  114|  3.57k|    return SourceLocation(line, file_name);
  115|  3.57k|  }
_ZN4absl12lts_2026052614SourceLocationC2EjPKc:
  151|  3.57k|      : line_(line), file_name_(file_name) {}
_ZNK4absl12lts_2026052614SourceLocation9file_nameEv:
  133|  3.57k|  constexpr const char* absl_nonnull file_name() const noexcept {
  134|  3.57k|    return file_name_;
  135|  3.57k|  }

_ZN4absl12lts_202605264SpanIKN8fuzztest8internal6no_adl8IRObjectEEC2INSt3__16vectorIS5_NS9_9allocatorIS5_EEEEvSD_iEERKT_:
  254|  1.26k|      : Span(span_internal::GetData(v), v.size()) {}
_ZN4absl12lts_202605264SpanIKN8fuzztest8internal6no_adl8IRObjectEEC2EPS6_m:
  230|  1.26k|      : ptr_(array), len_(length) {}
_ZN4absl12lts_202605264SpanIKN8fuzztest8internal6no_adl8IRObjectEEC2Ev:
  227|      3|  constexpr Span() noexcept : Span(nullptr, 0) {}
_ZNK4absl12lts_202605264SpanIKN8fuzztest8internal6no_adl8IRObjectEE4sizeEv:
  323|  1.26k|  constexpr size_type size() const noexcept { return len_; }
_ZNK4absl12lts_202605264SpanIKN8fuzztest8internal6no_adl8IRObjectEE5beginEv:
  375|  1.15k|  constexpr iterator begin() const noexcept { return data(); }
_ZNK4absl12lts_202605264SpanIKN8fuzztest8internal6no_adl8IRObjectEE4dataEv:
  318|  1.15k|  constexpr pointer data() const noexcept { return ptr_; }
_ZNK4absl12lts_202605264SpanIjE4dataEv:
  318|     20|  constexpr pointer data() const noexcept { return ptr_; }
_ZNK4absl12lts_202605264SpanIjE4sizeEv:
  323|     20|  constexpr size_type size() const noexcept { return len_; }
_ZN4absl12lts_202605264SpanIKjEC2INSt3__16vectorIjNS5_9allocatorIjEEEEvS9_iEERKT_:
  254|      2|      : Span(span_internal::GetData(v), v.size()) {}
_ZN4absl12lts_202605264SpanIKjEC2EPS2_m:
  230|     18|      : ptr_(array), len_(length) {}
_ZNK4absl12lts_202605264SpanIKjE4dataEv:
  318|     34|  constexpr pointer data() const noexcept { return ptr_; }
_ZNK4absl12lts_202605264SpanIKjE4sizeEv:
  323|     18|  constexpr size_type size() const noexcept { return len_; }
_ZN4absl12lts_202605268MakeSpanITpTnRiJEjLm512EEENS0_4SpanIT0_EERAT1__S4_:
  764|      2|    T (&array ABSL_ATTRIBUTE_LIFETIME_BOUND)[N]) noexcept {
  765|      2|  return Span<T>(array, N);
  766|      2|}
_ZN4absl12lts_202605264SpanIjEC2EPjm:
  230|     18|      : ptr_(array), len_(length) {}
_ZNK4absl12lts_202605264SpanIKjE5beginEv:
  375|     16|  constexpr iterator begin() const noexcept { return data(); }
_ZNK4absl12lts_202605264SpanIKjE3endEv:
  388|     16|  constexpr iterator end() const noexcept { return data() + size(); }
_ZN4absl12lts_202605268MakeSpanITpTnRiJEjEENS0_4SpanIT0_EEPS4_m:
  734|     16|                           size_t size) noexcept {
  735|     16|  return Span<T>(ptr, size);
  736|     16|}
_ZN4absl12lts_202605264SpanIKjEC2INS1_IjEEvS5_TnNSt3__19enable_ifIXsr6IsViewIT_EE5valueEiE4typeELi0EEERKS8_:
  269|     16|      : Span(span_internal::GetData(v), v.size()) {}
_ZNK4absl12lts_202605264SpanIjE5emptyEv:
  333|      2|  constexpr bool empty() const noexcept { return size() == 0; }

_ZN8fuzztest15internal_no_adl7TupleOfITpTnRiJEJNS_8internal23SequenceContainerOfImplINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEENS3_13ArbitraryImplIcvEEEEEEEDaDpT0_:
  594|      2|auto TupleOf(Inner... inner) {
  595|      2|  return internal::AggregateOfImpl<std::tuple<internal::value_type_t<Inner>...>,
  596|      2|                                   internal::RequireCustomCorpusType::kNo,
  597|      2|                                   Inner...>(std::in_place,
  598|      2|                                             std::move(inner)...);
  599|      2|}
_ZN8fuzztest15internal_no_adl6StringEv:
  530|      2|inline auto String() { return Arbitrary<std::string>(); }
_ZN8fuzztest15internal_no_adl9ArbitraryINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEDav:
  281|      2|auto Arbitrary() {
  282|      2|  return internal::ArbitraryImpl<T>{};
  283|      2|}

main:
   20|      2|int main(int argc, char** argv) {
   21|      2|  absl::InitializeSymbolizer(argv[0]);
   22|      2|  absl::FailureSignalHandlerOptions options;
   23|      2|  options.call_previous_handler = true;
   24|      2|  absl::InstallFailureSignalHandler(options);
   25|      2|  testing::InitGoogleTest(&argc, argv);
   26|       |  // We call fuzztest::ParseAbslFlags rather than absl::ParseCommandLine
   27|       |  // since the latter would complain about any unknown flags that need
   28|       |  // to be passed to legacy fuzzing engines (e.g. libfuzzer).
   29|      2|  fuzztest::ParseAbslFlags(argc, argv);
   30|      2|  fuzztest::InitFuzzTest(&argc, &argv);
   31|      2|  return RUN_ALL_TESTS();
   32|      2|}

_ZN8fuzztest19ListRegisteredTestsEv:
  258|      6|std::vector<std::string> ListRegisteredTests() {
  259|      6|  std::vector<std::string> result;
  260|      6|  internal::ForEachTest(
  261|      6|      [&](const auto& test) { result.push_back(test.full_name()); });
  262|      6|  return result;
  263|      6|}
_ZN8fuzztest25GetMatchingFuzzTestOrExitENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE:
  265|      2|std::string GetMatchingFuzzTestOrExit(std::string_view name) {
  266|      2|  const std::string partial_name(name);
  267|      2|  const std::vector<std::string> full_names = ListRegisteredTests();
  268|      2|  std::vector<const std::string*> matches;
  269|      2|  for (const std::string& full_name : full_names) {
  ------------------
  |  Branch (269:37): [True: 2, False: 0]
  ------------------
  270|      2|    if (absl::StrContains(full_name, partial_name)) {
  ------------------
  |  Branch (270:9): [True: 2, False: 0]
  ------------------
  271|      2|      if (full_name == partial_name) {
  ------------------
  |  Branch (271:11): [True: 2, False: 0]
  ------------------
  272|       |        // In case of an exact match, we end the search and use it. This is to
  273|       |        // handle the case when we want to select `MySuite.MyTest`, but the
  274|       |        // binary has both `MySuite.MyTest` and `MySuite.MyTestX`.
  275|      2|        return full_name;
  276|      2|      } else {
  277|      0|        matches.push_back(&full_name);
  278|      0|      }
  279|      2|    }
  280|      2|  }
  281|       |
  282|      0|  if (matches.empty()) {
  ------------------
  |  Branch (282:7): [True: 0, False: 0]
  ------------------
  283|      0|    absl::FPrintF(stderr, "\n\nNo FUZZ_TEST matches the name: %s\n\n",
  284|      0|                  partial_name);
  285|      0|    absl::FPrintF(stderr, "Valid tests:\n");
  286|      0|    for (const std::string& full_name : full_names) {
  ------------------
  |  Branch (286:39): [True: 0, False: 0]
  ------------------
  287|      0|      absl::FPrintF(stderr, " %s\n", full_name);
  288|      0|    }
  289|      0|    exit(1);
  290|      0|  } else if (matches.size() > 1) {
  ------------------
  |  Branch (290:14): [True: 0, False: 0]
  ------------------
  291|      0|    absl::FPrintF(stderr, "\n\nMultiple FUZZ_TESTs match the name: %s\n\n",
  292|      0|                  partial_name);
  293|      0|    absl::FPrintF(stderr, "Please select one. Matching tests:\n");
  294|      0|    for (const std::string* full_name : matches) {
  ------------------
  |  Branch (294:39): [True: 0, False: 0]
  ------------------
  295|      0|      absl::FPrintF(stderr, " %s\n", *full_name);
  296|      0|    }
  297|      0|    exit(1);
  298|      0|  }
  299|      0|  return *matches[0];
  300|      0|}
_ZN8fuzztest12InitFuzzTestEPiPPPcNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEE:
  403|      2|void InitFuzzTest(int* argc, char*** argv, std::string_view binary_id) {
  404|      2|  auto& runtime = internal::Runtime::instance();
  405|      2|  const bool is_listing = absl::GetFlag(FUZZTEST_FLAG(list_fuzz_tests));
  ------------------
  |  |   20|      2|#define FUZZTEST_FLAG(name) FLAGS_##name
  ------------------
  406|      2|  if (is_listing) {
  ------------------
  |  Branch (406:7): [True: 0, False: 2]
  ------------------
  407|      0|    for (const auto& name : ListRegisteredTests()) {
  ------------------
  |  Branch (407:27): [True: 0, False: 0]
  ------------------
  408|      0|      std::cout << "[*] Fuzz test: " << name << '\n';
  409|      0|    }
  410|      0|    std::cout << std::flush;
  411|      0|    std::exit(0);
  412|      0|  }
  413|      2|  std::optional<absl::Duration> fuzzing_time_limit = GetFuzzingTime();
  414|      2|  std::optional<absl::Duration> replay_corpus_time_limit =
  415|      2|      GetReplayCorpusTime();
  416|      4|  FUZZTEST_CHECK(!fuzzing_time_limit || !replay_corpus_time_limit)
  ------------------
  |  |   22|      0|#define FUZZTEST_CHECK(cond) ABSL_CHECK(cond)
  |  |  ------------------
  |  |  |  |   41|      2|  ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition)
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  180|      2|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|      4|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|      4|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 2, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|      2|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 2]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|      8|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [True: 2, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, False: 2]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 2, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [Folded, False: 2]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|      0|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   29|      2|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      2|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  417|      4|      << "Cannot run in fuzzing and corpus replay mode at the same time.";
  418|      2|  const auto test_to_fuzz = absl::GetFlag(FUZZTEST_FLAG(fuzz));
  ------------------
  |  |   20|      2|#define FUZZTEST_FLAG(name) FLAGS_##name
  ------------------
  419|      2|  const auto test_to_replay_corpus =
  420|      2|      absl::GetFlag(FUZZTEST_FLAG(replay_corpus));
  ------------------
  |  |   20|      2|#define FUZZTEST_FLAG(name) FLAGS_##name
  ------------------
  421|      2|  const auto specified_test = []() -> std::optional<std::string> {
  422|      2|    if (auto internal_selected_test =
  423|      2|            absl::GetFlag(FUZZTEST_FLAG(internal_override_fuzz_test));
  424|      2|        internal_selected_test.has_value()) {
  425|      2|      return internal_selected_test;
  426|      2|    }
  427|      2|    if (auto test_to_fuzz = absl::GetFlag(FUZZTEST_FLAG(fuzz));
  428|      2|        test_to_fuzz != kUnspecified) {
  429|      2|      return test_to_fuzz;
  430|      2|    }
  431|      2|    if (auto test_to_replay_corpus =
  432|      2|            absl::GetFlag(FUZZTEST_FLAG(replay_corpus));
  433|      2|        test_to_replay_corpus != kUnspecified) {
  434|      2|      return test_to_replay_corpus;
  435|      2|    }
  436|      2|    return std::nullopt;
  437|      2|  }();
  438|      2|  if (specified_test.has_value()) {
  ------------------
  |  Branch (438:7): [True: 2, False: 0]
  ------------------
  439|      2|    const std::string matching_fuzz_test =
  440|      2|        GetMatchingFuzzTestOrExit(*specified_test);
  441|       |    // Delegate the test to GoogleTest.
  442|      2|    GTEST_FLAG_SET(filter, matching_fuzz_test);
  443|      2|  }
  444|       |
  445|      2|  std::string derived_binary_id =
  446|      2|      binary_id.empty() ? std::string(internal::Basename(*argv[0]))
  ------------------
  |  Branch (446:7): [True: 2, False: 0]
  ------------------
  447|      2|                        : std::string(binary_id);
  448|      2|  std::optional<std::string> reproduction_command_template;
  449|      2|  internal::Configuration configuration =
  450|      2|      CreateConfigurationsFromFlags(derived_binary_id);
  451|      2|  configuration.reproduction_command_template = reproduction_command_template;
  452|      2|  internal::RegisterFuzzTestsAsGoogleTests(argc, argv, configuration);
  453|       |
  454|      2|  const bool is_fuzzing_or_replaying =
  455|      2|      (fuzzing_time_limit || replay_corpus_time_limit);
  ------------------
  |  Branch (455:8): [True: 2, False: 0]
  |  Branch (455:30): [True: 0, False: 0]
  ------------------
  456|      2|  if (is_fuzzing_or_replaying && !specified_test.has_value()) {
  ------------------
  |  Branch (456:7): [True: 2, False: 0]
  |  Branch (456:34): [True: 0, False: 2]
  ------------------
  457|      0|    absl::flat_hash_set<std::string> fuzz_tests = {
  458|      0|        configuration.fuzz_tests.begin(), configuration.fuzz_tests.end()};
  459|      0|    std::vector<std::string> non_fuzz_tests;
  460|      0|    for (const auto* test : internal::GetRegisteredTests()) {
  ------------------
  |  Branch (460:27): [True: 0, False: 0]
  ------------------
  461|      0|      const std::string test_name =
  462|      0|          absl::StrCat(test->test_suite_name(), ".", test->name());
  463|      0|      if (!fuzz_tests.contains(test_name)) {
  ------------------
  |  Branch (463:11): [True: 0, False: 0]
  ------------------
  464|      0|        non_fuzz_tests.push_back(test_name);
  465|      0|      }
  466|      0|    }
  467|      0|    if (!non_fuzz_tests.empty()) {
  ------------------
  |  Branch (467:9): [True: 0, False: 0]
  ------------------
  468|       |      // Run only the fuzz tests, and not the unit tests.
  469|       |      // TODO: b/340232436 -- This is needed because we currently rely on a fuzz
  470|       |      // test being the first test to run so that Centipede can get the
  471|       |      // serialized configuration from the binary.
  472|      0|      std::string filter = absl::StrCat(
  473|      0|          GTEST_FLAG_GET(filter),
  474|       |          // When the filter already includes the negative patterns, append to
  475|       |          // the negative patterns.
  476|      0|          absl::StrContains(GTEST_FLAG_GET(filter), '-') ? ":" : "-",
  ------------------
  |  Branch (476:11): [True: 0, False: 0]
  ------------------
  477|      0|          absl::StrJoin(non_fuzz_tests, ":"));
  478|      0|      GTEST_FLAG_SET(filter, filter);
  479|      0|    }
  480|      0|  }
  481|       |  // TODO(b/307513669): Use the Configuration class instead of Runtime.
  482|      2|  if (!absl::GetFlag(FUZZTEST_FLAG(unguided)) &&
  ------------------
  |  |   20|      2|#define FUZZTEST_FLAG(name) FLAGS_##name
  ------------------
  |  Branch (482:7): [True: 2, False: 0]
  ------------------
  483|      2|      fuzzing_time_limit.has_value()) {
  ------------------
  |  Branch (483:7): [True: 2, False: 0]
  ------------------
  484|      2|    runtime.SetRunMode(RunMode::kFuzz);
  485|      2|  } else {
  486|      0|    runtime.SetRunMode(RunMode::kUnitTest);
  487|      0|  }
  488|      2|}
_ZN8fuzztest14ParseAbslFlagsEiPPc:
  490|      2|void ParseAbslFlags(int argc, char** argv) {
  491|      2|  std::vector<char*> positional_args;
  492|      2|  std::vector<absl::UnrecognizedFlag> unrecognized_flags;
  493|      2|  absl::ParseAbseilFlagsOnly(argc, argv, positional_args, unrecognized_flags);
  494|      2|}
init_fuzztest.cc:_ZNK3$_0clEv:
   47|      2|    .OnUpdate([]() {
   48|      2|      fuzztest::internal::SetFuzzTestListingModeValidatorForGoogleTest(
   49|      2|          absl::GetFlag(FUZZTEST_FLAG(list_fuzz_tests)));
  ------------------
  |  |   20|      2|#define FUZZTEST_FLAG(name) FLAGS_##name
  ------------------
   50|      2|    });
init_fuzztest.cc:_ZNK3$_1clEv:
  216|      2|    .OnUpdate([] {
  217|      4|      FUZZTEST_PRECONDITION(
  ------------------
  |  |   32|      0|  ABSL_CHECK(cond) << "[Failed precondition] Incorrect usage: "
  |  |  ------------------
  |  |  |  |   41|      2|  ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition)
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  180|      2|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|      4|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|      4|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 2, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|      2|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 2]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|      6|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [True: 2, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 2, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [Folded, False: 2]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|      0|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   29|      2|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      2|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  218|      4|          !absl::GetFlag(FUZZTEST_FLAG(internal_override_fuzz_test))
  219|      4|               .has_value() ||
  220|      4|          std::getenv("CENTIPEDE_RUNNER_FLAGS") != nullptr)
  221|      4|          << "must not set --" FUZZTEST_FLAG_PREFIX
  222|      4|             "internal_override_fuzz_test directly";
  223|      2|    });
init_fuzztest.cc:_ZNK3$_2clEv:
  232|      2|    .OnUpdate([] {
  233|      4|      FUZZTEST_PRECONDITION(
  ------------------
  |  |   32|      0|  ABSL_CHECK(cond) << "[Failed precondition] Incorrect usage: "
  |  |  ------------------
  |  |  |  |   41|      2|  ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition)
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  180|      2|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|      4|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|      4|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 2, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|      2|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 2]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|      6|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [True: 2, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 2, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [Folded, False: 2]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|      0|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   29|      2|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      2|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  234|      4|          absl::GetFlag(FUZZTEST_FLAG(internal_override_total_time_limit)) ==
  235|      4|              absl::InfiniteDuration() ||
  236|      4|          std::getenv("CENTIPEDE_RUNNER_FLAGS") != nullptr)
  237|      4|          << "must not set --" FUZZTEST_FLAG_PREFIX
  238|      4|             "internal_override_total_time_limit directly";
  239|      2|    });
init_fuzztest.cc:_ZNK3$_3clEv:
  247|      2|    .OnUpdate([] {
  248|      4|      FUZZTEST_PRECONDITION(
  ------------------
  |  |   32|      0|  ABSL_CHECK(cond) << "[Failed precondition] Incorrect usage: "
  |  |  ------------------
  |  |  |  |   41|      2|  ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition)
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  180|      2|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|      4|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|      4|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 2, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|      2|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 2]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|      6|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [True: 2, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 2, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [Folded, False: 2]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|      0|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   29|      2|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      2|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  249|      4|          !absl::GetFlag(FUZZTEST_FLAG(internal_crashing_input_to_reproduce))
  250|      4|               .has_value() ||
  251|      4|          std::getenv("CENTIPEDE_RUNNER_FLAGS") != nullptr)
  252|      4|          << "must not set --" FUZZTEST_FLAG_PREFIX
  253|      4|             "internal_crashing_input_to_reproduce directly";
  254|      2|    });
init_fuzztest.cc:_ZN8fuzztest12_GLOBAL__N_129CreateConfigurationsFromFlagsENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  331|      2|    absl::string_view binary_identifier) {
  332|      2|  const bool reproduce_findings_as_separate_tests =
  333|      2|      absl::GetFlag(FUZZTEST_FLAG(reproduce_findings_as_separate_tests));
  ------------------
  |  |   20|      2|#define FUZZTEST_FLAG(name) FLAGS_##name
  ------------------
  334|      2|  const std::optional<absl::Duration> fuzzing_time_limit = GetFuzzingTime();
  335|      2|  const std::optional<absl::Duration> replay_corpus_time_limit =
  336|      2|      GetReplayCorpusTime();
  337|      2|  const std::optional<std::string> override_fuzz_test =
  338|      2|      absl::GetFlag(FUZZTEST_FLAG(internal_override_fuzz_test));
  ------------------
  |  |   20|      2|#define FUZZTEST_FLAG(name) FLAGS_##name
  ------------------
  339|      2|  const bool replay_coverage_inputs =
  340|      2|      fuzzing_time_limit.has_value() || replay_corpus_time_limit.has_value();
  ------------------
  |  Branch (340:7): [True: 2, False: 0]
  |  Branch (340:41): [True: 0, False: 0]
  ------------------
  341|      2|  const absl::Duration time_limit =
  342|      2|      override_fuzz_test.has_value()
  ------------------
  |  Branch (342:7): [True: 0, False: 2]
  ------------------
  343|      2|          ? absl::GetFlag(FUZZTEST_FLAG(internal_override_total_time_limit))
  ------------------
  |  |   20|      0|#define FUZZTEST_FLAG(name) FLAGS_##name
  ------------------
  344|      2|      : fuzzing_time_limit.has_value()       ? *fuzzing_time_limit
  ------------------
  |  Branch (344:9): [True: 2, False: 0]
  ------------------
  345|      2|      : replay_corpus_time_limit.has_value() ? *replay_corpus_time_limit
  ------------------
  |  Branch (345:9): [True: 0, False: 0]
  ------------------
  346|      0|                                             : absl::ZeroDuration();
  347|      2|  const internal::TimeBudgetType time_budget_type =
  348|      2|      override_fuzz_test.has_value()
  ------------------
  |  Branch (348:7): [True: 0, False: 2]
  ------------------
  349|      2|          ? internal::TimeBudgetType::kTotal
  350|      2|          : absl::GetFlag(FUZZTEST_FLAG(time_budget_type));
  ------------------
  |  |   20|      2|#define FUZZTEST_FLAG(name) FLAGS_##name
  ------------------
  351|      2|  const std::optional<size_t> jobs = absl::GetFlag(FUZZTEST_FLAG(jobs));
  ------------------
  |  |   20|      2|#define FUZZTEST_FLAG(name) FLAGS_##name
  ------------------
  352|      4|  FUZZTEST_CHECK(!jobs.has_value() || *jobs > 0)
  ------------------
  |  |   22|      0|#define FUZZTEST_CHECK(cond) ABSL_CHECK(cond)
  |  |  ------------------
  |  |  |  |   41|      2|  ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition)
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  180|      2|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|      4|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|      4|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 2, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|      2|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 2]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|      6|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [True: 2, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 2, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [Folded, False: 2]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|      0|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   29|      2|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      2|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  353|      4|      << "If specified, --" << FUZZTEST_FLAG(jobs).Name()
  ------------------
  |  |   20|      0|#define FUZZTEST_FLAG(name) FLAGS_##name
  ------------------
  354|      4|      << " must be positive.";
  355|      2|  std::string corpus_database = absl::GetFlag(FUZZTEST_FLAG(corpus_database));
  ------------------
  |  |   20|      2|#define FUZZTEST_FLAG(name) FLAGS_##name
  ------------------
  356|      2|  if (!corpus_database.empty() && corpus_database[0] != '/' &&
  ------------------
  |  Branch (356:7): [True: 2, False: 0]
  |  Branch (356:35): [True: 2, False: 0]
  ------------------
  357|      2|      std::getenv("TEST_SRCDIR")) {
  ------------------
  |  Branch (357:7): [True: 0, False: 2]
  ------------------
  358|      0|    corpus_database =
  359|      0|        absl::StrCat(std::getenv("TEST_SRCDIR"), "/", corpus_database);
  360|      0|  }
  361|      2|  return internal::Configuration{
  362|      2|      corpus_database,
  363|      2|      /*stats_root=*/"",
  364|      2|      /*workdir_root=*/"",
  365|      2|      std::string(binary_identifier),
  366|      2|      /*fuzz_tests=*/ListRegisteredTests(),
  367|      2|      /*fuzz_tests_in_current_shard=*/ListRegisteredTests(),
  368|       |      /*continue_after_crash=*/
  369|      2|      absl::GetFlag(FUZZTEST_FLAG(continue_after_crash)),
  ------------------
  |  |   20|      2|#define FUZZTEST_FLAG(name) FLAGS_##name
  ------------------
  370|      2|      reproduce_findings_as_separate_tests,
  371|      2|      replay_coverage_inputs,
  372|       |      /*only_replay=*/
  373|      2|      replay_corpus_time_limit.has_value(),
  374|      2|      /*replay_in_single_process=*/false,
  375|      2|      absl::GetFlag(FUZZTEST_FLAG(execution_id)),
  ------------------
  |  |   20|      2|#define FUZZTEST_FLAG(name) FLAGS_##name
  ------------------
  376|      2|      absl::GetFlag(FUZZTEST_FLAG(print_subprocess_log)),
  ------------------
  |  |   20|      2|#define FUZZTEST_FLAG(name) FLAGS_##name
  ------------------
  377|      2|      absl::GetFlag(FUZZTEST_FLAG(subprocess_cleanup_timeout)),
  ------------------
  |  |   20|      2|#define FUZZTEST_FLAG(name) FLAGS_##name
  ------------------
  378|      2|      /*stack_limit=*/absl::GetFlag(FUZZTEST_FLAG(stack_limit_kb)) * 1024,
  ------------------
  |  |   20|      2|#define FUZZTEST_FLAG(name) FLAGS_##name
  ------------------
  379|      2|      /*rss_limit=*/absl::GetFlag(FUZZTEST_FLAG(rss_limit_mb)) * 1024 * 1024,
  ------------------
  |  |   20|      2|#define FUZZTEST_FLAG(name) FLAGS_##name
  ------------------
  380|      2|      absl::GetFlag(FUZZTEST_FLAG(time_limit_per_input)),
  ------------------
  |  |   20|      2|#define FUZZTEST_FLAG(name) FLAGS_##name
  ------------------
  381|      2|      time_limit,
  382|      2|      time_budget_type,
  383|      2|      jobs.value_or(0),
  384|      2|      absl::GetFlag(FUZZTEST_FLAG(internal_centipede_command)),
  ------------------
  |  |   20|      2|#define FUZZTEST_FLAG(name) FLAGS_##name
  ------------------
  385|      2|      absl::GetFlag(FUZZTEST_FLAG(internal_crashing_input_to_reproduce)),
  ------------------
  |  |   20|      2|#define FUZZTEST_FLAG(name) FLAGS_##name
  ------------------
  386|      2|  };
  387|      2|}
init_fuzztest.cc:_ZN8fuzztest12_GLOBAL__N_114GetFuzzingTimeEv:
  304|      4|std::optional<absl::Duration> GetFuzzingTime() {
  305|      4|  absl::Duration fuzz_time_limit = absl::GetFlag(FUZZTEST_FLAG(fuzz_for));
  ------------------
  |  |   20|      4|#define FUZZTEST_FLAG(name) FLAGS_##name
  ------------------
  306|      4|  if (fuzz_time_limit <= absl::ZeroDuration()) {
  ------------------
  |  Branch (306:7): [True: 0, False: 4]
  ------------------
  307|      0|    fuzz_time_limit = absl::InfiniteDuration();
  308|      0|  }
  309|      4|  if (absl::GetFlag(FUZZTEST_FLAG(fuzz)) == kUnspecified &&
  ------------------
  |  |   20|      4|#define FUZZTEST_FLAG(name) FLAGS_##name
  ------------------
  |  Branch (309:7): [True: 0, False: 4]
  |  Branch (309:7): [True: 0, False: 4]
  ------------------
  310|      0|      fuzz_time_limit == absl::InfiniteDuration()) {
  ------------------
  |  Branch (310:7): [True: 0, False: 0]
  ------------------
  311|      0|    return std::nullopt;
  312|      0|  }
  313|      4|  return fuzz_time_limit;
  314|      4|}
init_fuzztest.cc:_ZN8fuzztest12_GLOBAL__N_119GetReplayCorpusTimeEv:
  316|      4|std::optional<absl::Duration> GetReplayCorpusTime() {
  317|      4|  absl::Duration replay_corpus_time_limit =
  318|      4|      absl::GetFlag(FUZZTEST_FLAG(replay_corpus_for));
  ------------------
  |  |   20|      4|#define FUZZTEST_FLAG(name) FLAGS_##name
  ------------------
  319|      4|  if (absl::GetFlag(FUZZTEST_FLAG(replay_corpus)) == kUnspecified &&
  ------------------
  |  |   20|      4|#define FUZZTEST_FLAG(name) FLAGS_##name
  ------------------
  |  Branch (319:7): [True: 4, False: 0]
  |  Branch (319:7): [True: 4, False: 0]
  ------------------
  320|      4|      replay_corpus_time_limit <= absl::ZeroDuration()) {
  ------------------
  |  Branch (320:7): [True: 4, False: 0]
  ------------------
  321|      4|    return std::nullopt;
  322|      4|  }
  323|      0|  if (absl::GetFlag(FUZZTEST_FLAG(replay_corpus)) != kUnspecified &&
  ------------------
  |  |   20|      0|#define FUZZTEST_FLAG(name) FLAGS_##name
  ------------------
  |  Branch (323:7): [True: 0, False: 0]
  |  Branch (323:7): [True: 0, False: 0]
  ------------------
  324|      0|      replay_corpus_time_limit <= absl::ZeroDuration()) {
  ------------------
  |  Branch (324:7): [True: 0, False: 0]
  ------------------
  325|      0|    replay_corpus_time_limit = absl::InfiniteDuration();
  326|      0|  }
  327|      0|  return replay_corpus_time_limit;
  328|      4|}
init_fuzztest.cc:_ZZN8fuzztest12InitFuzzTestEPiPPPcNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEENK3$_0clEv:
  421|      2|  const auto specified_test = []() -> std::optional<std::string> {
  422|      2|    if (auto internal_selected_test =
  423|      2|            absl::GetFlag(FUZZTEST_FLAG(internal_override_fuzz_test));
  ------------------
  |  |   20|      2|#define FUZZTEST_FLAG(name) FLAGS_##name
  ------------------
  424|      2|        internal_selected_test.has_value()) {
  ------------------
  |  Branch (424:9): [True: 0, False: 2]
  ------------------
  425|      0|      return internal_selected_test;
  426|      0|    }
  427|      2|    if (auto test_to_fuzz = absl::GetFlag(FUZZTEST_FLAG(fuzz));
  ------------------
  |  |   20|      2|#define FUZZTEST_FLAG(name) FLAGS_##name
  ------------------
  428|      2|        test_to_fuzz != kUnspecified) {
  ------------------
  |  Branch (428:9): [True: 2, False: 0]
  ------------------
  429|      2|      return test_to_fuzz;
  430|      2|    }
  431|      0|    if (auto test_to_replay_corpus =
  432|      0|            absl::GetFlag(FUZZTEST_FLAG(replay_corpus));
  ------------------
  |  |   20|      0|#define FUZZTEST_FLAG(name) FLAGS_##name
  ------------------
  433|      0|        test_to_replay_corpus != kUnspecified) {
  ------------------
  |  Branch (433:9): [True: 0, False: 0]
  ------------------
  434|      0|      return test_to_replay_corpus;
  435|      0|    }
  436|      0|    return std::nullopt;
  437|      0|  }();
init_fuzztest.cc:_ZZN8fuzztest19ListRegisteredTestsEvENK3$_0clINS_8internal8FuzzTestEEEDaRKT_:
  261|      6|      [&](const auto& test) { result.push_back(test.full_name()); });

_ZN8fuzztest8internal11CopyableAnyC2INSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEJSB_EEENS3_15in_place_type_tIT_EEDpOT0_:
  170|  1.13k|      : AnyBase(std::in_place, std::true_type{},
  171|  1.13k|                new T(std::forward<U>(args)...)) {}
_ZN8fuzztest8internal7AnyBaseC2INSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEENS3_10in_place_tENS3_17integral_constantIbLb1EEEPT_:
   35|  1.13k|  explicit AnyBase(std::in_place_t, std::true_type, T* value) {
   36|  1.13k|    static constexpr VTable kVTable = {type_id<T>, DestroyImpl<T>, CopyImpl<T>};
   37|  1.13k|    vtable_ = &kVTable;
   38|  1.13k|    value_ = const_cast<void*>(static_cast<const void*>(value));
   39|  1.13k|  }
_ZN8fuzztest8internal7AnyBase11DestroyImplINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEEvPv:
  123|  3.39k|  static void DestroyImpl(void* p) {
  124|  3.39k|    delete static_cast<T*>(p);
  125|  3.39k|  }
_ZN8fuzztest8internal7AnyBase8CopyImplINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEEPvSC_:
  128|  1.13k|  static void* CopyImpl(void* p) {
  129|  1.13k|    return new T(*static_cast<T*>(p));
  130|  1.13k|  }
_ZNR8fuzztest8internal7AnyBase5GetAsINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEERT_v:
   59|  1.13k|  T& GetAs() & {
   60|  2.26k|    FUZZTEST_PRECONDITION(has_value()) << "Object is empty!";
  ------------------
  |  |   32|      0|  ABSL_CHECK(cond) << "[Failed precondition] Incorrect usage: "
  |  |  ------------------
  |  |  |  |   41|  1.13k|  ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition)
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  180|  1.13k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|  2.26k|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|  2.26k|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 1.13k, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|  1.13k|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 1.13k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|  2.26k|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [True: 1.13k, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [Folded, False: 1.13k]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, False: 1.13k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|      0|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   29|  1.13k|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|  1.13k|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   61|  2.26k|    FUZZTEST_PRECONDITION(Has<T>()) << "Wrong type!";
  ------------------
  |  |   32|      0|  ABSL_CHECK(cond) << "[Failed precondition] Incorrect usage: "
  |  |  ------------------
  |  |  |  |   41|  1.13k|  ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition)
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  180|  1.13k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|  2.26k|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|  2.26k|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 1.13k, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|  1.13k|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 1.13k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|  2.26k|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [True: 1.13k, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [Folded, False: 1.13k]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, False: 1.13k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|      0|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   29|  1.13k|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|  1.13k|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   62|  1.13k|    return *static_cast<T*>(value_);
   63|  1.13k|  }
_ZNK8fuzztest8internal7AnyBase9has_valueEv:
   47|  14.7k|  bool has_value() const {
   48|  29.4k|    FUZZTEST_CHECK((vtable_ == nullptr) == (value_ == nullptr))
  ------------------
  |  |   22|      0|#define FUZZTEST_CHECK(cond) ABSL_CHECK(cond)
  |  |  ------------------
  |  |  |  |   41|  14.7k|  ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition)
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  180|  14.7k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|  29.4k|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|  29.4k|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 14.7k, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|  14.7k|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 14.7k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|  29.4k|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [True: 14.7k, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [Folded, False: 14.7k]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, False: 14.7k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|      0|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   29|  14.7k|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|  14.7k|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   49|  29.4k|        << "Inconsistent state between value and vtable.";
   50|  14.7k|    return value_ != nullptr;
   51|  14.7k|  }
_ZNK8fuzztest8internal7AnyBase3HasINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEEbv:
   54|  3.39k|  bool Has() const {
   55|  3.39k|    return has_value() && vtable_->type_id == type_id<T>;
  ------------------
  |  Branch (55:12): [True: 3.39k, False: 0]
  |  Branch (55:27): [True: 3.39k, False: 0]
  ------------------
   56|  3.39k|  }
_ZNKR8fuzztest8internal7AnyBase5GetAsINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEERKT_v:
   66|  2.26k|  const T& GetAs() const& {
   67|  4.53k|    FUZZTEST_PRECONDITION(has_value()) << "Object is empty!";
  ------------------
  |  |   32|      0|  ABSL_CHECK(cond) << "[Failed precondition] Incorrect usage: "
  |  |  ------------------
  |  |  |  |   41|  2.26k|  ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition)
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  180|  2.26k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|  4.53k|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|  4.53k|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 2.26k, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|  2.26k|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 2.26k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|  4.53k|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [True: 2.26k, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [Folded, False: 2.26k]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, False: 2.26k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|      0|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   29|  2.26k|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|  2.26k|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   68|  4.53k|    FUZZTEST_PRECONDITION(Has<T>()) << "Wrong type!";
  ------------------
  |  |   32|      0|  ABSL_CHECK(cond) << "[Failed precondition] Incorrect usage: "
  |  |  ------------------
  |  |  |  |   41|  2.26k|  ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition)
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  180|  2.26k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|  4.53k|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|  4.53k|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 2.26k, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|  2.26k|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 2.26k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|  4.53k|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [True: 2.26k, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [Folded, False: 2.26k]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, False: 2.26k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|      0|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   29|  2.26k|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|  2.26k|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   69|  2.26k|    return *static_cast<T*>(value_);
   70|  2.26k|  }
_ZN8fuzztest8internal11CopyableAnyC2EOS1_:
  175|  2.26k|  CopyableAny(CopyableAny&& other) = default;
_ZN8fuzztest8internal7AnyBaseC2EOS1_:
   90|  2.26k|      : vtable_(std::exchange(other.vtable_, nullptr)),
   91|  2.26k|        value_(std::exchange(other.value_, nullptr)) {}
_ZN8fuzztest8internal7AnyBaseD2Ev:
  101|  5.66k|  ~AnyBase() { Destroy(); }
_ZN8fuzztest8internal7AnyBase7DestroyEv:
  103|  5.66k|  void Destroy() {
  104|  5.66k|    if (has_value()) vtable_->destroy(value_);
  ------------------
  |  Branch (104:9): [True: 3.39k, False: 2.26k]
  ------------------
  105|  5.66k|  }
_ZN8fuzztest8internal11MoveOnlyAnyC2INSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEJSB_EEENS3_15in_place_type_tIT_EEDpOT0_:
  151|  1.13k|      : AnyBase(std::in_place, std::false_type{},
  152|  1.13k|                new T(std::forward<U>(args)...)) {}
_ZN8fuzztest8internal7AnyBaseC2INSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEENS3_10in_place_tENS3_17integral_constantIbLb0EEEPT_:
   41|  1.13k|  explicit AnyBase(std::in_place_t, std::false_type, T* value) {
   42|  1.13k|    static constexpr VTable kVTable = {type_id<T>, DestroyImpl<T>, nullptr};
   43|  1.13k|    vtable_ = &kVTable;
   44|  1.13k|    value_ = const_cast<void*>(static_cast<const void*>(value));
   45|  1.13k|  }
_ZN8fuzztest8internal11CopyableAnyC2ERKS1_:
  174|  1.13k|  CopyableAny(const CopyableAny& other) { CopyFrom(other); }
_ZN8fuzztest8internal7AnyBaseC2Ev:
   87|  1.13k|  AnyBase() : vtable_(nullptr), value_(nullptr) {}
_ZN8fuzztest8internal7AnyBase8CopyFromERKS1_:
  107|  1.13k|  void CopyFrom(const AnyBase& other) {
  108|  2.26k|    FUZZTEST_CHECK(!has_value()) << "CopyFrom called on a full object";
  ------------------
  |  |   22|      0|#define FUZZTEST_CHECK(cond) ABSL_CHECK(cond)
  |  |  ------------------
  |  |  |  |   41|  1.13k|  ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition)
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  180|  1.13k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|  2.26k|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|  2.26k|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 1.13k, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|  1.13k|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 1.13k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|  2.26k|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [True: 1.13k, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [Folded, False: 1.13k]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, False: 1.13k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|      0|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   29|  1.13k|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|  1.13k|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  109|  1.13k|    if (other.has_value()) {
  ------------------
  |  Branch (109:9): [True: 1.13k, False: 0]
  ------------------
  110|  1.13k|      vtable_ = other.vtable_;
  111|  1.13k|      value_ = vtable_->copy(other.value_);
  112|  1.13k|    }
  113|  1.13k|  }

_ZN8fuzztest8internal25SetExternalEngineCallbackEPNS0_22ExternalEngineCallbackE:
   33|      2|void SetExternalEngineCallback(ExternalEngineCallback* callback) {
   34|      2|  external_engine_callback = callback;
   35|      2|}
_ZN8fuzztest8internal25GetExternalEngineCallbackEv:
   37|  4.70k|ExternalEngineCallback* GetExternalEngineCallback() {
   38|  4.70k|  return external_engine_callback;
   39|  4.70k|}
_ZN8fuzztest8internal29FuzzTestExternalEngineAdaptorC2ERKNS0_8FuzzTestENSt3__110unique_ptrINS0_20UntypedFixtureDriverENS5_14default_deleteIS7_EEEE:
   65|      2|    : test_(test), fixture_driver_staging_(std::move(fixture_driver)) {}
_ZN8fuzztest8internal29FuzzTestExternalEngineAdaptor16RunInFuzzingModeEPiPPPcRKNS0_13ConfigurationE:
   73|      2|    int* argc, char*** argv, const Configuration& configuration) {
   74|      4|  FUZZTEST_CHECK(&LLVMFuzzerRunDriver) << "LibFuzzer Driver API not defined.";
  ------------------
  |  |   22|      0|#define FUZZTEST_CHECK(cond) ABSL_CHECK(cond)
  |  |  ------------------
  |  |  |  |   41|      2|  ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition)
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  180|      2|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|      4|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|      4|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 2, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|      2|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 2]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|      2|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [True: 2, Folded]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|      0|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   29|      2|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      2|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   75|      4|  FUZZTEST_CHECK(GetExternalEngineCallback() == nullptr)
  ------------------
  |  |   22|      0|#define FUZZTEST_CHECK(cond) ABSL_CHECK(cond)
  |  |  ------------------
  |  |  |  |   41|      2|  ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition)
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  180|      2|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|      4|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|      4|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 2, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|      2|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 2]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|      4|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [True: 2, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [Folded, False: 2]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, False: 2]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|      0|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   29|      2|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      2|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   76|      4|      << "External engine callback is already set while running a fuzz test.";
   77|      2|  SetExternalEngineCallback(this);
   78|      2|  runtime_.SetRunMode(RunMode::kFuzz);
   79|      2|  auto& impl = GetFuzzerImpl();
   80|      2|  runtime_.SetCurrentTest(&impl.test_, &configuration);
   81|      2|  runtime_.EnableReporter(&impl.stats_, [] { return absl::Now(); });
   82|       |
   83|      4|  FUZZTEST_CHECK(impl.fixture_driver_ != nullptr) << "Invalid fixture driver!";
  ------------------
  |  |   22|      0|#define FUZZTEST_CHECK(cond) ABSL_CHECK(cond)
  |  |  ------------------
  |  |  |  |   41|      2|  ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition)
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  180|      2|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|      4|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|      4|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 2, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|      2|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 2]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|      4|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [True: 2, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [Folded, False: 2]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, False: 2]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|      0|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   29|      2|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      2|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   84|      2|  impl.fixture_driver_->RunFuzzTest([&] {
   85|      2|    static bool driver_started = false;
   86|      2|    FUZZTEST_CHECK(!driver_started) << "Driver started more than once!";
   87|      2|    driver_started = true;
   88|      2|    LLVMFuzzerRunDriver(
   89|      2|        argc, argv, [](const uint8_t* data, size_t size) -> int {
   90|      2|          GetExternalEngineCallback()->RunOneInputData(
   91|      2|              absl::string_view(reinterpret_cast<const char*>(data), size));
   92|      2|          return 0;
   93|      2|        });
   94|      2|  });
   95|       |
   96|      2|  return true;
   97|      2|}
_ZN8fuzztest8internal29FuzzTestExternalEngineAdaptor15RunOneInputDataENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
  109|  4.70k|void FuzzTestExternalEngineAdaptor::RunOneInputData(absl::string_view data) {
  110|  4.70k|  auto& impl = GetFuzzerImpl();
  111|  4.70k|  if (impl.ShouldStop()) {
  ------------------
  |  Branch (111:7): [True: 0, False: 4.70k]
  ------------------
  112|      0|    runtime_.PrintFinalStatsOnDefaultSink();
  113|       |    // Use _Exit instead of exit so libFuzzer does not treat it as a crash.
  114|      0|    std::_Exit(0);
  115|      0|  }
  116|  4.70k|  if (data.size() == 0) return;
  ------------------
  |  Branch (116:7): [True: 0, False: 4.70k]
  ------------------
  117|  4.70k|  auto input = impl.TryParse(data);
  118|  4.70k|  if (!input.ok()) return;
  ------------------
  |  Branch (118:7): [True: 3.57k, False: 1.13k]
  ------------------
  119|  1.13k|  impl.RunOneInput({*std::move(input)});
  120|  1.13k|}
_ZN8fuzztest8internal29FuzzTestExternalEngineAdaptor13GetFuzzerImplEv:
  151|  4.70k|FuzzTestExternalEngineAdaptor::GetFuzzerImpl() {
  152|       |  // Postpone the creation to override libFuzzer signal setup.
  153|  4.70k|  if (!fuzzer_impl_) {
  ------------------
  |  Branch (153:7): [True: 2, False: 4.70k]
  ------------------
  154|      2|    fuzzer_impl_ =
  155|      2|        std::make_unique<FuzzerImpl>(test_, std::move(fixture_driver_staging_));
  156|      2|    fixture_driver_staging_ = nullptr;
  157|      2|  }
  158|  4.70k|  return *fuzzer_impl_;
  159|  4.70k|}
compatibility_mode.cc:_ZZN8fuzztest8internal29FuzzTestExternalEngineAdaptor16RunInFuzzingModeEPiPPPcRKNS0_13ConfigurationEENK3$_1clEv:
   81|  1.13k|  runtime_.EnableReporter(&impl.stats_, [] { return absl::Now(); });
compatibility_mode.cc:_ZZN8fuzztest8internal29FuzzTestExternalEngineAdaptor16RunInFuzzingModeEPiPPPcRKNS0_13ConfigurationEENK3$_0clEv:
   84|      2|  impl.fixture_driver_->RunFuzzTest([&] {
   85|      2|    static bool driver_started = false;
   86|      4|    FUZZTEST_CHECK(!driver_started) << "Driver started more than once!";
  ------------------
  |  |   22|      0|#define FUZZTEST_CHECK(cond) ABSL_CHECK(cond)
  |  |  ------------------
  |  |  |  |   41|      2|  ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition)
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  180|      2|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|      4|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|      4|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 2, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|      2|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 2]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|      4|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [True: 2, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [Folded, False: 2]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, False: 2]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|      0|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   29|      2|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      2|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   87|      2|    driver_started = true;
   88|      2|    LLVMFuzzerRunDriver(
   89|      2|        argc, argv, [](const uint8_t* data, size_t size) -> int {
   90|      2|          GetExternalEngineCallback()->RunOneInputData(
   91|      2|              absl::string_view(reinterpret_cast<const char*>(data), size));
   92|      2|          return 0;
   93|      2|        });
   94|      2|  });
compatibility_mode.cc:_ZZZN8fuzztest8internal29FuzzTestExternalEngineAdaptor16RunInFuzzingModeEPiPPPcRKNS0_13ConfigurationEENK3$_0clEvENKUlPKhmE_clESB_m:
   89|  4.70k|        argc, argv, [](const uint8_t* data, size_t size) -> int {
   90|  4.70k|          GetExternalEngineCallback()->RunOneInputData(
   91|  4.70k|              absl::string_view(reinterpret_cast<const char*>(data), size));
   92|  4.70k|          return 0;
   93|  4.70k|        });

_ZNK8fuzztest8internal13Configuration19GetTimeLimitPerTestEv:
  318|      2|absl::Duration Configuration::GetTimeLimitPerTest() const {
  319|      2|  switch (time_budget_type) {
  320|      2|    case TimeBudgetType::kPerTest:
  ------------------
  |  Branch (320:5): [True: 2, False: 0]
  ------------------
  321|      2|      return time_limit;
  322|      0|    case TimeBudgetType::kTotal:
  ------------------
  |  Branch (322:5): [True: 0, False: 2]
  ------------------
  323|      0|      return time_limit / fuzz_tests_in_current_shard.size();
  324|      0|    default:
  ------------------
  |  Branch (324:5): [True: 0, False: 2]
  ------------------
  325|      0|      return absl::InfiniteDuration();
  326|      2|  }
  327|      2|}

_ZN8fuzztest8internal20GetExecutionCoverageEv:
   91|      2|ExecutionCoverage* GetExecutionCoverage() {
   92|      2|  return execution_coverage_instance;
   93|      2|}
_ZN8fuzztest8internal14CorpusCoverageC2Em:
  279|      2|CorpusCoverage::CorpusCoverage(size_t map_size) {
  280|      2|  size_t alignment = alignof(Vector);
  281|       |  // Round up to a multiple of alignment.
  282|      2|  map_size += alignment - 1;
  283|      2|  map_size -= map_size % alignment;
  284|       |  // And allocate an extra step to make sure the alignment logic has the
  285|       |  // necessary space.
  286|      2|  map_size += alignment;
  287|      2|  corpus_map_size_ = map_size;
  288|       |#if defined(_WIN32)
  289|       |  corpus_map_ = static_cast<uint8_t*>(_aligned_malloc(map_size, alignment));
  290|       |#else
  291|      2|  corpus_map_ = static_cast<uint8_t*>(std::aligned_alloc(alignment, map_size));
  292|      2|#endif
  293|      2|  std::fill(corpus_map_, corpus_map_ + corpus_map_size_, 0);
  294|      2|}

_ZNK8fuzztest8internal15AggregateOfImplINSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplIS9_NS0_13ArbitraryImplIcvEEEEEE19ValidateCorpusValueERKSA_:
  173|  1.13k|  absl::Status ValidateCorpusValue(const corpus_type& corpus_value) const {
  174|  1.13k|    absl::Status result = absl::OkStatus();
  175|  1.13k|    ApplyIndex<sizeof...(Inner)>([&](auto... I) {
  176|  1.13k|      (
  177|  1.13k|          [&] {
  178|  1.13k|            if (!result.ok()) return;
  179|  1.13k|            const absl::Status s = std::get<I>(inner_).ValidateCorpusValue(
  180|  1.13k|                std::get<I>(corpus_value));
  181|  1.13k|            result = Prefix(s, "Invalid value in aggregate");
  182|  1.13k|          }(),
  183|  1.13k|          ...);
  184|  1.13k|    });
  185|  1.13k|    return result;
  186|  1.13k|  }
_ZZNK8fuzztest8internal15AggregateOfImplINSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplIS9_NS0_13ArbitraryImplIcvEEEEEE19ValidateCorpusValueERKSA_ENKUlDpT_E_clIJNS2_17integral_constantImLm0EEEEEEDaSK_:
  175|  1.13k|    ApplyIndex<sizeof...(Inner)>([&](auto... I) {
  176|  1.13k|      (
  177|  1.13k|          [&] {
  178|  1.13k|            if (!result.ok()) return;
  179|  1.13k|            const absl::Status s = std::get<I>(inner_).ValidateCorpusValue(
  180|  1.13k|                std::get<I>(corpus_value));
  181|  1.13k|            result = Prefix(s, "Invalid value in aggregate");
  182|  1.13k|          }(),
  183|  1.13k|          ...);
  184|  1.13k|    });
_ZZZNK8fuzztest8internal15AggregateOfImplINSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplIS9_NS0_13ArbitraryImplIcvEEEEEE19ValidateCorpusValueERKSA_ENKUlDpT_E_clIJNS2_17integral_constantImLm0EEEEEEDaSK_ENKUlvE_clEv:
  177|  1.13k|          [&] {
  178|  1.13k|            if (!result.ok()) return;
  ------------------
  |  Branch (178:17): [True: 0, False: 1.13k]
  ------------------
  179|  1.13k|            const absl::Status s = std::get<I>(inner_).ValidateCorpusValue(
  180|  1.13k|                std::get<I>(corpus_value));
  181|  1.13k|            result = Prefix(s, "Invalid value in aggregate");
  182|  1.13k|          }(),
_ZNK8fuzztest8internal15AggregateOfImplINSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplIS9_NS0_13ArbitraryImplIcvEEEEEE11ParseCorpusERKNS0_6no_adl8IRObjectE:
  157|  3.20k|  std::optional<corpus_type> ParseCorpus(const IRObject& obj) const {
  158|       |    if constexpr (has_custom_corpus_type) {
  159|       |      return ParseWithDomainTuple(inner_, obj);
  160|  3.20k|    } else {
  161|  3.20k|      return obj.ToCorpus<corpus_type>();
  162|  3.20k|    }
  163|  3.20k|  }
_ZNK8fuzztest8internal15AggregateOfImplINSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplIS9_NS0_13ArbitraryImplIcvEEEEEE8GetValueERKSA_:
  115|  1.13k|  value_type GetValue(const corpus_type& value) const {
  116|       |    if constexpr (has_custom_corpus_type) {
  117|       |      if constexpr (DetectBindableFieldCount<value_type>() ==
  118|       |                    DetectBraceInitCount<value_type>()) {
  119|       |        return ApplyIndex<sizeof...(Inner)>([&](auto... I) {
  120|       |          return T{std::get<I>(inner_).GetValue(std::get<I>(value))...};
  121|       |        });
  122|       |      } else {
  123|       |        // Right now the only other possibility is that the bindable field count
  124|       |        // is one less than the brace init field count. In that case, that extra
  125|       |        // field is used to initialize an empty base class. We'll need to update
  126|       |        // this if that ever changes.
  127|       |        return ApplyIndex<sizeof...(Inner)>([&](auto... I) {
  128|       |          return T{{}, std::get<I>(inner_).GetValue(std::get<I>(value))...};
  129|       |        });
  130|       |      }
  131|  1.13k|    } else {
  132|  1.13k|      return value;
  133|  1.13k|    }
  134|  1.13k|  }
_ZN8fuzztest8internal15AggregateOfImplINSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplIS9_NS0_13ArbitraryImplIcvEEEEEEC2ENS2_10in_place_tESF_:
   58|      2|      : inner_(std::move(inner)...) {}

_ZNK8fuzztest8internal13ArbitraryImplIcvE19ValidateCorpusValueERKc:
  209|  9.62M|  absl::Status ValidateCorpusValue(const value_type&) const {
  210|  9.62M|    return absl::OkStatus();  // Nothing to validate.
  211|  9.62M|  }

_ZNK8fuzztest8internal19ContainerOfImplBaseINS0_23SequenceContainerOfImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_13ArbitraryImplIcvEEEES9_SB_E19ValidateCorpusValueERKS9_:
  339|  1.13k|  absl::Status ValidateCorpusValue(const corpus_type& corpus_value) const {
  340|       |    // Check size.
  341|  1.13k|    if (corpus_value.size() < min_size()) {
  ------------------
  |  Branch (341:9): [True: 0, False: 1.13k]
  ------------------
  342|      0|      return absl::InvalidArgumentError(absl::StrCat(
  343|      0|          "Invalid size: ", corpus_value.size(), ". Min size: ", min_size()));
  344|      0|    }
  345|  1.13k|    if (validate_max_size() && corpus_value.size() > max_size()) {
  ------------------
  |  Branch (345:9): [True: 1.13k, False: 0]
  |  Branch (345:32): [True: 0, False: 1.13k]
  ------------------
  346|      0|      return absl::InvalidArgumentError(absl::StrCat(
  347|      0|          "Invalid size: ", corpus_value.size(), ". Max size: ", max_size()));
  348|      0|    }
  349|       |    // Check elements.
  350|  1.13k|    int i = 0;
  351|  9.62M|    for (const auto& elem : corpus_value) {
  ------------------
  |  Branch (351:27): [True: 9.62M, False: 1.13k]
  ------------------
  352|  9.62M|      const absl::Status s = inner_.ValidateCorpusValue(elem);
  353|  9.62M|      if (!s.ok()) {
  ------------------
  |  Branch (353:11): [True: 0, False: 9.62M]
  ------------------
  354|      0|        return Prefix(s,
  355|      0|                      absl::StrCat("Invalid value in container at index ", i));
  356|      0|      }
  357|  9.62M|      i++;
  358|  9.62M|    }
  359|  1.13k|    return absl::OkStatus();
  360|  1.13k|  }
_ZNK8fuzztest8internal19ContainerOfImplBaseINS0_23SequenceContainerOfImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_13ArbitraryImplIcvEEEES9_SB_E8min_sizeEv:
  394|  1.13k|  size_t min_size() const { return min_size_; }
_ZNK8fuzztest8internal19ContainerOfImplBaseINS0_23SequenceContainerOfImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_13ArbitraryImplIcvEEEES9_SB_E17validate_max_sizeEv:
  398|  1.13k|  bool validate_max_size() const { return validate_max_size_; }
_ZNK8fuzztest8internal19ContainerOfImplBaseINS0_23SequenceContainerOfImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_13ArbitraryImplIcvEEEES9_SB_E8max_sizeEv:
  395|  1.13k|  size_t max_size() const {
  396|  1.13k|    return max_size_.value_or(std::max(min_size_, kDefaultContainerMaxSize));
  397|  1.13k|  }
_ZN8fuzztest8internal19ContainerOfImplBaseINS0_23SequenceContainerOfImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_13ArbitraryImplIcvEEEES9_SB_E4SelfEv:
  401|      2|  Derived& Self() { return static_cast<Derived&>(*this); }
_ZN8fuzztest8internal27SequenceContainerOfImplBaseINS0_23SequenceContainerOfImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_13ArbitraryImplIcvEEEES9_SB_EC2Ev:
  572|      2|  SequenceContainerOfImplBase() = default;
_ZN8fuzztest8internal19ContainerOfImplBaseINS0_23SequenceContainerOfImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_13ArbitraryImplIcvEEEES9_SB_EC2Ev:
  110|      2|  ContainerOfImplBase() = default;
_ZN8fuzztest8internal19ContainerOfImplBaseINS0_23SequenceContainerOfImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_13ArbitraryImplIcvEEEES9_SB_E11WithMaxSizeEm:
  236|      2|  Derived& WithMaxSize(size_t s) {
  237|      4|    FUZZTEST_PRECONDITION(min_size_ <= s)
  ------------------
  |  |   32|      0|  ABSL_CHECK(cond) << "[Failed precondition] Incorrect usage: "
  |  |  ------------------
  |  |  |  |   41|      2|  ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition)
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  180|      2|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|      4|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|      4|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 2, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|      2|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 2]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|      4|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [True: 2, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [Folded, False: 2]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, False: 2]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|      0|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   29|      2|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      2|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  238|      4|        << "Maximal size " << s << " cannot be smaller than minimal size "
  239|      4|        << min_size_;
  240|      2|    max_size_ = s;
  241|      2|    validate_max_size_ = true;
  242|      2|    return Self();
  243|      2|  }

_ZN8fuzztest6DomainINSt3__15tupleIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEEEC2INS_8internal15AggregateOfImplIS9_LNSC_23RequireCustomCorpusTypeE0EJNSC_23SequenceContainerOfImplIS8_NSC_13ArbitraryImplIcvEEEEEEES9_EEONS_18domain_implementor10DomainBaseIT_S9_T0_EE:
  112|      2|      : inner_(std::make_unique<internal::DomainModel<Inner>>(
  113|      2|            static_cast<Inner&&>(inner))) {}
_ZN8fuzztest6DomainINSt3__15tupleIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEEEC2ERKSA_:
  115|     12|  Domain(const Domain& other) { *this = other; }
_ZN8fuzztest6DomainINSt3__15tupleIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEEEaSERKSA_:
  116|     12|  Domain& operator=(const Domain& other) {
  117|     12|    inner_ = other.inner_->TypedClone();
  118|     12|    return *this;
  119|     12|  }
_ZN8fuzztest13UntypedDomainC2INSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEERKNS_6DomainIT_EE:
  332|      2|      : inner_(domain.inner_->UntypedClone()) {}
_ZNK8fuzztest13UntypedDomain8GetValueERKNS_8internal11CopyableAnyE:
  347|  1.13k|  value_type GetValue(const corpus_type& corpus_value) const {
  348|  1.13k|    return inner_->UntypedGetValue(corpus_value);
  349|  1.13k|  }
_ZNK8fuzztest13UntypedDomain11ParseCorpusERKNS_8internal6no_adl8IRObjectE:
  351|  3.20k|  std::optional<corpus_type> ParseCorpus(const internal::IRObject& obj) const {
  352|  3.20k|    return inner_->UntypedParseCorpus(obj);
  353|  3.20k|  }
_ZNK8fuzztest13UntypedDomain19ValidateCorpusValueERKNS_8internal11CopyableAnyE:
  359|  1.13k|  absl::Status ValidateCorpusValue(const corpus_type& corpus_value) const {
  360|  1.13k|    return inner_->UntypedValidateCorpusValue(corpus_value);
  361|  1.13k|  }

_ZN8fuzztest18domain_implementor10DomainBaseINS_8internal15AggregateOfImplINSt3__15tupleIJNS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEELNS2_23RequireCustomCorpusTypeE0EJNS2_23SequenceContainerOfImplISB_NS2_13ArbitraryImplIcvEEEEEEESC_SC_EC2Ev:
  111|      2|  DomainBase() {
  112|       |    // Check that the interface of `Derived` matches the requirements for a
  113|       |    // domain implementation. We check these inside the constructor of
  114|       |    // `DomainBase`, where `Derived` is already fully defined. If we try to
  115|       |    // check them at class scope we would see an incomplete `Derived` class and
  116|       |    // the checks would not work.
  117|      2|    fuzztest::internal::CheckIsSame<
  118|      2|        ValueType, fuzztest::internal::value_type_t<Derived>>();
  119|      2|    fuzztest::internal::CheckIsSame<
  120|      2|        CorpusType, fuzztest::internal::corpus_type_t<Derived>>();
  121|      2|    static_assert(has_custom_corpus_type == Derived::has_custom_corpus_type);
  122|       |
  123|       |    // Check that `Derived` type-checks against the type-erased `Domain<T>`
  124|       |    // interface by forcing the `DomainModel` template specialization.
  125|      2|    if (Derived* domain = nullptr) {
  ------------------
  |  Branch (125:18): [True: 0, False: 2]
  ------------------
  126|      0|      (void)fuzztest::internal::DomainModel<Derived>{*domain};
  127|      0|    }
  128|      2|  }
_ZN8fuzztest18domain_implementor10DomainBaseINS_8internal23SequenceContainerOfImplINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS2_13ArbitraryImplIcvEEEESA_SA_EC2Ev:
  111|      2|  DomainBase() {
  112|       |    // Check that the interface of `Derived` matches the requirements for a
  113|       |    // domain implementation. We check these inside the constructor of
  114|       |    // `DomainBase`, where `Derived` is already fully defined. If we try to
  115|       |    // check them at class scope we would see an incomplete `Derived` class and
  116|       |    // the checks would not work.
  117|      2|    fuzztest::internal::CheckIsSame<
  118|      2|        ValueType, fuzztest::internal::value_type_t<Derived>>();
  119|      2|    fuzztest::internal::CheckIsSame<
  120|      2|        CorpusType, fuzztest::internal::corpus_type_t<Derived>>();
  121|      2|    static_assert(has_custom_corpus_type == Derived::has_custom_corpus_type);
  122|       |
  123|       |    // Check that `Derived` type-checks against the type-erased `Domain<T>`
  124|       |    // interface by forcing the `DomainModel` template specialization.
  125|      2|    if (Derived* domain = nullptr) {
  ------------------
  |  Branch (125:18): [True: 0, False: 2]
  ------------------
  126|      0|      (void)fuzztest::internal::DomainModel<Derived>{*domain};
  127|      0|    }
  128|      2|  }
_ZN8fuzztest18domain_implementor10DomainBaseINS_8internal13ArbitraryImplIcvEEccEC2Ev:
  111|      2|  DomainBase() {
  112|       |    // Check that the interface of `Derived` matches the requirements for a
  113|       |    // domain implementation. We check these inside the constructor of
  114|       |    // `DomainBase`, where `Derived` is already fully defined. If we try to
  115|       |    // check them at class scope we would see an incomplete `Derived` class and
  116|       |    // the checks would not work.
  117|      2|    fuzztest::internal::CheckIsSame<
  118|      2|        ValueType, fuzztest::internal::value_type_t<Derived>>();
  119|      2|    fuzztest::internal::CheckIsSame<
  120|      2|        CorpusType, fuzztest::internal::corpus_type_t<Derived>>();
  121|      2|    static_assert(has_custom_corpus_type == Derived::has_custom_corpus_type);
  122|       |
  123|       |    // Check that `Derived` type-checks against the type-erased `Domain<T>`
  124|       |    // interface by forcing the `DomainModel` template specialization.
  125|      2|    if (Derived* domain = nullptr) {
  ------------------
  |  Branch (125:18): [True: 0, False: 2]
  ------------------
  126|      0|      (void)fuzztest::internal::DomainModel<Derived>{*domain};
  127|      0|    }
  128|      2|  }

_ZN8fuzztest8internal11DomainModelINS0_15AggregateOfImplINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplISA_NS0_13ArbitraryImplIcvEEEEEEEEC2EOSH_:
  132|      2|  explicit DomainModel(D&& domain) : domain_(std::forward<D>(domain)) {}
_ZN8fuzztest8internal20UntypedDomainConceptD2Ev:
   57|     10|  virtual ~UntypedDomainConcept() = default;
_ZNK8fuzztest8internal18TypedDomainConceptINSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEE12UntypedCloneEv:
  110|      2|  std::unique_ptr<UntypedDomainConcept> UntypedClone() const final {
  111|      2|    return TypedClone();
  112|      2|  }
_ZNK8fuzztest8internal11DomainModelINS0_15AggregateOfImplINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplISA_NS0_13ArbitraryImplIcvEEEEEEEE18UntypedParseCorpusERKNS0_6no_adl8IRObjectE:
  180|  3.20k|      const IRObject& obj) const final {
  181|  3.20k|    if (auto res = domain_.ParseCorpus(obj)) {
  ------------------
  |  Branch (181:14): [True: 1.13k, False: 2.07k]
  ------------------
  182|  1.13k|      return GenericDomainCorpusType(std::in_place_type<CorpusType>,
  183|  1.13k|                                     *std::move(res));
  184|  2.07k|    } else {
  185|  2.07k|      return std::nullopt;
  186|  2.07k|    }
  187|  3.20k|  }
_ZNK8fuzztest8internal11DomainModelINS0_15AggregateOfImplINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplISA_NS0_13ArbitraryImplIcvEEEEEEEE26UntypedValidateCorpusValueERKNS0_11CopyableAnyE:
  195|  1.13k|      const GenericDomainCorpusType& corpus_value) const final {
  196|  1.13k|    return domain_.ValidateCorpusValue(corpus_value.GetAs<CorpusType>());
  197|  1.13k|  }
_ZNK8fuzztest8internal18TypedDomainConceptINSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEE15UntypedGetValueERKNS0_11CopyableAnyE:
  115|  1.13k|      const GenericDomainCorpusType& v) const final {
  116|  1.13k|    return GenericDomainValueType(std::in_place_type<ValueType>,
  117|  1.13k|                                  TypedGetValue(v));
  118|  1.13k|  }
_ZNK8fuzztest8internal11DomainModelINS0_15AggregateOfImplINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplISA_NS0_13ArbitraryImplIcvEEEEEEEE10TypedCloneEv:
  134|     14|  std::unique_ptr<TypedDomainConcept<ValueType>> TypedClone() const final {
  135|     14|    return std::make_unique<DomainModel>(*this);
  136|     14|  }
_ZNK8fuzztest8internal11DomainModelINS0_15AggregateOfImplINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplISA_NS0_13ArbitraryImplIcvEEEEEEEE13TypedGetValueERKNS0_11CopyableAnyE:
  159|  1.13k|  ValueType TypedGetValue(const GenericDomainCorpusType& v) const final {
  160|  1.13k|    return domain_.GetValue(v.GetAs<CorpusType>());
  161|  1.13k|  }

_ZN8fuzztest8internal20UntypedFixtureDriver11RunFuzzTestEN4absl12lts_2026052612AnyInvocableIFvvOEEE:
   24|      2|void UntypedFixtureDriver::RunFuzzTest(absl::AnyInvocable<void() &&> run_test) {
   25|      2|  std::move(run_test)();
   26|      2|}
_ZN8fuzztest8internal20UntypedFixtureDriver20RunFuzzTestIterationEN4absl12lts_2026052612AnyInvocableIFvvOEEE:
   28|  1.13k|    absl::AnyInvocable<void() &&> run_iteration) {
   29|  1.13k|  std::move(run_iteration)();
   30|  1.13k|}

_ZN8fuzztest8internal13FixtureDriverINS_6DomainINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEENS0_9NoFixtureEPFvNS3_17basic_string_viewIcS7_EEEPvEC2ESH_SC_NS3_6vectorINS0_11CopyableAnyENS8_ISL_EEEERKSI_:
  317|      2|      : FixtureDriver::TypedFixtureDriver(std::move(domain), std::move(seeds),
  318|      2|                                          seed_provider),
  319|      2|        target_function_(target_function) {}
_ZN8fuzztest8internal18TypedFixtureDriverINSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEPvEC2ENS_6DomainISA_EENS2_6vectorINS0_11CopyableAnyENS7_ISG_EEEERKSB_:
  135|      2|      : domain_(std::move(domain)),
  136|      2|        seeds_(std::move(seeds)),
  137|      2|        seed_provider_(seed_provider) {}
_ZNK8fuzztest8internal13FixtureDriverINS_6DomainINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEENS0_9NoFixtureEPFvNS3_17basic_string_viewIcS7_EEEPvE4TestEONS0_11MoveOnlyAnyE:
  321|  1.13k|  void Test(MoveOnlyAny&& args_untyped) const override {
  322|  1.13k|    std::apply(
  323|  1.13k|        [&](auto&&... args) {
  324|  1.13k|          target_function_(ForceVectorForStringView<Args>(std::move(args))...);
  325|  1.13k|        },
  326|  1.13k|        args_untyped.GetAs<value_type_t<DomainT>>());
  327|  1.13k|  }
_ZZNK8fuzztest8internal13FixtureDriverINS_6DomainINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEENS0_9NoFixtureEPFvNS3_17basic_string_viewIcS7_EEEPvE4TestEONS0_11MoveOnlyAnyEENKUlDpOT_E_clIJRSA_EEEDaSO_:
  323|  1.13k|        [&](auto&&... args) {
  324|  1.13k|          target_function_(ForceVectorForStringView<Args>(std::move(args))...);
  325|  1.13k|        },
_ZN8fuzztest8internal24ForceVectorForStringViewINSt3__117basic_string_viewIcNS2_11char_traitsIcEEEENS2_12basic_stringIcS5_NS2_9allocatorIcEEEEEEDcOT0_:
  212|  1.13k|decltype(auto) ForceVectorForStringView(Src&& src) {
  213|       |  // We only do this when Src is a std::string. If it's a string view it is
  214|       |  // handled by the string view domain itself.
  215|       |  if constexpr (std::is_same_v<void(std::decay_t<Dest>, std::decay_t<Src>),
  216|  1.13k|                               void(std::string_view, std::string)>) {
  217|  1.13k|    return ForceVector{std::vector<char>(src.begin(), src.end())};
  218|       |  } else {
  219|       |    return std::forward<Src>(src);
  220|       |  }
  221|  1.13k|}
_ZNK8fuzztest8internal11ForceVectorcvNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEEv:
  207|  1.13k|  operator std::string_view() const { return {value.data(), value.size()}; }
_ZNK8fuzztest8internal18TypedFixtureDriverINSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEPvE10GetDomainsEv:
  151|      2|  UntypedDomain GetDomains() const final { return domain_; }

_ZNK8fuzztest8internal17GTest_TestAdaptor26GetFuzzTestsInCurrentShardEv:
   28|      2|std::vector<std::string> GTest_TestAdaptor::GetFuzzTestsInCurrentShard() const {
   29|      2|  std::vector<std::string> result;
   30|      2|  for (const auto* test : GetRegisteredTests()) {
  ------------------
  |  Branch (30:25): [True: 2, False: 2]
  ------------------
   31|      2|    if (!test->should_run()) continue;
  ------------------
  |  Branch (31:9): [True: 0, False: 2]
  ------------------
   32|      2|    if (test->is_in_another_shard()) continue;
  ------------------
  |  Branch (32:9): [True: 0, False: 2]
  ------------------
   33|      2|    for (const auto& fuzztest : configuration_.fuzz_tests) {
  ------------------
  |  Branch (33:31): [True: 2, False: 0]
  ------------------
   34|      2|      if (fuzztest ==
  ------------------
  |  Branch (34:11): [True: 2, False: 0]
  ------------------
   35|      2|          absl::StrCat(test->test_suite_name(), ".", test->name())) {
   36|      2|        result.push_back(fuzztest);
   37|      2|        break;
   38|      2|      }
   39|      2|    }
   40|      2|  }
   41|      2|  return result;
   42|      2|}
_ZN8fuzztest8internal30RegisterFuzzTestsAsGoogleTestsEPiPPPcRKNS0_13ConfigurationE:
  105|      2|                                    const Configuration& configuration) {
  106|      2|  ::fuzztest::internal::ForEachTest([&](auto& test) {
  107|      2|    if (test.uses_fixture()) {
  108|      2|      RegisterTests<::fuzztest::internal::GTest_TestAdaptor>(argc, argv, test,
  109|      2|                                                             configuration);
  110|      2|    } else {
  111|      2|      RegisterTests<::testing::Test>(argc, argv, test, configuration);
  112|      2|    }
  113|      2|  });
  114|       |
  115|      2|  ::testing::UnitTest::GetInstance()->listeners().Append(
  116|      2|      new ::fuzztest::internal::GTest_EventListener<
  117|      2|          ::testing::EmptyTestEventListener, ::testing::TestPartResult>());
  118|      2|}
_ZN8fuzztest8internal28FuzzTestListingModeValidator26RegisterGoogleTestListenerEv:
  174|      2|void FuzzTestListingModeValidator::RegisterGoogleTestListener() {
  175|      2|  testing::UnitTest::GetInstance()->listeners().Append(
  176|      2|      new ValidatorProxyListener(this));
  177|      2|}
_ZN8fuzztest8internal44SetFuzzTestListingModeValidatorForGoogleTestEb:
  179|      2|void SetFuzzTestListingModeValidatorForGoogleTest(bool listing_mode) {
  180|      2|  FuzzTestListingModeValidator::GetInstance().set_listing_mode(listing_mode);
  181|      2|}
_ZN8fuzztest8internal18GetRegisteredTestsEv:
  183|      2|std::vector<const testing::TestInfo*> GetRegisteredTests() {
  184|      2|  std::vector<const testing::TestInfo*> result;
  185|      2|  auto& unit_test = *testing::UnitTest::GetInstance();
  186|       |  // TODO(b/416466508): Remove this call once the bug is fixed. This function is
  187|       |  // internal to GoogleTest.
  188|      2|  unit_test.parameterized_test_registry().RegisterTests();
  189|      4|  for (int i = 0; i < unit_test.total_test_suite_count(); ++i) {
  ------------------
  |  Branch (189:19): [True: 2, False: 2]
  ------------------
  190|      4|    for (int j = 0; j < unit_test.GetTestSuite(i)->total_test_count(); ++j) {
  ------------------
  |  Branch (190:21): [True: 2, False: 2]
  ------------------
  191|      2|      result.push_back(unit_test.GetTestSuite(i)->GetTestInfo(j));
  192|      2|    }
  193|      2|  }
  194|      2|  return result;
  195|      2|}
_ZN8fuzztest8internal22ValidatorProxyListenerC2EPNS0_28FuzzTestListingModeValidatorE:
  169|      2|      : validator_(validator) {}
_ZN8fuzztest8internal22ValidatorProxyListener18OnTestProgramStartERKN7testing8UnitTestE:
  161|      2|  void OnTestProgramStart(const testing::UnitTest& unit_test) override {
  162|      2|    validator_->Run();
  163|      2|  }
_ZN8fuzztest8internal28FuzzTestListingModeValidator3RunEv:
  124|      2|  void Run() {
  125|      2|    if (listing_mode_) {
  ------------------
  |  Branch (125:9): [True: 0, False: 2]
  ------------------
  126|       |      // Since InitFuzzTest calls std::exit after listing the fuzz tests, we
  127|       |      // would not reach here if InitFuzzTest is called before.
  128|       |      absl::FPrintF(stderr,
  129|      0|                    "[!] --" FUZZTEST_FLAG_PREFIX
  130|      0|                    "list_fuzz_tests not handled by InitFuzzTest - fuzz tests "
  131|      0|                    "would not be listed even if defined.\n");
  132|      0|      std::exit(0);
  133|      0|    }
  134|      2|  }
_ZN8fuzztest8internal28FuzzTestListingModeValidator11GetInstanceEv:
  138|      2|  static FuzzTestListingModeValidator& GetInstance() {
  139|      2|    static auto* instance = [] {
  140|      2|      static_assert(
  141|      2|          std::is_trivially_destructible_v<FuzzTestListingModeValidator>);
  142|      2|      static FuzzTestListingModeValidator instance;
  143|      2|      instance.RegisterGoogleTestListener();
  144|      2|      return &instance;
  145|      2|    }();
  146|      2|    return *instance;
  147|      2|  }
_ZZN8fuzztest8internal28FuzzTestListingModeValidator11GetInstanceEvENKUlvE_clEv:
  139|      2|    static auto* instance = [] {
  140|      2|      static_assert(
  141|      2|          std::is_trivially_destructible_v<FuzzTestListingModeValidator>);
  142|      2|      static FuzzTestListingModeValidator instance;
  143|      2|      instance.RegisterGoogleTestListener();
  144|      2|      return &instance;
  145|      2|    }();
_ZN8fuzztest8internal28FuzzTestListingModeValidator16set_listing_modeEb:
  136|      2|  void set_listing_mode(bool listing_mode) { listing_mode_ = listing_mode; }
googletest_adaptor.cc:_ZZN8fuzztest8internal30RegisterFuzzTestsAsGoogleTestsEPiPPPcRKNS0_13ConfigurationEENK3$_0clINS0_8FuzzTestEEEDaRT_:
  106|      2|  ::fuzztest::internal::ForEachTest([&](auto& test) {
  107|      2|    if (test.uses_fixture()) {
  ------------------
  |  Branch (107:9): [True: 0, False: 2]
  ------------------
  108|      0|      RegisterTests<::fuzztest::internal::GTest_TestAdaptor>(argc, argv, test,
  109|      0|                                                             configuration);
  110|      2|    } else {
  111|      2|      RegisterTests<::testing::Test>(argc, argv, test, configuration);
  112|      2|    }
  113|      2|  });
googletest_adaptor.cc:_ZN8fuzztest8internal12_GLOBAL__N_113RegisterTestsIN7testing4TestEEEvPiPPPcRNS0_8FuzzTestERKNS0_13ConfigurationE:
   96|      2|                   const Configuration& configuration) {
   97|      2|  RegisterFuzzTestAsGTest<T>(argc, argv, test, configuration);
   98|      2|  RegisterSeparateRegressionTestForEachCrashingInput<T>(argc, argv, test,
   99|      2|                                                        configuration);
  100|      2|}
googletest_adaptor.cc:_ZN8fuzztest8internal12_GLOBAL__N_123RegisterFuzzTestAsGTestIN7testing4TestEEEvPiPPPcRNS0_8FuzzTestERKNS0_13ConfigurationENSt3__117basic_string_viewIcNSE_11char_traitsIcEEEE:
   48|      2|                             absl::string_view crashing_input_path = "") {
   49|      2|  auto fixture_factory = [argc, argv, &test,
   50|      2|                          configuration = configuration]() mutable -> T* {
   51|      2|    return new ::fuzztest::internal::GTest_TestAdaptor(
   52|      2|        test, argc, argv, std::move(configuration));
   53|      2|  };
   54|      2|  if (crashing_input_path.empty()) {
  ------------------
  |  Branch (54:7): [True: 2, False: 0]
  ------------------
   55|      2|    ::testing::RegisterTest(test.suite_name().c_str(), test.test_name().c_str(),
   56|      2|                            nullptr, nullptr, test.file().c_str(), test.line(),
   57|      2|                            std::move(fixture_factory));
   58|      2|    return;
   59|      2|  }
   60|      0|  const absl::StatusOr<std::string> regression_test_name =
   61|      0|      RegressionTestNameForCrashingInput(test.test_name(), crashing_input_path);
   62|      0|  if (!regression_test_name.ok()) {
  ------------------
  |  Branch (62:7): [True: 0, False: 0]
  ------------------
   63|      0|    FUZZTEST_LOG(WARNING)
  ------------------
  |  |   36|      0|#define FUZZTEST_LOG(severity) ABSL_LOG(severity)
  |  |  ------------------
  |  |  |  |   38|      0|#define ABSL_LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  174|      0|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|      0|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|      0|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|      0|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|      0|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|      0|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   60|      0|  ::absl::log_internal::LogMessage(   \
  |  |  |  |  |  |  |  |   61|      0|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::WarningTag{})
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   64|      0|        << "Failed to get regression test name for crashing input "
   65|      0|        << crashing_input_path << ". Not registering a regression test for it. "
   66|      0|        << "Status: " << regression_test_name.status();
   67|      0|    return;
   68|      0|  }
   69|      0|  ::testing::RegisterTest(
   70|      0|      test.suite_name().c_str(), regression_test_name->c_str(), nullptr,
   71|      0|      nullptr, test.file().c_str(), test.line(), std::move(fixture_factory));
   72|      0|}
googletest_adaptor.cc:_ZZN8fuzztest8internal12_GLOBAL__N_123RegisterFuzzTestAsGTestIN7testing4TestEEEvPiPPPcRNS0_8FuzzTestERKNS0_13ConfigurationENSt3__117basic_string_viewIcNSE_11char_traitsIcEEEEENUlvE_clEv:
   50|      2|                          configuration = configuration]() mutable -> T* {
   51|      2|    return new ::fuzztest::internal::GTest_TestAdaptor(
   52|      2|        test, argc, argv, std::move(configuration));
   53|      2|  };
googletest_adaptor.cc:_ZN8fuzztest8internal12_GLOBAL__N_150RegisterSeparateRegressionTestForEachCrashingInputIN7testing4TestEEEvPiPPPcRNS0_8FuzzTestERKNS0_13ConfigurationE:
   77|      2|    const Configuration& configuration) {
   78|      2|  if (!configuration.reproduce_findings_as_separate_tests) return;
  ------------------
  |  Branch (78:7): [True: 2, False: 0]
  ------------------
   79|       |#ifdef FUZZTEST_USE_CENTIPEDE
   80|       |  const std::vector<std::string> crash_inputs =
   81|       |      ListCrashIdsUsingCentipede(configuration, test.full_name());
   82|       |#else
   83|      0|  CorpusDatabase corpus_database(configuration);
   84|      0|  const std::vector<std::string> crash_inputs =
   85|      0|      corpus_database.GetCrashingInputsIfAny(test.full_name());
   86|      0|#endif
   87|      0|  for (const std::string& input : crash_inputs) {
  ------------------
  |  Branch (87:33): [True: 0, False: 0]
  ------------------
   88|      0|    Configuration updated_configuration = configuration;
   89|      0|    updated_configuration.crashing_input_to_reproduce = input;
   90|      0|    RegisterFuzzTestAsGTest<T>(argc, argv, test, updated_configuration, input);
   91|      0|  }
   92|      0|}

_ZN8fuzztest8internal17GTest_TestAdaptorC2ERNS0_8FuzzTestEPiPPPcNS0_13ConfigurationE:
   35|      2|      : test_(test),
   36|      2|        argc_(argc),
   37|      2|        argv_(argv),
   38|      2|        configuration_(std::move(configuration)) {}
_ZN8fuzztest8internal17GTest_TestAdaptor8TestBodyEv:
   40|      2|  void TestBody() override {
   41|      2|    RecordProperty("fuzz_test", "true");
   42|      2|    auto test = test_.make();
   43|      2|    configuration_.fuzz_tests_in_current_shard = GetFuzzTestsInCurrentShard();
   44|       |    // We replay a reproducer in the same process to help debugging when
   45|       |    // (1) we're replaying a single reproducer and (2) we're running locally.
   46|      2|    const bool running_locally =
   47|      2|        !std::getenv("FUZZTEST_RUNNING_UNDER_CI");
   48|      2|    configuration_.replay_in_single_process =
   49|      2|        configuration_.crashing_input_to_reproduce.has_value() &&
  ------------------
  |  Branch (49:9): [True: 0, False: 2]
  ------------------
   50|      0|        testing::UnitTest::GetInstance()->test_to_run_count() == 1 &&
  ------------------
  |  Branch (50:9): [True: 0, False: 0]
  ------------------
   51|      0|        running_locally;
  ------------------
  |  Branch (51:9): [True: 0, False: 0]
  ------------------
   52|      2|    if (Runtime::instance().run_mode() == RunMode::kUnitTest) {
  ------------------
  |  Branch (52:9): [True: 0, False: 2]
  ------------------
   53|       |      // In "bug reproduction" mode, sometimes we need to reproduce multiple
   54|       |      // bugs, i.e., run multiple tests that lead to a crash.
   55|      0|#if defined(GTEST_HAS_DEATH_TEST) && !defined(FUZZTEST_USE_CENTIPEDE)
   56|      0|      const bool needs_subprocess =
   57|      0|          configuration_.crashing_input_to_reproduce.has_value() &&
  ------------------
  |  Branch (57:11): [True: 0, False: 0]
  ------------------
   58|      0|          (!configuration_.replay_in_single_process ||
  ------------------
  |  Branch (58:12): [True: 0, False: 0]
  ------------------
   59|       |           // EXPECT_EXIT is required in the death-test subprocess, but in
   60|       |           // the subprocess there's only one test to run.
   61|      0|           testing::internal::InDeathTestChild());
  ------------------
  |  Branch (61:12): [True: 0, False: 0]
  ------------------
   62|       |#else
   63|       |      const bool needs_subprocess = false;
   64|       |#endif
   65|      0|      if (needs_subprocess) {
  ------------------
  |  Branch (65:11): [True: 0, False: 0]
  ------------------
   66|      0|        configuration_.preprocess_crash_reproducing = [] {
   67|       |          // EXPECT_EXIT disables event forwarding in gtest and as a result,
   68|       |          // EXPECT/ASSERT-s are disabled. Here, we overwrite this option.
   69|      0|          testing::UnitTest::GetInstance()->listeners().SuppressEventForwarding(
   70|      0|              false);
   71|      0|        };
   72|       |        // `RunInUnitTestMode` is supposed to fail and we wish to show the
   73|       |        // failure to the user. Directly running the test would terminate the
   74|       |        // process and using `EXPECT_DEATH` causes the test to pass. We use
   75|       |        // `EXPECT_EXIT` so that the test exit unsuccessfully, meaning that the
   76|       |        // test below fails without terminating the process.
   77|      0|#ifdef GTEST_HAS_DEATH_TEST
   78|      0|        EXPECT_EXIT(
  ------------------
  |  Branch (78:9): [True: 0, False: 0]
  |  Branch (78:9): [True: 0, False: 0]
  |  Branch (78:9): [True: 0, False: 0]
  |  Branch (78:9): [True: 0, False: 0]
  |  Branch (78:9): [True: 0, False: 0]
  |  Branch (78:9): [True: 0, False: 0]
  |  Branch (78:9): [True: 0, False: 0]
  |  Branch (78:9): [True: 0, False: 0]
  |  Branch (78:9): [True: 0, False: 0]
  |  Branch (78:9): [True: 0, False: 0]
  ------------------
   79|      0|            (test->RunInUnitTestMode(configuration_),
   80|      0|             void(
   81|      0|                 R"( FuzzTest failure! Please see 'actual message' below for the crash report. )"),
   82|      0|             std::exit(0)),
   83|      0|            ::testing::ExitedWithCode(0), "");
   84|       |#else
   85|       |        EXPECT_TRUE(false) << "Death test is not supported.";
   86|       |#endif
   87|      0|      } else {
   88|      0|        EXPECT_TRUE(test->RunInUnitTestMode(configuration_))
  ------------------
  |  Branch (88:9): [True: 0, False: 0]
  |  Branch (88:9): [True: 0, False: 0]
  |  Branch (88:9): [True: 0, False: 0]
  ------------------
   89|      0|            << "Failure(s) found in the unit-test mode - please see the test "
   90|      0|               "log for more details.";
   91|      0|      }
   92|      2|    } else {
   93|       |      // TODO(b/245753736): Consider using `tolerate_failure` when FuzzTest can
   94|       |      // tolerate crashes in fuzzing mode.
   95|      6|      EXPECT_TRUE(test->RunInFuzzingMode(argc_, argv_, configuration_))
  ------------------
  |  Branch (95:7): [True: 0, False: 2]
  |  Branch (95:7): [True: 0, False: 2]
  |  Branch (95:7): [True: 2, False: 0]
  ------------------
   96|      6|          << "Failure(s) found in the fuzzing mode - please see the test log "
   97|      6|             "for more details.";
   98|      2|    }
   99|      2|  }

_ZN8fuzztest8internal8BasenameENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  184|      2|absl::string_view Basename(absl::string_view filename) {
  185|      2|  auto last_slash_pos = filename.find_last_of("/\\");
  186|       |
  187|      2|  return last_slash_pos == absl::string_view::npos
  ------------------
  |  Branch (187:10): [True: 0, False: 2]
  ------------------
  188|      2|             ? filename
  189|      2|             : filename.substr(last_slash_pos + 1);
  190|      2|}

_ZN8fuzztest8internal14GetStderrFdDupEv:
   79|      2|int GetStderrFdDup() {
   80|       |  static int fd = DupLocally(STDERR_FILENO);
   81|      2|  return fd;
   82|      2|}
_ZN8fuzztest8internal9GetStderrEv:
   84|      2|FILE* GetStderr() {
   85|      2|  absl::MutexLock lock(stderr_file_guard_);
   86|      2|  if (!stderr_file_) {
  ------------------
  |  Branch (86:7): [True: 2, False: 0]
  ------------------
   87|       |    stderr_file_ = stderr;
   88|      2|  }
   89|      2|  return stderr_file_;
   90|      2|}
logging.cc:_ZN8fuzztest8internal12_GLOBAL__N_110DupLocallyEi:
   45|      4|int DupLocally(int fd) {
   46|      4|  int dup_fd = dup(fd);
   47|       |  // Error conditions below are extremely unlikely, so we don't spend too much
   48|       |  // effort in handling/logging them.
   49|      4|  if (dup_fd == -1) {
  ------------------
  |  Branch (49:7): [True: 0, False: 4]
  ------------------
   50|      0|    constexpr char msg[] = "[!] dup() failed in DupLocally(), returning -1\n";
   51|      0|    (void)write(STDERR_FILENO, msg, sizeof(msg) - 1);
   52|      0|    return -1;
   53|      0|  }
   54|      4|  int flags = fcntl(dup_fd, F_GETFD);
   55|      4|  if (flags == -1) {
  ------------------
  |  Branch (55:7): [True: 0, False: 4]
  ------------------
   56|      0|    constexpr char msg[] =
   57|      0|        "[!] fcntl(F_GETFD) failed in DupLocally(), ignoring the "
   58|      0|        "error..\n";
   59|      0|    (void)write(STDERR_FILENO, msg, sizeof(msg) - 1);
   60|      0|    return dup_fd;
   61|      0|  }
   62|      4|  flags |= FD_CLOEXEC;
   63|      4|  if (fcntl(dup_fd, F_SETFD, flags) == -1) {
  ------------------
  |  Branch (63:7): [True: 0, False: 4]
  ------------------
   64|      0|    constexpr char msg[] =
   65|      0|        "[!] fcntl(F_SETFD) failed in DupLocally(), ignoring the "
   66|      0|        "error..\n";
   67|       |    (void)write(STDERR_FILENO, msg, sizeof(msg) - 1);
   68|      0|  }
   69|      4|  return dup_fd;
   70|      4|}
logging.cc:_ZN8fuzztest8internal12_GLOBAL__N_114GetStdoutFdDupEv:
   94|      2|int GetStdoutFdDup() {
   95|       |  static int fd = DupLocally(STDOUT_FILENO);
   96|      2|  return fd;
   97|      2|}

_ZN8fuzztest8internal10ApplyIndexILm1EZNKS0_15AggregateOfImplINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplISA_NS0_13ArbitraryImplIcvEEEEEE19ValidateCorpusValueERKSB_EUlDpT_E_EEDaT0_:
   54|  1.13k|constexpr auto ApplyIndex(F f) {
   55|  1.13k|  return ApplyIndexImpl(f, std::make_index_sequence<N>{});
   56|  1.13k|}
_ZN8fuzztest8internal14ApplyIndexImplIJLm0EEZNKS0_15AggregateOfImplINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplISA_NS0_13ArbitraryImplIcvEEEEEE19ValidateCorpusValueERKSB_EUlDpT_E_EEDaT0_NS3_16integer_sequenceImJXspT_EEEE:
   39|  1.13k|constexpr auto ApplyIndexImpl(F f, std::index_sequence<I...>) {
   40|  1.13k|  return f(std::integral_constant<size_t, I>{}...);
   41|  1.13k|}
_ZN8fuzztest8internal10ApplyIndexILm1EZNKS0_6no_adl8IRObject8ToCorpusINSt3__15tupleIJNS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEEEEEENS5_8optionalIT_EEvEUlDpT_E_EEDaT0_:
   54|  1.15k|constexpr auto ApplyIndex(F f) {
   55|  1.15k|  return ApplyIndexImpl(f, std::make_index_sequence<N>{});
   56|  1.15k|}
_ZN8fuzztest8internal14ApplyIndexImplIJLm0EEZNKS0_6no_adl8IRObject8ToCorpusINSt3__15tupleIJNS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEEEEEENS5_8optionalIT_EEvEUlDpT_E_EEDaT0_NS5_16integer_sequenceImJXspT_EEEE:
   39|  1.15k|constexpr auto ApplyIndexImpl(F f, std::index_sequence<I...>) {
   40|  1.15k|  return f(std::integral_constant<size_t, I>{}...);
   41|  1.15k|}
_ZN8fuzztest8internal11CheckIsSameINSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEESA_EEvv:
  839|      4|constexpr void CheckIsSame() {
  840|      4|  static_assert(std::is_same_v<T, U>);
  841|      4|}
_ZN8fuzztest8internal11CheckIsSameINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEES8_EEvv:
  839|      4|constexpr void CheckIsSame() {
  840|      4|  static_assert(std::is_same_v<T, U>);
  841|      4|}
_ZN8fuzztest8internal11CheckIsSameIccEEvv:
  839|      4|constexpr void CheckIsSame() {
  840|      4|  static_assert(std::is_same_v<T, U>);
  841|      4|}

_ZN8fuzztest15GetRegistrationIPFvNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEEEEDaNS1_12basic_stringIcS4_NS1_9allocatorIcEEEESB_SB_iT_:
  338|      2|                     TargetFunction target_function) {
  339|      2|  return ::fuzztest::internal::Registration<::fuzztest::internal::NoFixture,
  340|      2|                                            TargetFunction>(
  341|      2|      ::fuzztest::internal::BasicTestInfo{std::move(suite_name),
  342|      2|                                          std::move(test_name), std::move(file),
  343|      2|                                          line, false},
  344|      2|      target_function);
  345|      2|}
_ZN8fuzztest8internal12RegistrationINS0_9NoFixtureEPFvNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEENS0_23DefaultRegistrationBaseIJS7_EEEPvEC2ENS0_13BasicTestInfoES9_:
  134|      2|      : test_info_(std::move(info)), target_function_(target_function) {}
_ZNO8fuzztest8internal12RegistrationINS0_9NoFixtureEPFvNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEENS0_23DefaultRegistrationBaseIJS7_EEEPvE11WithDomainsIJRNS0_23SequenceContainerOfImplINS3_12basic_stringIcS6_NS3_9allocatorIcEEEENS0_13ArbitraryImplIcvEEEEEEEDaDpOT_:
  172|      2|  auto WithDomains(NewDomains&&... domains) && {
  173|      2|    return std::move(*this).WithDomains(
  174|      2|        TupleOf(std::forward<NewDomains>(domains)...));
  175|      2|  }
_ZNO8fuzztest8internal12RegistrationINS0_9NoFixtureEPFvNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEENS0_23DefaultRegistrationBaseIJS7_EEEPvE11WithDomainsIJNS0_23SequenceContainerOfImplINS3_12basic_stringIcS6_NS3_9allocatorIcEEEENS0_13ArbitraryImplIcvEEEEEEEDaNS0_15AggregateOfImplINS3_5tupleIJDpNT_10value_typeEEEELNS0_23RequireCustomCorpusTypeE0EJDpSP_EEE:
  149|      2|                       domain) && {
  150|      2|    static_assert(!Registration::kHasDomain,
  151|      2|                  "WithDomains can only be called once.");
  152|      2|    static_assert(!Registration::kHasSeeds,
  153|      2|                  "WithDomains can not be called after WithSeeds.");
  154|      2|    static_assert(!Registration::kHasSeedProvider,
  155|      2|                  "WithDomains can not be called after WithSeedProvider.");
  156|      2|    static_assert(
  157|      2|        Base::kNumArgs == sizeof...(NewDomains),
  158|      2|        "Number of domains specified in .WithDomains() does not match "
  159|      2|        "the number of function parameters.");
  160|      2|    using NewBase = RegistrationWithDomainsBase<value_type_t<NewDomains>...>;
  161|      2|    return Registration<Fixture, TargetFunction, NewBase, SeedProvider>(
  162|      2|        std::move(test_info_), target_function_, NewBase{std::move(domain)});
  163|      2|  }
_ZN8fuzztest8internal12RegistrationINS0_9NoFixtureEPFvNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEENS0_27RegistrationWithDomainsBaseIJNS3_12basic_stringIcS6_NS3_9allocatorIcEEEEEEEPvEC2ENS0_13BasicTestInfoES9_SF_:
  293|      2|      : Base(std::move(base)),
  294|      2|        test_info_(std::move(info)),
  295|      2|        target_function_(target_function) {}
_ZNK8fuzztest8internal27RegistrationWithDomainsBaseIJNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE10GetDomainsEv:
   95|      2|  const auto& GetDomains() const { return domains_; }
_ZNK8fuzztest8internal12RegistrationINS0_9NoFixtureEPFvNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEENS0_27RegistrationWithDomainsBaseIJNS3_12basic_stringIcS6_NS3_9allocatorIcEEEEEEEPvE5seedsEv:
  271|      2|  std::vector<GenericDomainCorpusType> seeds() const {
  272|       |    if constexpr (Base::kHasSeeds) {
  273|       |      return this->seeds_;
  274|      2|    } else {
  275|      2|      return {};
  276|      2|    }
  277|      2|  }
_ZN8fuzztest8internal12RegistrationINS0_9NoFixtureEPFvNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEENS0_27RegistrationWithDomainsBaseIJNS3_12basic_stringIcS6_NS3_9allocatorIcEEEEEEEPvE13seed_providerEv:
  279|      2|  SeedProvider seed_provider() {
  280|       |    if constexpr (Base::kHasSeedProvider) {
  281|       |      return std::move(this->seed_provider_);
  282|      2|    } else {
  283|      2|      return {};
  284|      2|    }
  285|      2|  }

_ZN8fuzztest8internal11ForEachTestEN4absl12lts_2026052611FunctionRefIFvRNS0_8FuzzTestEEEE:
   56|      8|void ForEachTest(absl::FunctionRef<void(FuzzTest&)> func) {
   57|      8|  for (auto& t : Regs()) func(t);
  ------------------
  |  Branch (57:16): [True: 8, False: 8]
  ------------------
   58|      8|}
_ZN8fuzztest8internal12RegisterImplENS0_13BasicTestInfoEN4absl12lts_2026052612AnyInvocableIKFNSt3__110unique_ptrINS0_14FuzzTestFuzzerENS5_14default_deleteIS7_EEEERKNS0_8FuzzTestEEEE:
   60|      2|void RegisterImpl(BasicTestInfo test_info, FuzzTestFuzzerFactory factory) {
   61|      2|  Regs().emplace_back(std::move(test_info), std::move(factory));
   62|      2|}
registry.cc:_ZN8fuzztest8internal12_GLOBAL__N_14RegsEv:
   30|     10|auto& Regs() {
   31|       |  // We use a deque because FuzzTest is not copyable/movable.
   32|     10|  static auto* reg = new std::deque<FuzzTest>;
   33|     10|  return *reg;
   34|     10|}

_ZN8fuzztest8internal17RegistrationTokenaSINS0_27RegistrationWithDomainsBaseIJNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEENS0_9NoFixtureEPFvNS4_17basic_string_viewIcS7_EEEPvEERS1_ONS0_12RegistrationIT0_T1_T_T2_EE:
   57|      2|      Registration<Fixture, TargetFunction, RegBase, SeedProvider>&& reg) {
   58|       |    if constexpr (std::is_base_of_v<FixtureWithExplicitSetUp, Fixture>) {
   59|       |      RegisterSetUpTearDownTestSuiteFunctions(reg.test_info_.suite_name,
   60|       |                                              &Fixture::SetUpTestSuite,
   61|       |                                              &Fixture::TearDownTestSuite);
   62|       |    }
   63|      2|    BasicTestInfo test_info = reg.test_info_;
   64|      2|    RegisterImpl(std::move(test_info),
   65|      2|                 GetFuzzTestFuzzerFactory(std::move(reg)));
   66|      2|    return *this;
   67|      2|  }
_ZN8fuzztest8internal17RegistrationToken24GetFuzzTestFuzzerFactoryINS0_27RegistrationWithDomainsBaseIJNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEENS0_9NoFixtureEPFvNS4_17basic_string_viewIcS7_EEEPvEEN4absl12lts_2026052612AnyInvocableIKFNS4_10unique_ptrINS0_14FuzzTestFuzzerENS4_14default_deleteISM_EEEERKNS0_8FuzzTestEEEEONS0_12RegistrationIT0_T1_T_T2_EE:
   72|      2|      Registration<Fixture, TargetFunction, RegBase, SeedProvider>&& reg) {
   73|       |#if defined(FUZZTEST_COMPATIBILITY_MODE) && defined(FUZZTEST_USE_CENTIPEDE)
   74|       |#error FuzzTest compatibility mode cannot work together with Centipede.
   75|       |#endif
   76|      2|#if defined(FUZZTEST_COMPATIBILITY_MODE)
   77|      2|    using FuzzerImpl = FuzzTestExternalEngineAdaptor;
   78|       |#elif defined(FUZZTEST_USE_CENTIPEDE)
   79|       |    using FuzzerImpl = CentipedeFuzzerAdaptor;
   80|       |#else
   81|       |    using FuzzerImpl = FuzzTestFuzzerImpl;
   82|       |#endif
   83|       |
   84|      2|    return [target_function = reg.target_function_, domain = reg.GetDomains(),
   85|      2|            seeds = reg.seeds(), seed_provider = reg.seed_provider()](
   86|      2|               const FuzzTest& test) -> std::unique_ptr<FuzzTestFuzzer> {
   87|      2|      return std::make_unique<FuzzerImpl>(
   88|      2|          test,
   89|      2|          std::make_unique<FixtureDriverImpl<decltype(domain), Fixture,
   90|      2|                                             TargetFunction, SeedProvider>>(
   91|      2|              target_function, domain, seeds, seed_provider));
   92|      2|    };
   93|      2|  }
_ZZN8fuzztest8internal17RegistrationToken24GetFuzzTestFuzzerFactoryINS0_27RegistrationWithDomainsBaseIJNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEENS0_9NoFixtureEPFvNS4_17basic_string_viewIcS7_EEEPvEEN4absl12lts_2026052612AnyInvocableIKFNS4_10unique_ptrINS0_14FuzzTestFuzzerENS4_14default_deleteISM_EEEERKNS0_8FuzzTestEEEEONS0_12RegistrationIT0_T1_T_T2_EEENKUlSS_E_clESS_:
   86|      2|               const FuzzTest& test) -> std::unique_ptr<FuzzTestFuzzer> {
   87|      2|      return std::make_unique<FuzzerImpl>(
   88|      2|          test,
   89|      2|          std::make_unique<FixtureDriverImpl<decltype(domain), Fixture,
   90|      2|                                             TargetFunction, SeedProvider>>(
   91|      2|              target_function, domain, seeds, seed_provider));
   92|      2|    };

_ZN8fuzztest8internal7RuntimeC2Ev:
  247|      2|Runtime::Runtime() {
  248|      2|  if (const char* crash_metadata_path =
  249|      2|          std::getenv("FUZZTEST_CRASH_METADATA_PATH");
  250|      2|      crash_metadata_path != nullptr) {
  ------------------
  |  Branch (250:7): [True: 0, False: 2]
  ------------------
  251|      0|    RegisterCrashMetadataListener(
  252|      0|        [=](absl::string_view crash_type,
  253|      0|            absl::Span<const std::string> /*stack_frames*/) {
  254|      0|          WriteFile(crash_metadata_path, crash_type);
  255|      0|        });
  256|      0|  }
  257|      2|}
_ZN8fuzztest8internal7Runtime8Spinlock4LockEv:
  434|  3.39k|void Runtime::Spinlock::Lock() {
  435|  3.39k|  while (locked_.test_and_set(std::memory_order_acq_rel)) {
  ------------------
  |  Branch (435:10): [True: 0, False: 3.39k]
  ------------------
  436|      0|    std::this_thread::yield();
  437|      0|  }
  438|  3.39k|}
_ZN8fuzztest8internal7Runtime8Spinlock6UnlockEv:
  440|  3.39k|void Runtime::Spinlock::Unlock() { locked_.clear(std::memory_order_release); }
_ZN8fuzztest8internal7Runtime19CheckWatchdogLimitsEv:
  453|  1.13k|void Runtime::CheckWatchdogLimits() {
  454|       |  // Centipede runner has its own watchdog.
  455|  1.13k|#ifndef FUZZTEST_USE_CENTIPEDE
  456|  1.13k|  watchdog_spinlock_.Lock();
  457|  1.13k|  if (current_configuration_ == nullptr || !test_iteration_started_ ||
  ------------------
  |  Branch (457:7): [True: 0, False: 1.13k]
  |  Branch (457:44): [True: 0, False: 1.13k]
  ------------------
  458|  1.13k|      watchdog_limit_exceeded_) {
  ------------------
  |  Branch (458:7): [True: 0, False: 1.13k]
  ------------------
  459|      0|    watchdog_spinlock_.Unlock();
  460|      0|    return;
  461|      0|  }
  462|  1.13k|  const absl::Duration run_duration =
  463|  1.13k|      clock_fn_() - current_iteration_start_time_;
  464|  1.13k|  if (current_configuration_->time_limit_per_input > absl::ZeroDuration() &&
  ------------------
  |  Branch (464:7): [True: 1.13k, False: 0]
  ------------------
  465|  1.13k|      run_duration > current_configuration_->time_limit_per_input) {
  ------------------
  |  Branch (465:7): [True: 0, False: 1.13k]
  ------------------
  466|      0|    absl::FPrintF(
  467|      0|        GetStderr(), "[!] Per-input timeout exceeded: %s > %s - aborting\n",
  468|      0|        absl::FormatDuration(run_duration),
  469|      0|        absl::FormatDuration(current_configuration_->time_limit_per_input));
  470|      0|    watchdog_limit_exceeded_ = true;
  471|      0|    watchdog_spinlock_.Unlock();
  472|      0|    std::abort();
  473|      0|  }
  474|  1.13k|  const size_t rss_usage = GetPeakRSSBytes();
  475|  1.13k|  if (current_configuration_->rss_limit > 0 &&
  ------------------
  |  Branch (475:7): [True: 0, False: 1.13k]
  ------------------
  476|      0|      rss_usage > current_configuration_->rss_limit) {
  ------------------
  |  Branch (476:7): [True: 0, False: 0]
  ------------------
  477|      0|    absl::FPrintF(GetStderr(),
  478|      0|                  "[!] RSS limit exceeded: %zu > %zu (bytes) - aborting\n",
  479|      0|                  rss_usage, current_configuration_->rss_limit);
  480|      0|    watchdog_limit_exceeded_ = true;
  481|      0|    watchdog_spinlock_.Unlock();
  482|      0|    std::abort();
  483|      0|  }
  484|  1.13k|  watchdog_spinlock_.Unlock();
  485|  1.13k|#endif  // FUZZTEST_USE_CENTIPEDE
  486|  1.13k|}
_ZN8fuzztest8internal7Runtime14SetCurrentTestEPKNS0_8FuzzTestEPKNS0_13ConfigurationE:
  489|      2|                             const Configuration* configuration) {
  490|      2|  FUZZTEST_CHECK((test != nullptr) == (configuration != nullptr));
  ------------------
  |  |   22|      2|#define FUZZTEST_CHECK(cond) ABSL_CHECK(cond)
  |  |  ------------------
  |  |  |  |   41|      2|  ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition)
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      4|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  180|      2|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|      4|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|      4|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 2, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|      2|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 2]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|      4|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [True: 2, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [Folded, False: 2]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, False: 2]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|      4|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   29|      4|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  491|      2|  current_test_ = test;
  492|      2|  current_configuration_ = configuration;
  493|      2|  if (configuration == nullptr) return;
  ------------------
  |  Branch (493:7): [True: 0, False: 2]
  ------------------
  494|      2|  if (const auto test_time_limit = configuration->GetTimeLimitPerTest();
  495|      2|      test_time_limit < absl::InfiniteDuration()) {
  ------------------
  |  Branch (495:7): [True: 0, False: 2]
  ------------------
  496|      0|    const absl::Status has_enough_time =
  497|      0|        fuzztest::internal::VerifyBazelHasEnoughTimeToRunTest(
  498|      0|            creation_time_, test_time_limit, test_counter_,
  499|      0|            configuration->fuzz_tests.size());
  500|      0|    FUZZTEST_PRECONDITION(has_enough_time.ok())
  ------------------
  |  |   32|      0|  ABSL_CHECK(cond) << "[Failed precondition] Incorrect usage: "
  |  |  ------------------
  |  |  |  |   41|      0|  ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition)
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  180|      0|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|      0|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|      0|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|      0|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|      0|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|      0|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   29|      0|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  501|      0|        << "Not enough time for running the fuzz test " << test->full_name()
  502|      0|        << " for " << test_time_limit << ": " << has_enough_time;
  503|      0|  }
  504|      2|  ++test_counter_;
  505|      2|}
_ZN8fuzztest8internal7Runtime20OnTestIterationStartERKN4absl12lts_202605264TimeE:
  507|  1.13k|void Runtime::OnTestIterationStart(const absl::Time& start_time) {
  508|  1.13k|  watchdog_spinlock_.Lock();
  509|  1.13k|  current_iteration_start_time_ = start_time;
  510|  1.13k|  test_iteration_started_ = true;
  511|  1.13k|  watchdog_spinlock_.Unlock();
  512|  1.13k|}
_ZN8fuzztest8internal7Runtime18OnTestIterationEndEv:
  514|  1.13k|void Runtime::OnTestIterationEnd() {
  515|  1.13k|  CheckWatchdogLimits();
  516|  1.13k|  watchdog_spinlock_.Lock();
  517|  1.13k|  test_iteration_started_ = false;
  518|  1.13k|  watchdog_spinlock_.Unlock();
  519|  1.13k|}
_ZN8fuzztest8internal21InstallSignalHandlersEP8_IO_FILE:
  632|      2|void InstallSignalHandlers(FILE* out) {
  633|      2|  if (signal_out != nullptr) {
  ------------------
  |  Branch (633:7): [True: 0, False: 2]
  ------------------
  634|       |    // Already installed. Noop.
  635|      0|    return;
  636|      0|  }
  637|      2|  signal_out = out;
  638|       |
  639|       |#if defined(FUZZTEST_HAS_SANITIZER)
  640|       |  // An ASan failure might come without a signal.
  641|       |  // Eg a divide by zero is intercepted by ASan and it terminates the process
  642|       |  // after printing its output. This handler helps us print our output
  643|       |  // afterwards.
  644|       |  __sanitizer_set_death_callback(
  645|       |      [](auto...) { Runtime::instance().PrintReport(&signal_out_sink); });
  646|       |#endif
  647|       |
  648|     12|  for (OldSignalHandler& h : crash_handlers) {
  ------------------
  |  Branch (648:28): [True: 12, False: 2]
  ------------------
  649|     12|    SetNewSigAction(h.signum, &HandleCrash, &h.action);
  650|     12|  }
  651|       |
  652|      6|  for (OldSignalHandler& h : termination_handlers) {
  ------------------
  |  Branch (652:28): [True: 6, False: 2]
  ------------------
  653|      6|    SetNewSigAction(h.signum, &HandleTermination, nullptr);
  654|      6|  }
  655|      2|}
_ZN8fuzztest8internal28InstallUnexpectedExitHandlerEv:
  674|      2|void InstallUnexpectedExitHandler() {
  675|       |#ifndef FUZZTEST_COMPATIBILITY_MODE
  676|       |  // In compatibility mode we don't install the handler because libFuzzer
  677|       |  // always explicitly exits, so every run would finish with an unexpected
  678|       |  // exit.
  679|       |  // https://github.com/llvm/llvm-project/blob/fa511cde48ea218dadfa8b35658ac06368f34607/compiler-rt/lib/fuzzer/FuzzerDriver.cpp#L930
  680|       |  [[maybe_unused]] const bool installed = [] {
  681|       |    std::atexit([] { Runtime::instance().HandleUnexpectedExit(); });
  682|       |    return true;
  683|       |  }();
  684|       |#endif
  685|      2|}
_ZN8fuzztest8internal18FuzzTestFuzzerImplC2ERKNS0_8FuzzTestENSt3__110unique_ptrINS0_20UntypedFixtureDriverENS5_14default_deleteIS7_EEEE:
  697|      2|    : test_(test),
  698|      2|      fixture_driver_(std::move(fixture_driver)),
  699|      2|      params_domain_(fixture_driver_->GetDomains()),
  700|      2|      execution_coverage_(internal::GetExecutionCoverage()),
  701|      2|      corpus_coverage_(execution_coverage_ != nullptr
  ------------------
  |  Branch (701:24): [True: 0, False: 2]
  ------------------
  702|      2|                           ? execution_coverage_->GetCounterMap().size()
  703|      2|                           : 0) {
  704|      4|  FUZZTEST_PRECONDITION(fixture_driver_ != nullptr)
  ------------------
  |  |   32|      0|  ABSL_CHECK(cond) << "[Failed precondition] Incorrect usage: "
  |  |  ------------------
  |  |  |  |   41|      2|  ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition)
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  180|      2|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|      4|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|      4|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 2, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|      2|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 2]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|      4|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [True: 2, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [Folded, False: 2]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, False: 2]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|      0|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   29|      2|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      2|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  705|      4|      << "Invalid fixture driver!";
  706|      2|  stats_.start_time = absl::Now();
  707|      2|  const char* corpus_out_dir_chars = getenv("FUZZTEST_TESTSUITE_OUT_DIR");
  708|      2|  if (corpus_out_dir_chars) corpus_out_dir_ = corpus_out_dir_chars;
  ------------------
  |  Branch (708:7): [True: 0, False: 2]
  ------------------
  709|       |
  710|      2|  std::vector<double> weights = {100.};
  711|      2|  corpus_distribution_ =
  712|      2|      absl::discrete_distribution<>(weights.begin(), weights.end());
  713|      2|}
_ZN8fuzztest8internal18FuzzTestFuzzerImpl8TryParseENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
  720|  4.70k|    absl::string_view data) {
  721|  4.70k|  auto ir_value = ParseIRObject(data);
  722|  4.70k|  if (!ir_value) {
  ------------------
  |  Branch (722:7): [True: 1.50k, False: 3.20k]
  ------------------
  723|  1.50k|    return absl::InvalidArgumentError("Unexpected file format");
  724|  1.50k|  }
  725|  3.20k|  auto corpus_value = params_domain_.ParseCorpus(*ir_value);
  726|  3.20k|  if (!corpus_value) {
  ------------------
  |  Branch (726:7): [True: 2.07k, False: 1.13k]
  ------------------
  727|  2.07k|    return absl::InvalidArgumentError("Unexpected intermediate representation");
  728|  2.07k|  }
  729|  1.13k|  absl::Status is_valid = params_domain_.ValidateCorpusValue(*corpus_value);
  730|  1.13k|  if (!is_valid.ok()) {
  ------------------
  |  Branch (730:7): [True: 0, False: 1.13k]
  ------------------
  731|      0|    return Prefix(is_valid, "Invalid corpus value");
  732|      0|  }
  733|  1.13k|  return *corpus_value;
  734|  1.13k|}
_ZN8fuzztest8internal18FuzzTestFuzzerImpl10ShouldStopEv:
 1010|  4.70k|bool FuzzTestFuzzerImpl::ShouldStop() {
 1011|  4.70k|  if (runs_limit_.has_value() && stats_.runs >= *runs_limit_) return true;
  ------------------
  |  Branch (1011:7): [True: 0, False: 4.70k]
  |  Branch (1011:34): [True: 0, False: 0]
  ------------------
 1012|  4.70k|  if (time_limit_ != absl::InfiniteFuture() && absl::Now() > time_limit_)
  ------------------
  |  Branch (1012:7): [True: 0, False: 4.70k]
  |  Branch (1012:48): [True: 0, False: 0]
  ------------------
 1013|      0|    return true;
 1014|  4.70k|  return runtime_.termination_requested();
 1015|  4.70k|}
_ZN8fuzztest8internal18FuzzTestFuzzerImpl11RunOneInputERKNS1_5InputE:
 1128|  1.13k|    const Input& input) {
 1129|  1.13k|  ++stats_.runs;
 1130|  1.13k|  auto untyped_args = params_domain_.GetValue(input.args);
 1131|  1.13k|  Runtime::Args debug_args{input.args, params_domain_};
 1132|  1.13k|  runtime_.SetCurrentArgs(&debug_args);
 1133|       |
 1134|       |  // Reset and observe the coverage map and start tracing in
 1135|       |  // the tightest scope possible. In particular, we can't include the call
 1136|       |  // to GetValue in the scope as it will run user code.
 1137|  1.13k|  if (execution_coverage_ != nullptr) {
  ------------------
  |  Branch (1137:7): [True: 0, False: 1.13k]
  ------------------
 1138|      0|    execution_coverage_->ResetState();
 1139|      0|  }
 1140|  1.13k|  absl::Time start = absl::Now();
 1141|  1.13k|  runtime_.OnTestIterationStart(start);
 1142|       |  // Set tracing after absl::Now(), otherwise it will make
 1143|       |  // FuzzingModeTest.MinimizesDuplicatedCorpustest flaky because
 1144|       |  // randomness in absl::Now() being traced by cmp coverage.
 1145|  1.13k|  if (execution_coverage_ != nullptr) {
  ------------------
  |  Branch (1145:7): [True: 0, False: 1.13k]
  ------------------
 1146|      0|    execution_coverage_->SetIsTracing(true);
 1147|      0|  }
 1148|       |
 1149|  1.13k|  runtime_.SetSkippingRequested(false);
 1150|  1.13k|  fixture_driver_->RunFuzzTestIteration([&] {
 1151|  1.13k|    if (!runtime_.skipping_requested()) {
 1152|  1.13k|      fixture_driver_->Test(std::move(untyped_args));
 1153|  1.13k|    }
 1154|  1.13k|  });
 1155|  1.13k|  if (execution_coverage_ != nullptr) {
  ------------------
  |  Branch (1155:7): [True: 0, False: 1.13k]
  ------------------
 1156|      0|    execution_coverage_->SetIsTracing(false);
 1157|      0|  }
 1158|  1.13k|  const absl::Duration run_time = absl::Now() - start;
 1159|       |
 1160|  1.13k|  bool new_coverage = false;
 1161|  1.13k|  if (execution_coverage_ != nullptr && !runtime_.skipping_requested()) {
  ------------------
  |  Branch (1161:7): [True: 0, False: 1.13k]
  |  Branch (1161:41): [True: 0, False: 0]
  ------------------
 1162|      0|    new_coverage = corpus_coverage_.Update(execution_coverage_);
 1163|      0|    stats_.max_stack_used =
 1164|      0|        std::max(stats_.max_stack_used, execution_coverage_->MaxStackUsed());
 1165|      0|  }
 1166|       |
 1167|  1.13k|  runtime_.OnTestIterationEnd();
 1168|  1.13k|  runtime_.UnsetCurrentArgs();
 1169|  1.13k|  return {new_coverage, run_time};
 1170|  1.13k|}
runtime.cc:_ZN8fuzztest8internalL15GetPeakRSSBytesEv:
  442|  1.13k|static size_t GetPeakRSSBytes() {
  443|       |#ifndef FUZZTEST_HAS_RUSAGE
  444|       |  return 0;
  445|       |#else
  446|  1.13k|  struct rusage usage = {};
  447|  1.13k|  if (getrusage(RUSAGE_SELF, &usage) != 0) return 0;
  ------------------
  |  Branch (447:7): [True: 0, False: 1.13k]
  ------------------
  448|       |  // On Linux, ru_maxrss is in KiB
  449|  1.13k|  return usage.ru_maxrss * 1024;
  450|  1.13k|#endif
  451|  1.13k|}
runtime.cc:_ZN8fuzztest8internalL15SetNewSigActionEiPFviP9siginfo_tPvEP9sigaction:
  615|     18|                            struct sigaction* old_sigact) {
  616|     18|  struct sigaction new_sigact = {};
  617|     18|  sigemptyset(&new_sigact.sa_mask);
  618|     18|  new_sigact.sa_sigaction = handler;
  619|       |
  620|       |  // We make use of the SA_ONSTACK flag so that signal handlers are executed on
  621|       |  // a separate stack. This is needed to properly handle cases where stack space
  622|       |  // is limited and the delivery of a signal needs to be properly handled.
  623|     18|  new_sigact.sa_flags = SA_SIGINFO | SA_ONSTACK;
  624|       |
  625|     18|  if (sigaction(signum, &new_sigact, old_sigact) == -1) {
  ------------------
  |  Branch (625:7): [True: 0, False: 18]
  ------------------
  626|      0|    fprintf(GetStderr(), "Error installing signal handler: %s\n",
  627|       |            strerror(errno));
  628|      0|    exit(1);
  629|      0|  }
  630|     18|}
runtime.cc:_ZZN8fuzztest8internal18FuzzTestFuzzerImpl11RunOneInputERKNS1_5InputEENK3$_0clEv:
 1150|  1.13k|  fixture_driver_->RunFuzzTestIteration([&] {
 1151|  1.13k|    if (!runtime_.skipping_requested()) {
  ------------------
  |  Branch (1151:9): [True: 1.13k, False: 0]
  ------------------
 1152|  1.13k|      fixture_driver_->Test(std::move(untyped_args));
 1153|  1.13k|    }
 1154|  1.13k|  });

_ZN8fuzztest8internal8FuzzTestC2ENS0_13BasicTestInfoEN4absl12lts_2026052612AnyInvocableIKFNSt3__110unique_ptrINS0_14FuzzTestFuzzerENS6_14default_deleteIS8_EEEERKS1_EEE:
   83|      2|      : test_info_(std::move(test_info)), make_(std::move(factory)) {}
_ZNK8fuzztest8internal8FuzzTest10suite_nameEv:
   85|      2|  const std::string& suite_name() const { return test_info_.suite_name; }
_ZNK8fuzztest8internal8FuzzTest9test_nameEv:
   86|      2|  const std::string& test_name() const { return test_info_.test_name; }
_ZNK8fuzztest8internal8FuzzTest9full_nameEv:
   87|      6|  std::string full_name() const {
   88|      6|    return absl::StrCat(test_info_.suite_name, ".", test_info_.test_name);
   89|      6|  }
_ZNK8fuzztest8internal8FuzzTest4fileEv:
   90|      2|  const std::string& file() const { return test_info_.file; }
_ZNK8fuzztest8internal8FuzzTest4lineEv:
   91|      2|  int line() const { return test_info_.line; }
_ZNK8fuzztest8internal8FuzzTest12uses_fixtureEv:
   92|      2|  bool uses_fixture() const { return test_info_.uses_fixture; }
_ZNK8fuzztest8internal8FuzzTest4makeEv:
   93|      2|  auto make() const { return make_(*this); }
_ZN8fuzztest8internal7Runtime8instanceEv:
  127|      8|  static Runtime& instance() {
  128|      8|    static auto* runtime = new Runtime();
  129|      8|    return *runtime;
  130|      8|  }
_ZN8fuzztest8internal7Runtime20SetSkippingRequestedEb:
  139|  1.13k|  void SetSkippingRequested(bool requested) {
  140|  1.13k|    skipping_requested_.store(requested, std::memory_order_relaxed);
  141|  1.13k|  }
_ZNK8fuzztest8internal7Runtime18skipping_requestedEv:
  143|  1.13k|  bool skipping_requested() const {
  144|  1.13k|    return skipping_requested_.load(std::memory_order_relaxed);
  145|  1.13k|  }
_ZNK8fuzztest8internal7Runtime21termination_requestedEv:
  159|  4.70k|  bool termination_requested() const {
  160|  4.70k|    return termination_requested_.load(std::memory_order_relaxed);
  161|  4.70k|  }
_ZN8fuzztest8internal7Runtime10SetRunModeENS_7RunModeE:
  163|      4|  void SetRunMode(RunMode run_mode) { run_mode_ = run_mode; }
_ZNK8fuzztest8internal7Runtime8run_modeEv:
  164|      2|  RunMode run_mode() const { return run_mode_; }
_ZN8fuzztest8internal7Runtime14EnableReporterEPKNS0_12RuntimeStatsEPFN4absl12lts_202605264TimeEvE:
  168|      2|  void EnableReporter(const RuntimeStats* stats, absl::Time (*clock_fn)()) {
  169|      2|    reporter_enabled_ = true;
  170|      2|    stats_ = stats;
  171|      2|    clock_fn_ = clock_fn;
  172|       |    // In case we have not installed them yet, do so now.
  173|      2|    InstallSignalHandlers(GetStderr());
  174|      2|    InstallUnexpectedExitHandler();
  175|      2|    ResetCrashType();
  176|      2|  }
_ZN8fuzztest8internal7Runtime14SetCurrentArgsEPNS1_4ArgsE:
  193|  1.13k|  void SetCurrentArgs(Args* args) { current_args_ = args; }
_ZN8fuzztest8internal7Runtime16UnsetCurrentArgsEv:
  194|  1.13k|  void UnsetCurrentArgs() { current_args_ = nullptr; }
_ZN8fuzztest8internal7Runtime14ResetCrashTypeEv:
  211|      2|  void ResetCrashType() { crash_type_ = std::nullopt; }
_ZN8fuzztest8internal7Runtime8SpinlockC2Ev:
  272|      2|    Spinlock() = default;

_ZN8fuzztest8internal23GetFromEnvOrMakeSeedSeqERNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEENS1_17basic_string_viewIcS4_EE:
   64|      2|                                      absl::string_view env_var) {
   65|      2|  const std::vector<uint32_t> seed_material =
   66|      2|      GetFromEnvOrMakeSeedMaterial(env_var);
   67|      2|  const std::string encoded_seed_material = EncodeSeedMaterial(seed_material);
   68|      2|  out << env_var << "=" << encoded_seed_material << '\n';
   69|      2|  return std::seed_seq(seed_material.begin(), seed_material.end());
   70|      2|}
_ZN8fuzztest8internal18EncodeSeedMaterialEN4absl12lts_202605264SpanIKjEE:
   72|      2|std::string EncodeSeedMaterial(absl::Span<const uint32_t> seed_material) {
   73|      2|  return absl::WebSafeBase64Escape(
   74|      2|      absl::string_view(reinterpret_cast<const char*>(seed_material.data()),
   75|      2|                        seed_material.size() * sizeof(uint32_t)));
   76|      2|}
seed_seq.cc:_ZN8fuzztest8internal12_GLOBAL__N_128GetFromEnvOrMakeSeedMaterialENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
   48|      2|std::vector<uint32_t> GetFromEnvOrMakeSeedMaterial(absl::string_view env_var) {
   49|      2|  const char* encoded_seed_material = std::getenv(env_var.data());
   50|      2|  if (encoded_seed_material == nullptr) {
  ------------------
  |  Branch (50:7): [True: 2, False: 0]
  ------------------
   51|      2|    return MakeSeedMaterial();
   52|      2|  }
   53|      0|  std::optional<std::vector<uint32_t>> seed_material =
   54|      0|      DecodeSeedMaterial(encoded_seed_material);
   55|      0|  FUZZTEST_PRECONDITION(seed_material.has_value())
  ------------------
  |  |   32|      0|  ABSL_CHECK(cond) << "[Failed precondition] Incorrect usage: "
  |  |  ------------------
  |  |  |  |   41|      0|  ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition)
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  180|      0|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|      0|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|      0|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|      0|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|      0|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|      0|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |  |  |   29|      0|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   56|      0|      << "Failed to decode seed material from the environment variable "
   57|      0|      << env_var;
   58|      0|  return *std::move(seed_material);
   59|      0|}
seed_seq.cc:_ZN8fuzztest8internal12_GLOBAL__N_116MakeSeedMaterialEv:
   38|      2|std::vector<uint32_t> MakeSeedMaterial() {
   39|      2|  absl::BitGen gen;
   40|      2|  static constexpr int kNumberOfEntropyBits = 256;
   41|      2|  std::vector<uint32_t> seed_material(kNumberOfEntropyBits /
   42|      2|                                      (8 * sizeof(uint32_t)));
   43|      2|  std::generate(seed_material.begin(), seed_material.end(),
   44|      2|                [&gen] { return absl::Uniform<uint32_t>(gen); });
   45|      2|  return seed_material;
   46|      2|}
seed_seq.cc:_ZZN8fuzztest8internal12_GLOBAL__N_116MakeSeedMaterialEvENK3$_0clEv:
   44|     16|                [&gen] { return absl::Uniform<uint32_t>(gen); });

_ZN8fuzztest8internal13ParseIRObjectENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  328|  4.70k|std::optional<IRObject> ParseIRObject(absl::string_view str) {
  329|  4.70k|  IRObject object;
  330|  4.70k|  if (IsInBinaryFormat(str)) {
  ------------------
  |  Branch (330:7): [True: 1.11k, False: 3.58k]
  ------------------
  331|  1.11k|    BinaryParseBuf buf = {str.data(), str.size()};
  332|  1.11k|    buf.Advance(kBinaryHeader.size());
  333|  1.11k|    if (!BinaryParse(object, buf, /*recursion_depth=*/0) || !buf.empty())
  ------------------
  |  Branch (333:9): [True: 43, False: 1.07k]
  |  Branch (333:61): [True: 1, False: 1.07k]
  ------------------
  334|     44|      return std::nullopt;
  335|  3.58k|  } else {
  336|  3.58k|    if (ReadToken(str) != kHeader) return std::nullopt;
  ------------------
  |  Branch (336:9): [True: 84, False: 3.50k]
  ------------------
  337|  3.50k|    if (!ParseImpl(object, str, /*recursion_depth=*/0) ||
  ------------------
  |  Branch (337:9): [True: 1.29k, False: 2.20k]
  |  Branch (337:9): [True: 1.37k, False: 2.13k]
  ------------------
  338|  2.20k|        !ReadToken(str).empty())
  ------------------
  |  Branch (338:9): [True: 74, False: 2.13k]
  ------------------
  339|  1.37k|      return std::nullopt;
  340|  3.50k|  }
  341|  3.20k|  return object;
  342|  4.70k|}
serialization.cc:_ZN8fuzztest8internal12_GLOBAL__N_116IsInBinaryFormatENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
  299|  4.70k|bool IsInBinaryFormat(absl::string_view str) {
  300|       |  // Not using absl::string_view or std::memcmp because they could be
  301|       |  // instrumented and using them could pollute coverage.
  302|  4.70k|  return str.size() >= kBinaryHeader.size() &&
  ------------------
  |  Branch (302:10): [True: 4.63k, False: 66]
  ------------------
  303|  4.63k|         __builtin_memcmp(str.data(), kBinaryHeader.data(),
  ------------------
  |  Branch (303:10): [True: 1.11k, False: 3.52k]
  ------------------
  304|  4.63k|                          kBinaryHeader.size()) == 0;
  305|  4.70k|}
serialization.cc:_ZN8fuzztest8internal12_GLOBAL__N_114BinaryParseBuf7AdvanceEm:
  239|  12.3k|  void Advance(size_t s) {
  240|  12.3k|    if (s > size) s = size;
  ------------------
  |  Branch (240:9): [True: 0, False: 12.3k]
  ------------------
  241|  12.3k|    str += s;
  242|  12.3k|    size -= s;
  243|  12.3k|  }
serialization.cc:_ZN8fuzztest8internal12_GLOBAL__N_111BinaryParseERNS0_6no_adl8IRObjectERNS1_14BinaryParseBufEi:
  246|  6.39k|bool BinaryParse(IRObject& obj, BinaryParseBuf& buf, int recursion_depth) {
  247|  6.39k|  if (recursion_depth > kMaxParseRecursionDepth) return false;
  ------------------
  |  Branch (247:7): [True: 0, False: 6.39k]
  ------------------
  248|  6.39k|  if (buf.empty()) return false;
  ------------------
  |  Branch (248:7): [True: 7, False: 6.39k]
  ------------------
  249|  6.39k|  const auto h = static_cast<BinaryFormatHeader>(buf.str[0]);
  250|  6.39k|  buf.Advance(1);
  251|  6.39k|  switch (h) {
  ------------------
  |  Branch (251:11): [True: 6.36k, False: 26]
  ------------------
  252|  2.55k|    case BinaryFormatHeader::kEmpty: {
  ------------------
  |  Branch (252:5): [True: 2.55k, False: 3.84k]
  ------------------
  253|  2.55k|      return true;
  254|      0|    }
  255|  1.08k|    case BinaryFormatHeader::kUInt64: {
  ------------------
  |  Branch (255:5): [True: 1.08k, False: 5.30k]
  ------------------
  256|  1.08k|      if (buf.size < sizeof(uint64_t)) return false;
  ------------------
  |  Branch (256:11): [True: 0, False: 1.08k]
  ------------------
  257|  1.08k|      auto& t = obj.MutableScalar<uint64_t>();
  258|  1.08k|      std::memcpy(&t, buf.str, sizeof(uint64_t));
  259|  1.08k|      buf.Advance(sizeof(uint64_t));
  260|  1.08k|      return true;
  261|  1.08k|    }
  262|      1|    case BinaryFormatHeader::kDouble: {
  ------------------
  |  Branch (262:5): [True: 1, False: 6.38k]
  ------------------
  263|      1|      if (buf.size < sizeof(double)) return false;
  ------------------
  |  Branch (263:11): [True: 1, False: 0]
  ------------------
  264|      0|      auto& t = obj.MutableScalar<double>();
  265|      0|      std::memcpy(&t, buf.str, sizeof(t));
  266|      0|      buf.Advance(sizeof(double));
  267|      0|      return true;
  268|      1|    }
  269|  1.07k|    case BinaryFormatHeader::kString: {
  ------------------
  |  Branch (269:5): [True: 1.07k, False: 5.31k]
  ------------------
  270|  1.07k|      if (buf.size < sizeof(uint64_t)) return false;
  ------------------
  |  Branch (270:11): [True: 2, False: 1.07k]
  ------------------
  271|  1.07k|      uint64_t str_size;
  272|  1.07k|      std::memcpy(&str_size, buf.str, sizeof(str_size));
  273|  1.07k|      buf.Advance(sizeof(uint64_t));
  274|  1.07k|      if (buf.size < str_size) return false;
  ------------------
  |  Branch (274:11): [True: 4, False: 1.07k]
  ------------------
  275|  1.07k|      obj.MutableScalar<std::string>() = {buf.str,
  276|  1.07k|                                          static_cast<size_t>(str_size)};
  277|  1.07k|      buf.Advance(str_size);
  278|  1.07k|      return true;
  279|  1.07k|    }
  280|  1.65k|    case BinaryFormatHeader::kObject: {
  ------------------
  |  Branch (280:5): [True: 1.65k, False: 4.73k]
  ------------------
  281|  1.65k|      if (buf.size < sizeof(uint64_t)) return false;
  ------------------
  |  Branch (281:11): [True: 1, False: 1.65k]
  ------------------
  282|  1.65k|      uint64_t vec_size;
  283|  1.65k|      std::memcpy(&vec_size, buf.str, sizeof(vec_size));
  284|  1.65k|      buf.Advance(sizeof(vec_size));
  285|       |      // This could happen for malformed inputs.
  286|  1.65k|      if (vec_size > buf.size) return false;
  ------------------
  |  Branch (286:11): [True: 2, False: 1.65k]
  ------------------
  287|  1.65k|      auto& v = obj.MutableSubs();
  288|  1.65k|      v.reserve(vec_size);
  289|  6.63k|      for (uint64_t i = 0; i < vec_size; ++i) {
  ------------------
  |  Branch (289:28): [True: 5.28k, False: 1.35k]
  ------------------
  290|  5.28k|        if (!BinaryParse(v.emplace_back(), buf, recursion_depth + 1))
  ------------------
  |  Branch (290:13): [True: 299, False: 4.98k]
  ------------------
  291|    299|          return false;
  292|  5.28k|      }
  293|  1.35k|      return true;
  294|  1.65k|    }
  295|  6.39k|  }
  296|     26|  return false;
  297|  6.39k|}
serialization.cc:_ZNK8fuzztest8internal12_GLOBAL__N_114BinaryParseBuf5emptyEv:
  238|  7.47k|  bool empty() const { return size == 0; }
serialization.cc:_ZN8fuzztest8internal12_GLOBAL__N_19ReadTokenERNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
   76|   221k|absl::string_view ReadToken(absl::string_view& in) {
   77|   277k|  while (!in.empty() && std::isspace(in[0])) in.remove_prefix(1);
  ------------------
  |  Branch (77:10): [True: 274k, False: 3.06k]
  |  Branch (77:25): [True: 55.2k, False: 218k]
  ------------------
   78|   221k|  if (in.empty()) return in;
  ------------------
  |  Branch (78:7): [True: 3.06k, False: 218k]
  ------------------
   79|   218k|  size_t end = 1;
   80|   218k|  const auto is_literal = [](char c) {
   81|   218k|    return std::isalnum(c) != 0 || c == '+' || c == '-' || c == '.';
   82|   218k|  };
   83|   218k|  if (is_literal(in[0])) {
  ------------------
  |  Branch (83:7): [True: 111k, False: 107k]
  ------------------
   84|  48.3M|    while (end < in.size() && is_literal(in[end])) ++end;
  ------------------
  |  Branch (84:12): [True: 48.3M, False: 3.02k]
  |  Branch (84:31): [True: 48.2M, False: 108k]
  ------------------
   85|   111k|  } else if (in[0] == '"') {
  ------------------
  |  Branch (85:14): [True: 452, False: 106k]
  ------------------
   86|  3.80M|    while (end < in.size() && in[end] != '"') ++end;
  ------------------
  |  Branch (86:12): [True: 3.80M, False: 21]
  |  Branch (86:31): [True: 3.80M, False: 431]
  ------------------
   87|    452|    if (end < in.size()) ++end;
  ------------------
  |  Branch (87:9): [True: 431, False: 21]
  ------------------
   88|    452|  }
   89|   218k|  absl::string_view res = in.substr(0, end);
   90|   218k|  in.remove_prefix(end);
   91|   218k|  return res;
   92|   221k|}
serialization.cc:_ZZN8fuzztest8internal12_GLOBAL__N_19ReadTokenERNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEENK3$_0clEc:
   80|  48.5M|  const auto is_literal = [](char c) {
   81|  48.5M|    return std::isalnum(c) != 0 || c == '+' || c == '-' || c == '.';
  ------------------
  |  Branch (81:12): [True: 48.2M, False: 285k]
  |  Branch (81:36): [True: 1.74k, False: 283k]
  |  Branch (81:48): [True: 54.5k, False: 228k]
  |  Branch (81:60): [True: 13.1k, False: 215k]
  ------------------
   82|  48.5M|  };
serialization.cc:_ZN8fuzztest8internal12_GLOBAL__N_19ParseImplERNS0_6no_adl8IRObjectERNSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEi:
  134|  39.8k|bool ParseImpl(IRObject& obj, absl::string_view& str, int recursion_depth) {
  135|  39.8k|  if (recursion_depth > kMaxParseRecursionDepth) return false;
  ------------------
  |  Branch (135:7): [True: 0, False: 39.8k]
  ------------------
  136|  39.8k|  absl::string_view key = ReadToken(str);
  137|  39.8k|  if (key.empty() || key == "}") {
  ------------------
  |  Branch (137:7): [True: 47, False: 39.8k]
  |  Branch (137:22): [True: 603, False: 39.2k]
  ------------------
  138|       |    // The object is empty. Put the token back and return.
  139|    650|    str = absl::string_view(key.data(), str.data() + str.size() - key.data());
  140|    650|    return true;
  141|    650|  }
  142|       |
  143|  39.2k|  if (key == "sub") {
  ------------------
  |  Branch (143:7): [True: 3.27k, False: 35.9k]
  ------------------
  144|  3.27k|    auto& v = obj.MutableSubs();
  145|  36.4k|    do {
  146|  36.4k|      if (ReadToken(str) != "{") return false;
  ------------------
  |  Branch (146:11): [True: 39, False: 36.3k]
  ------------------
  147|  36.3k|      if (!ParseImpl(v.emplace_back(), str, recursion_depth + 1)) return false;
  ------------------
  |  Branch (147:11): [True: 2.12k, False: 34.2k]
  ------------------
  148|  34.2k|      if (ReadToken(str) != "}") return false;
  ------------------
  |  Branch (148:11): [True: 683, False: 33.5k]
  ------------------
  149|  33.5k|      key = ReadToken(str);
  150|  33.5k|    } while (key == "sub");
  ------------------
  |  Branch (150:14): [True: 33.1k, False: 421]
  ------------------
  151|       |    // We are done reading this repeated sub.
  152|       |    // Put the token back for the caller.
  153|    421|    str = absl::string_view(key.data(), str.data() + str.size() - key.data());
  154|    421|    return true;
  155|  35.9k|  } else {
  156|  35.9k|    if (ReadToken(str) != ":") return false;
  ------------------
  |  Branch (156:9): [True: 18, False: 35.9k]
  ------------------
  157|  35.9k|    auto value = ReadToken(str);
  158|  35.9k|    if (key == "i") {
  ------------------
  |  Branch (158:9): [True: 10.3k, False: 25.6k]
  ------------------
  159|  10.3k|      return ReadScalar(obj.MutableScalar<uint64_t>(), value);
  160|  25.6k|    } else if (key == "d") {
  ------------------
  |  Branch (160:16): [True: 25.1k, False: 440]
  ------------------
  161|  25.1k|      return ReadScalar(obj.MutableScalar<double>(), value);
  162|  25.1k|    } else if (key == "s") {
  ------------------
  |  Branch (162:16): [True: 440, False: 0]
  ------------------
  163|    440|      return ReadScalar(obj.MutableScalar<std::string>(), value);
  164|    440|    } else {
  165|       |      // Unrecognized key
  166|      0|      return false;
  167|      0|    }
  168|  35.9k|  }
  169|  39.2k|}
serialization.cc:_ZN8fuzztest8internal12_GLOBAL__N_110ReadScalarERmNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   94|  10.3k|bool ReadScalar(uint64_t& out, absl::string_view value) {
   95|  10.3k|  return absl::SimpleAtoi(value, &out);
   96|  10.3k|}
serialization.cc:_ZN8fuzztest8internal12_GLOBAL__N_110ReadScalarERdNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   98|  25.1k|bool ReadScalar(double& out, absl::string_view value) {
   99|  25.1k|  return absl::SimpleAtod(value, &out);
  100|  25.1k|}
serialization.cc:_ZN8fuzztest8internal12_GLOBAL__N_110ReadScalarERNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS2_17basic_string_viewIcS5_EE:
  102|    440|bool ReadScalar(std::string& out, absl::string_view value) {
  103|    440|  if (value.empty() || value[0] != '"') return false;
  ------------------
  |  Branch (103:7): [True: 6, False: 434]
  |  Branch (103:24): [True: 0, False: 434]
  ------------------
  104|    434|  value.remove_prefix(1);
  105|       |
  106|    434|  if (value.empty() || value.back() != '"') return false;
  ------------------
  |  Branch (106:7): [True: 2, False: 432]
  |  Branch (106:24): [True: 1, False: 431]
  ------------------
  107|    431|  value.remove_suffix(1);
  108|       |
  109|  2.23M|  while (!value.empty()) {
  ------------------
  |  Branch (109:10): [True: 2.23M, False: 431]
  ------------------
  110|  2.23M|    if (value[0] != '\\') {
  ------------------
  |  Branch (110:9): [True: 2.23M, False: 0]
  ------------------
  111|  2.23M|      out += value[0];
  112|  2.23M|      value.remove_prefix(1);
  113|  2.23M|    } else {
  114|      0|      uint32_t v = 0;
  115|       |
  116|      0|      if (value.size() < 4) return false;
  ------------------
  |  Branch (116:11): [True: 0, False: 0]
  ------------------
  117|      0|      for (int i = 1; i < 4; ++i) {
  ------------------
  |  Branch (117:23): [True: 0, False: 0]
  ------------------
  118|      0|        if (value[i] < '0' || value[i] > '7') {
  ------------------
  |  Branch (118:13): [True: 0, False: 0]
  |  Branch (118:31): [True: 0, False: 0]
  ------------------
  119|      0|          return false;
  120|      0|        }
  121|      0|        v = 8 * v + value[i] - '0';
  122|      0|      }
  123|      0|      if (v > 255) return false;
  ------------------
  |  Branch (123:11): [True: 0, False: 0]
  ------------------
  124|       |
  125|      0|      out += static_cast<char>(v);
  126|      0|      value.remove_prefix(4);
  127|      0|    }
  128|  2.23M|  }
  129|    431|  return true;
  130|    431|}

_ZNK8fuzztest8internal6no_adl8IRObject8ToCorpusINSt3__15tupleIJNS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEEEENS4_8optionalIT_EEv:
  245|  3.20k|  std::optional<T> ToCorpus() const {
  246|       |    if constexpr (std::is_const_v<T>) {
  247|       |      return ToCorpus<std::remove_const_t<T>>();
  248|       |    } else if constexpr (is_monostate_v<T>) {
  249|       |      if (std::holds_alternative<std::monostate>(value_)) return T{};
  250|       |      return std::nullopt;
  251|       |    } else if constexpr (std::is_same_v<T, IRObject>) {
  252|       |      return *this;
  253|       |    } else if constexpr (std::is_constructible_v<IRObject, T>) {
  254|       |      if (auto v = GetScalar<T>()) {
  255|       |        return static_cast<T>(*v);
  256|       |      }
  257|       |      return std::nullopt;
  258|       |    } else if constexpr (is_variant_v<T>) {
  259|       |      auto elems = Subs();
  260|       |      if (!elems || elems->size() != 2) return std::nullopt;
  261|       |      auto index = (*elems)[0].ToCorpus<size_t>();
  262|       |      if (!index || *index >= std::variant_size_v<T>) return std::nullopt;
  263|       |      return Switch<std::variant_size_v<T>>(
  264|       |          *index, [&](auto I) -> std::optional<T> {
  265|       |            auto inner =
  266|       |                (*elems)[1].ToCorpus<std::variant_alternative_t<I, T>>();
  267|       |            if (inner) return T(std::in_place_index<I>, *std::move(inner));
  268|       |            return std::nullopt;
  269|       |          });
  270|       |    } else if constexpr (std::is_same_v<T, absl::int128> ||
  271|       |                         std::is_same_v<T, absl::uint128>) {
  272|       |      if (auto res = ToCorpus<std::pair<uint64_t, uint64_t>>()) {
  273|       |        return static_cast<T>(absl::MakeUint128(res->first, res->second));
  274|       |      }
  275|       |      return std::nullopt;
  276|       |    } else if constexpr (is_protocol_buffer_v<T>) {
  277|       |      const std::string* v = std::get_if<std::string>(&value_);
  278|       |      T out;
  279|       |      if (v && out.ParseFromString(*v)) return out;
  280|       |      return std::nullopt;
  281|       |    } else if constexpr (is_dynamic_container_v<T>) {
  282|       |      if constexpr (is_bytevector_v<T>) {
  283|       |        const std::string* v = std::get_if<std::string>(&value_);
  284|       |        if (v) {
  285|       |          T out;
  286|       |          out.resize(v->size());
  287|       |          std::memcpy(out.data(), v->data(), v->size());
  288|       |          return out;
  289|       |        }
  290|       |      }
  291|       |
  292|       |      auto elems = Subs();
  293|       |      if (!elems) return std::nullopt;
  294|       |
  295|       |      T out;
  296|       |      for (const auto& elem : *elems) {
  297|       |        if (auto inner = elem.ToCorpus<typename T::value_type>()) {
  298|       |          out.insert(out.end(), *std::move(inner));
  299|       |        } else {
  300|       |          return std::nullopt;
  301|       |        }
  302|       |      }
  303|       |      return out;
  304|  3.20k|    } else {
  305|       |      // Must be a tuple like object.
  306|  3.20k|      auto elems = Subs();
  307|  3.20k|      if (!elems || elems->size() != std::tuple_size_v<T>) return std::nullopt;
  ------------------
  |  Branch (307:11): [True: 1.94k, False: 1.26k]
  |  Branch (307:21): [True: 113, False: 1.15k]
  ------------------
  308|  1.15k|      auto it = elems->begin();
  309|  1.15k|      auto parts = ApplyIndex<std::tuple_size_v<T>>([&](auto... I) {
  310|  1.15k|        return std::tuple{it++->ToCorpus<std::tuple_element_t<I, T>>()...};
  311|  1.15k|      });
  312|  1.15k|      return std::apply(
  313|  1.15k|          [&](auto&... part) -> std::optional<T> {
  314|  1.15k|            if ((!part || ...)) return std::nullopt;
  315|  1.15k|            return T{*std::move(part)...};
  316|  1.15k|          },
  317|  1.15k|          parts);
  318|  3.20k|    }
  319|  3.20k|  }
_ZNK8fuzztest8internal6no_adl8IRObject4SubsEv:
  152|  3.20k|  std::optional<absl::Span<const IRObject>> Subs() const {
  153|  3.20k|    if (const auto* i = std::get_if<std::vector<IRObject>>(&value_)) {
  ------------------
  |  Branch (153:21): [True: 1.26k, False: 1.94k]
  ------------------
  154|  1.26k|      return *i;
  155|  1.26k|    }
  156|       |    // The empty vector is serialized the same way as the monostate: nothing.
  157|       |    // Handle that case too.
  158|  1.94k|    if (std::holds_alternative<std::monostate>(value_)) {
  ------------------
  |  Branch (158:9): [True: 3, False: 1.94k]
  ------------------
  159|      3|      return absl::Span<const IRObject>{};
  160|      3|    }
  161|  1.94k|    return std::nullopt;
  162|  1.94k|  }
_ZZNK8fuzztest8internal6no_adl8IRObject8ToCorpusINSt3__15tupleIJNS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEEEENS4_8optionalIT_EEvENKUlDpT_E_clIJNS4_17integral_constantImLm0EEEEEEDaSH_:
  309|  1.15k|      auto parts = ApplyIndex<std::tuple_size_v<T>>([&](auto... I) {
  310|  1.15k|        return std::tuple{it++->ToCorpus<std::tuple_element_t<I, T>>()...};
  311|  1.15k|      });
_ZNK8fuzztest8internal6no_adl8IRObject8ToCorpusINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEENS4_8optionalIT_EEv:
  245|  1.15k|  std::optional<T> ToCorpus() const {
  246|       |    if constexpr (std::is_const_v<T>) {
  247|       |      return ToCorpus<std::remove_const_t<T>>();
  248|       |    } else if constexpr (is_monostate_v<T>) {
  249|       |      if (std::holds_alternative<std::monostate>(value_)) return T{};
  250|       |      return std::nullopt;
  251|       |    } else if constexpr (std::is_same_v<T, IRObject>) {
  252|       |      return *this;
  253|  1.15k|    } else if constexpr (std::is_constructible_v<IRObject, T>) {
  254|  1.15k|      if (auto v = GetScalar<T>()) {
  ------------------
  |  Branch (254:16): [True: 1.13k, False: 17]
  ------------------
  255|  1.13k|        return static_cast<T>(*v);
  256|  1.13k|      }
  257|     17|      return std::nullopt;
  258|       |    } else if constexpr (is_variant_v<T>) {
  259|       |      auto elems = Subs();
  260|       |      if (!elems || elems->size() != 2) return std::nullopt;
  261|       |      auto index = (*elems)[0].ToCorpus<size_t>();
  262|       |      if (!index || *index >= std::variant_size_v<T>) return std::nullopt;
  263|       |      return Switch<std::variant_size_v<T>>(
  264|       |          *index, [&](auto I) -> std::optional<T> {
  265|       |            auto inner =
  266|       |                (*elems)[1].ToCorpus<std::variant_alternative_t<I, T>>();
  267|       |            if (inner) return T(std::in_place_index<I>, *std::move(inner));
  268|       |            return std::nullopt;
  269|       |          });
  270|       |    } else if constexpr (std::is_same_v<T, absl::int128> ||
  271|       |                         std::is_same_v<T, absl::uint128>) {
  272|       |      if (auto res = ToCorpus<std::pair<uint64_t, uint64_t>>()) {
  273|       |        return static_cast<T>(absl::MakeUint128(res->first, res->second));
  274|       |      }
  275|       |      return std::nullopt;
  276|       |    } else if constexpr (is_protocol_buffer_v<T>) {
  277|       |      const std::string* v = std::get_if<std::string>(&value_);
  278|       |      T out;
  279|       |      if (v && out.ParseFromString(*v)) return out;
  280|       |      return std::nullopt;
  281|       |    } else if constexpr (is_dynamic_container_v<T>) {
  282|       |      if constexpr (is_bytevector_v<T>) {
  283|       |        const std::string* v = std::get_if<std::string>(&value_);
  284|       |        if (v) {
  285|       |          T out;
  286|       |          out.resize(v->size());
  287|       |          std::memcpy(out.data(), v->data(), v->size());
  288|       |          return out;
  289|       |        }
  290|       |      }
  291|       |
  292|       |      auto elems = Subs();
  293|       |      if (!elems) return std::nullopt;
  294|       |
  295|       |      T out;
  296|       |      for (const auto& elem : *elems) {
  297|       |        if (auto inner = elem.ToCorpus<typename T::value_type>()) {
  298|       |          out.insert(out.end(), *std::move(inner));
  299|       |        } else {
  300|       |          return std::nullopt;
  301|       |        }
  302|       |      }
  303|       |      return out;
  304|       |    } else {
  305|       |      // Must be a tuple like object.
  306|       |      auto elems = Subs();
  307|       |      if (!elems || elems->size() != std::tuple_size_v<T>) return std::nullopt;
  308|       |      auto it = elems->begin();
  309|       |      auto parts = ApplyIndex<std::tuple_size_v<T>>([&](auto... I) {
  310|       |        return std::tuple{it++->ToCorpus<std::tuple_element_t<I, T>>()...};
  311|       |      });
  312|       |      return std::apply(
  313|       |          [&](auto&... part) -> std::optional<T> {
  314|       |            if ((!part || ...)) return std::nullopt;
  315|       |            return T{*std::move(part)...};
  316|       |          },
  317|       |          parts);
  318|       |    }
  319|  1.15k|  }
_ZNK8fuzztest8internal6no_adl8IRObject9GetScalarINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEDav:
   99|  1.15k|  auto GetScalar() const {
  100|       |    if constexpr (std::is_enum_v<T>) {
  101|       |      auto inner = GetScalar<std::underlying_type_t<T>>();
  102|       |      return inner ? std::optional(static_cast<T>(*inner)) : std::nullopt;
  103|       |    } else if constexpr (std::is_integral_v<T>) {
  104|       |      const uint64_t* i = std::get_if<uint64_t>(&value_);
  105|       |      return i != nullptr ? std::optional(static_cast<T>(*i)) : std::nullopt;
  106|       |    } else if constexpr (std::is_same_v<float, T> ||
  107|       |                         std::is_same_v<double, T>) {
  108|       |      const double* i = std::get_if<double>(&value_);
  109|       |      return i != nullptr ? std::optional(static_cast<T>(*i)) : std::nullopt;
  110|  1.15k|    } else if constexpr (std::is_same_v<std::string, T>) {
  111|  1.15k|      std::optional<absl::string_view> out;
  112|  1.15k|      if (const auto* s = std::get_if<std::string>(&value_)) {
  ------------------
  |  Branch (112:23): [True: 1.13k, False: 17]
  ------------------
  113|  1.13k|        out = *s;
  114|  1.13k|      }
  115|  1.15k|      return out;
  116|  1.15k|    }
  117|  1.15k|  }
_ZZNK8fuzztest8internal6no_adl8IRObject8ToCorpusINSt3__15tupleIJNS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEEEENS4_8optionalIT_EEvENKUlDpRT_E_clIJNSD_ISB_EEEEENSD_ISC_EESI_:
  313|  1.15k|          [&](auto&... part) -> std::optional<T> {
  314|  1.15k|            if ((!part || ...)) return std::nullopt;
  ------------------
  |  Branch (314:18): [True: 17, False: 1.13k]
  ------------------
  315|  1.13k|            return T{*std::move(part)...};
  316|  1.15k|          },
_ZN8fuzztest8internal6no_adl8IRObjectC2Ev:
   75|  46.3k|  IRObject() = default;
_ZN8fuzztest8internal6no_adl8IRObject11MutableSubsEv:
  167|  4.92k|  std::vector<IRObject>& MutableSubs() {
  168|  4.92k|    if (!std::holds_alternative<std::vector<IRObject>>(value_)) {
  ------------------
  |  Branch (168:9): [True: 4.92k, False: 0]
  ------------------
  169|  4.92k|      value_.emplace<std::vector<IRObject>>();
  170|  4.92k|    }
  171|  4.92k|    return std::get<std::vector<IRObject>>(value_);
  172|  4.92k|  }
_ZN8fuzztest8internal6no_adl8IRObject13MutableScalarImEERDav:
  141|  11.4k|  auto& MutableScalar() {
  142|       |    if constexpr (is_monostate_v<T>) {
  143|       |      static_assert(always_false<T>, "Invalid type");
  144|       |    }
  145|  11.4k|    if (!std::holds_alternative<T>(value_)) {
  ------------------
  |  Branch (145:9): [True: 11.4k, False: 0]
  ------------------
  146|  11.4k|      value_.emplace<T>();
  147|  11.4k|    }
  148|  11.4k|    return std::get<T>(value_);
  149|  11.4k|  }
_ZN8fuzztest8internal6no_adl8IRObject13MutableScalarIdEERDav:
  141|  25.1k|  auto& MutableScalar() {
  142|       |    if constexpr (is_monostate_v<T>) {
  143|       |      static_assert(always_false<T>, "Invalid type");
  144|       |    }
  145|  25.1k|    if (!std::holds_alternative<T>(value_)) {
  ------------------
  |  Branch (145:9): [True: 25.1k, False: 0]
  ------------------
  146|  25.1k|      value_.emplace<T>();
  147|  25.1k|    }
  148|  25.1k|    return std::get<T>(value_);
  149|  25.1k|  }
_ZN8fuzztest8internal6no_adl8IRObject13MutableScalarINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEERDav:
  141|  1.51k|  auto& MutableScalar() {
  142|       |    if constexpr (is_monostate_v<T>) {
  143|       |      static_assert(always_false<T>, "Invalid type");
  144|       |    }
  145|  1.51k|    if (!std::holds_alternative<T>(value_)) {
  ------------------
  |  Branch (145:9): [True: 1.51k, False: 0]
  ------------------
  146|  1.51k|      value_.emplace<T>();
  147|  1.51k|    }
  148|  1.51k|    return std::get<T>(value_);
  149|  1.51k|  }

_Z6PrefixRKN4absl12lts_202605266StatusENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEE:
   17|  1.13k|absl::Status Prefix(const absl::Status& status, absl::string_view prefix) {
   18|  1.13k|  if (status.ok() || prefix.empty()) return status;
  ------------------
  |  Branch (18:7): [True: 1.13k, False: 0]
  |  Branch (18:22): [True: 0, False: 0]
  ------------------
   19|      0|  return SetMessage(status, absl::StrCat(prefix, " >> ", status.message()));
   20|  1.13k|}

_ZN7testing7MessagelsIKcEERS0_RKPT_:
  181|     44|  inline Message& operator<<(T* const& pointer) {  // NOLINT
  182|     44|    if (pointer == nullptr) {
  ------------------
  |  Branch (182:9): [True: 0, False: 44]
  ------------------
  183|      0|      *ss_ << "(null)";
  184|     44|    } else {
  185|     44|      *ss_ << pointer;
  186|     44|    }
  187|     44|    return *this;
  188|     44|  }
_ZN7testing8internal18StreamableToStringIiEENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKT_:
  242|      6|std::string StreamableToString(const T& streamable) {
  243|      6|  return (Message() << streamable).GetString();
  244|      6|}
_ZN7testing7MessagelsIiEERS0_RKT_:
  132|      6|  inline Message& operator<<(const T& val) {
  133|       |        // Some libraries overload << for STL containers.  These
  134|       |    // overloads are defined in the global namespace instead of ::std.
  135|       |    //
  136|       |    // C++'s symbol lookup rule (i.e. Koenig lookup) says that these
  137|       |    // overloads are visible in either the std namespace or the global
  138|       |    // namespace, but not other namespaces, including the testing
  139|       |    // namespace which Google Test's Message class is in.
  140|       |    //
  141|       |    // To allow STL containers (and other types that has a << operator
  142|       |    // defined in the global namespace) to be used in Google Test
  143|       |    // assertions, testing::Message must access the custom << operator
  144|       |    // from the global namespace.  With this using declaration,
  145|       |    // overloads of << defined in the global namespace and those
  146|       |    // visible via Koenig lookup are both exposed in this function.
  147|      6|    using ::operator<<;
  148|      6|    *ss_ << val;
  149|      6|    return *this;
  150|      6|  }
_ZN7testing7MessagelsIA7_cEERS0_RKT_:
  132|     44|  inline Message& operator<<(const T& val) {
  133|       |        // Some libraries overload << for STL containers.  These
  134|       |    // overloads are defined in the global namespace instead of ::std.
  135|       |    //
  136|       |    // C++'s symbol lookup rule (i.e. Koenig lookup) says that these
  137|       |    // overloads are visible in either the std namespace or the global
  138|       |    // namespace, but not other namespaces, including the testing
  139|       |    // namespace which Google Test's Message class is in.
  140|       |    //
  141|       |    // To allow STL containers (and other types that has a << operator
  142|       |    // defined in the global namespace) to be used in Google Test
  143|       |    // assertions, testing::Message must access the custom << operator
  144|       |    // from the global namespace.  With this using declaration,
  145|       |    // overloads of << defined in the global namespace and those
  146|       |    // visible via Koenig lookup are both exposed in this function.
  147|     44|    using ::operator<<;
  148|     44|    *ss_ << val;
  149|     44|    return *this;
  150|     44|  }
_ZN7testing7MessagelsIcEERS0_RKT_:
  132|    884|  inline Message& operator<<(const T& val) {
  133|       |        // Some libraries overload << for STL containers.  These
  134|       |    // overloads are defined in the global namespace instead of ::std.
  135|       |    //
  136|       |    // C++'s symbol lookup rule (i.e. Koenig lookup) says that these
  137|       |    // overloads are visible in either the std namespace or the global
  138|       |    // namespace, but not other namespaces, including the testing
  139|       |    // namespace which Google Test's Message class is in.
  140|       |    //
  141|       |    // To allow STL containers (and other types that has a << operator
  142|       |    // defined in the global namespace) to be used in Google Test
  143|       |    // assertions, testing::Message must access the custom << operator
  144|       |    // from the global namespace.  With this using declaration,
  145|       |    // overloads of << defined in the global namespace and those
  146|       |    // visible via Koenig lookup are both exposed in this function.
  147|    884|    using ::operator<<;
  148|    884|    *ss_ << val;
  149|    884|    return *this;
  150|    884|  }
_ZN7testing8internal18StreamableToStringIPcEENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERKT_:
  242|     28|std::string StreamableToString(const T& streamable) {
  243|     28|  return (Message() << streamable).GetString();
  244|     28|}
_ZN7testing7MessagelsIcEERS0_RKPT_:
  181|     28|  inline Message& operator<<(T* const& pointer) {  // NOLINT
  182|     28|    if (pointer == nullptr) {
  ------------------
  |  Branch (182:9): [True: 0, False: 28]
  ------------------
  183|      0|      *ss_ << "(null)";
  184|     28|    } else {
  185|     28|      *ss_ << pointer;
  186|     28|    }
  187|     28|    return *this;
  188|     28|  }

_ZNK7testing8TestInfo15test_suite_nameEv:
  540|      2|  const char* test_suite_name() const { return test_suite_name_.c_str(); }
_ZNK7testing8TestInfo4nameEv:
  548|      6|  const char* name() const { return name_.c_str(); }
_ZN7testing8UnitTest4implEv:
 1280|     48|  internal::UnitTestImpl* impl() { return impl_; }
_ZNK7testing12TestProperty3keyEv:
  378|      4|  const char* key() const { return key_.c_str(); }
_ZNK7testing9TestSuite14test_info_listEv:
  761|      2|  const std::vector<TestInfo*>& test_info_list() const {
  762|      2|    return test_info_list_;
  763|      2|  }
_ZN7testing10TestResult19set_start_timestampEl:
  467|      2|  void set_start_timestamp(TimeInMillis start) { start_timestamp_ = start; }
_ZN7testing9TestSuite13ShouldRunTestEPKNS_8TestInfoE:
  838|      4|  static bool ShouldRunTest(const TestInfo* test_info) {
  839|      4|    return test_info->should_run();
  840|      4|  }
_ZN7testing9TestSuite17RunSetUpTestSuiteEv:
  792|      2|  void RunSetUpTestSuite() {
  793|      2|    if (set_up_tc_ != nullptr) {
  ------------------
  |  Branch (793:9): [True: 0, False: 2]
  ------------------
  794|      0|      (*set_up_tc_)();
  795|      0|    }
  796|      2|  }
_ZNK7testing9TestSuite18ad_hoc_test_resultEv:
  751|      4|  const TestResult& ad_hoc_test_result() const { return ad_hoc_test_result_; }
_ZN7testing8TestInfo15ClearTestResultEPS0_:
  638|      2|  static void ClearTestResult(TestInfo* test_info) {
  639|      2|    test_info->result_.Clear();
  640|      2|  }
_ZNK7testing9TestSuite4nameEv:
  694|      2|  const char* name() const { return name_.c_str(); }
_ZNK7testing9TestSuite10type_paramEv:
  698|      2|  const char* type_param() const {
  699|      2|    if (type_param_ != nullptr) return type_param_->c_str();
  ------------------
  |  Branch (699:9): [True: 0, False: 2]
  ------------------
  700|      2|    return nullptr;
  701|      2|  }
_ZNK7testing9TestSuite10should_runEv:
  704|      4|  bool should_run() const { return should_run_; }
_ZNK7testing8TestInfo10should_runEv:
  589|      4|  bool should_run() const { return should_run_; }
_ZNK7testing8TestInfo10type_paramEv:
  552|      2|  const char* type_param() const {
  553|      2|    if (type_param_ != nullptr) return type_param_->c_str();
  ------------------
  |  Branch (553:9): [True: 0, False: 2]
  ------------------
  554|      2|    return nullptr;
  555|      2|  }
_ZNK7testing8UnitTest4implEv:
 1281|     14|  const internal::UnitTestImpl* impl() const { return impl_; }
_ZN7testing12TestPropertyC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_:
  375|      2|      : key_(a_key), value_(a_value) {}
_ZN7testing9TestSuite20ClearTestSuiteResultEPS0_:
  780|      2|  static void ClearTestSuiteResult(TestSuite* test_suite) {
  781|      2|    test_suite->ClearResult();
  782|      2|  }
_ZN7testing9TestSuite14set_should_runEb:
  770|      4|  void set_should_run(bool should) { should_run_ = should; }
_ZN7testing9TestSuite14test_info_listEv:
  758|      2|  std::vector<TestInfo*>& test_info_list() { return test_info_list_; }
_ZN7testing17TestEventListener16OnTestSuiteStartERKNS_9TestSuiteE:
  945|      2|  virtual void OnTestSuiteStart(const TestSuite& /*test_suite*/) {}

_ZN7testing8internal8FilePathC2ENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
   76|      2|  explicit FilePath(std::string pathname) : pathname_(std::move(pathname)) {
   77|      2|    Normalize();
   78|      2|  }
_ZNK7testing8internal8FilePath7IsEmptyEv:
  124|      4|  bool IsEmpty() const { return pathname_.empty(); }
_ZN7testing8internal8FilePathC2Ev:
   72|      2|  FilePath() : pathname_("") {}
_ZN7testing8internal8FilePathaSEOS1_:
   84|      2|  FilePath& operator=(FilePath&& rhs) noexcept {
   85|      2|    pathname_ = std::move(rhs.pathname_);
   86|      2|    return *this;
   87|      2|  }

_ZN7testing8internal6RandomC2Ej:
  845|      2|  explicit Random(uint32_t seed) : state_(seed) {}
_ZN7testing8internal9GetTypeIdINS_4TestEEEPKvv:
  410|      2|TypeId GetTypeId() {
  411|       |  // The compiler is required to allocate a different
  412|       |  // TypeIdHelper<T>::dummy_ variable for each T used to instantiate
  413|       |  // the template.  Therefore, the address of dummy_ is guaranteed to
  414|       |  // be unique.
  415|      2|  return &(TypeIdHelper<T>::dummy_);
  416|      2|}

_ZN7testing8internal30ParameterizedTestSuiteRegistry13RegisterTestsEv:
  734|      2|  void RegisterTests() {
  735|      2|    for (auto& test_suite_info : test_suite_infos_) {
  ------------------
  |  Branch (735:32): [True: 0, False: 2]
  ------------------
  736|      0|      test_suite_info->RegisterTests();
  737|      0|    }
  738|      2|  }
_ZN7testing8internal30ParameterizedTestSuiteRegistryC2Ev:
  693|      2|  ParameterizedTestSuiteRegistry() = default;

_ZN7testing8internal7ToUpperEc:
 1979|    884|inline char ToUpper(char ch) {
 1980|    884|  return static_cast<char>(toupper(static_cast<unsigned char>(ch)));
 1981|    884|}
_ZN7testing8internal5posix6GetEnvEPKc:
 2138|     64|inline const char* GetEnv(const char* name) {
 2139|       |#if defined(GTEST_OS_WINDOWS_MOBILE) || defined(GTEST_OS_WINDOWS_PHONE) || \
 2140|       |    defined(GTEST_OS_ESP8266) || defined(GTEST_OS_XTENSA) ||               \
 2141|       |    defined(GTEST_OS_QURT)
 2142|       |  // We are on an embedded platform, which has no environment variables.
 2143|       |  static_cast<void>(name);  // To prevent 'unused argument' warning.
 2144|       |  return nullptr;
 2145|       |#elif defined(__BORLANDC__) || defined(__SunOS_5_8) || defined(__SunOS_5_9)
 2146|       |  // Environment variables which we programmatically clear will be set to the
 2147|       |  // empty string rather than unset (NULL).  Handle that case.
 2148|       |  const char* const env = getenv(name);
 2149|       |  return (env != nullptr && env[0] != '\0') ? env : nullptr;
 2150|       |#else
 2151|     64|  return getenv(name);
 2152|     64|#endif
 2153|     64|}
_ZN7testing8internal14GTestMutexLockC2EPNS0_9MutexBaseE:
 1732|      6|  explicit GTestMutexLock(MutexBase* mutex) : mutex_(mutex) { mutex_->Lock(); }
_ZN7testing8internal9MutexBase4LockEv:
 1657|      6|  void Lock() {
 1658|      6|    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_lock(&mutex_));
  ------------------
  |  | 1100|      6|  if (const int gtest_error = (posix_call))    \
  |  |  ------------------
  |  |  |  Branch (1100:17): [True: 0, False: 6]
  |  |  ------------------
  |  | 1101|      6|  GTEST_LOG_(FATAL) << #posix_call << "failed with error " << gtest_error
  |  |  ------------------
  |  |  |  | 1062|      0|  ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \
  |  |  |  | 1063|      0|                                __FILE__, __LINE__)                    \
  |  |  |  | 1064|      0|      .GetStream()
  |  |  ------------------
  ------------------
 1659|      6|    owner_ = pthread_self();
 1660|      6|    has_owner_ = true;
 1661|      6|  }
_ZN7testing8internal14GTestMutexLockD2Ev:
 1734|      6|  ~GTestMutexLock() { mutex_->Unlock(); }
_ZN7testing8internal9MutexBase6UnlockEv:
 1664|      6|  void Unlock() {
 1665|       |    // Since the lock is being released the owner_ field should no longer be
 1666|       |    // considered valid. We don't protect writing to has_owner_ here, as it's
 1667|       |    // the caller's responsibility to ensure that the current thread holds the
 1668|       |    // mutex when this is called.
 1669|      6|    has_owner_ = false;
 1670|      6|    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_unlock(&mutex_));
  ------------------
  |  | 1100|      6|  if (const int gtest_error = (posix_call))    \
  |  |  ------------------
  |  |  |  Branch (1100:17): [True: 0, False: 6]
  |  |  ------------------
  |  | 1101|      6|  GTEST_LOG_(FATAL) << #posix_call << "failed with error " << gtest_error
  |  |  ------------------
  |  |  |  | 1062|      0|  ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \
  |  |  |  | 1063|      0|                                __FILE__, __LINE__)                    \
  |  |  |  | 1064|      0|      .GetStream()
  |  |  ------------------
  ------------------
 1671|      6|  }
_ZN7testing8internal5posix10StrCaseCmpEPKcS3_:
 2074|      2|inline int StrCaseCmp(const char* s1, const char* s2) {
 2075|      2|  return strcasecmp(s1, s2);
 2076|      2|}
_ZN7testing8internal5MutexC2Ev:
 1714|     10|  Mutex() {
 1715|     10|    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, nullptr));
  ------------------
  |  | 1100|     10|  if (const int gtest_error = (posix_call))    \
  |  |  ------------------
  |  |  |  Branch (1100:17): [True: 0, False: 10]
  |  |  ------------------
  |  | 1101|     10|  GTEST_LOG_(FATAL) << #posix_call << "failed with error " << gtest_error
  |  |  ------------------
  |  |  |  | 1062|      0|  ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \
  |  |  |  | 1063|      0|                                __FILE__, __LINE__)                    \
  |  |  |  | 1064|      0|      .GetStream()
  |  |  ------------------
  ------------------
 1716|     10|    has_owner_ = false;
 1717|     10|  }
_ZN7testing8internal5posix6IsATTYEi:
 2080|      2|inline int IsATTY(int fd) {
 2081|       |  // DoIsATTY might change errno (for example ENOTTY in case you redirect stdout
 2082|       |  // to a file on Linux), which is unexpected, so save the previous value, and
 2083|       |  // restore it after the call.
 2084|      2|  int savedErrno = errno;
 2085|      2|  int isAttyValue = DoIsATTY(fd);
 2086|      2|  errno = savedErrno;
 2087|       |
 2088|      2|  return isAttyValue;
 2089|      2|}
_ZN7testing8internal5posix8DoIsATTYEi:
 2073|      2|inline int DoIsATTY(int fd) { return isatty(fd); }
_ZN7testing8internal5posix6FileNoEP8_IO_FILE:
 2035|      2|inline int FileNo(FILE* file) { return fileno(file); }
_ZN7testing8internal11ThreadLocalIPNS_31TestPartResultReporterInterfaceEEC2ERKS3_:
 1769|      2|      : key_(CreateKey()),
 1770|      2|        default_factory_(new InstanceValueHolderFactory(value)) {}
_ZN7testing8internal11ThreadLocalIPNS_31TestPartResultReporterInterfaceEE9CreateKeyEv:
 1801|      2|  static pthread_key_t CreateKey() {
 1802|      2|    pthread_key_t key;
 1803|       |    // When a thread exits, DeleteThreadLocalValue() will be called on
 1804|       |    // the object managed for that thread.
 1805|      2|    GTEST_CHECK_POSIX_SUCCESS_(
  ------------------
  |  | 1100|      2|  if (const int gtest_error = (posix_call))    \
  |  |  ------------------
  |  |  |  Branch (1100:17): [True: 0, False: 2]
  |  |  ------------------
  |  | 1101|      2|  GTEST_LOG_(FATAL) << #posix_call << "failed with error " << gtest_error
  |  |  ------------------
  |  |  |  | 1062|      0|  ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \
  |  |  |  | 1063|      0|                                __FILE__, __LINE__)                    \
  |  |  |  | 1064|      0|      .GetStream()
  |  |  ------------------
  ------------------
 1806|      2|        pthread_key_create(&key, &DeleteThreadLocalValue));
 1807|      2|    return key;
 1808|      2|  }
_ZN7testing8internal11ThreadLocalIPNS_31TestPartResultReporterInterfaceEE26InstanceValueHolderFactoryC2ERKS3_:
 1847|      2|    explicit InstanceValueHolderFactory(const T& value) : value_(value) {}
_ZN7testing8internal11ThreadLocalIPNS_31TestPartResultReporterInterfaceEE18ValueHolderFactoryC2Ev:
 1825|      2|    ValueHolderFactory() = default;
_ZN7testing8internal11ThreadLocalINSt3__16vectorINS0_9TraceInfoENS2_9allocatorIS4_EEEEEC2Ev:
 1767|      2|      : key_(CreateKey()), default_factory_(new DefaultValueHolderFactory()) {}
_ZN7testing8internal11ThreadLocalINSt3__16vectorINS0_9TraceInfoENS2_9allocatorIS4_EEEEE9CreateKeyEv:
 1801|      2|  static pthread_key_t CreateKey() {
 1802|      2|    pthread_key_t key;
 1803|       |    // When a thread exits, DeleteThreadLocalValue() will be called on
 1804|       |    // the object managed for that thread.
 1805|      2|    GTEST_CHECK_POSIX_SUCCESS_(
  ------------------
  |  | 1100|      2|  if (const int gtest_error = (posix_call))    \
  |  |  ------------------
  |  |  |  Branch (1100:17): [True: 0, False: 2]
  |  |  ------------------
  |  | 1101|      2|  GTEST_LOG_(FATAL) << #posix_call << "failed with error " << gtest_error
  |  |  ------------------
  |  |  |  | 1062|      0|  ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \
  |  |  |  | 1063|      0|                                __FILE__, __LINE__)                    \
  |  |  |  | 1064|      0|      .GetStream()
  |  |  ------------------
  ------------------
 1806|      2|        pthread_key_create(&key, &DeleteThreadLocalValue));
 1807|      2|    return key;
 1808|      2|  }
_ZN7testing8internal11ThreadLocalINSt3__16vectorINS0_9TraceInfoENS2_9allocatorIS4_EEEEE25DefaultValueHolderFactoryC2Ev:
 1836|      2|    DefaultValueHolderFactory() = default;
_ZN7testing8internal11ThreadLocalINSt3__16vectorINS0_9TraceInfoENS2_9allocatorIS4_EEEEE18ValueHolderFactoryC2Ev:
 1825|      2|    ValueHolderFactory() = default;

_ZN7testing8internal29ParseInternalRunDeathTestFlagEv:
 1533|      2|InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag() {
 1534|      2|  if (GTEST_FLAG_GET(internal_run_death_test).empty()) return nullptr;
  ------------------
  |  | 2310|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2242|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  |  Branch (1534:7): [True: 2, False: 0]
  ------------------
 1535|       |
 1536|       |  // GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we
 1537|       |  // can use it here.
 1538|      0|  int line = -1;
 1539|      0|  int index = -1;
 1540|      0|  ::std::vector< ::std::string> fields;
 1541|      0|  SplitString(GTEST_FLAG_GET(internal_run_death_test), '|', &fields);
  ------------------
  |  | 2310|      0|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2242|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
 1542|      0|  int write_fd = -1;
 1543|       |
 1544|       |#ifdef GTEST_OS_WINDOWS
 1545|       |
 1546|       |  unsigned int parent_process_id = 0;
 1547|       |  size_t write_handle_as_size_t = 0;
 1548|       |  size_t event_handle_as_size_t = 0;
 1549|       |
 1550|       |  if (fields.size() != 6 || !ParseNaturalNumber(fields[1], &line) ||
 1551|       |      !ParseNaturalNumber(fields[2], &index) ||
 1552|       |      !ParseNaturalNumber(fields[3], &parent_process_id) ||
 1553|       |      !ParseNaturalNumber(fields[4], &write_handle_as_size_t) ||
 1554|       |      !ParseNaturalNumber(fields[5], &event_handle_as_size_t)) {
 1555|       |    DeathTestAbort("Bad --gtest_internal_run_death_test flag: " +
 1556|       |                   GTEST_FLAG_GET(internal_run_death_test));
 1557|       |  }
 1558|       |  write_fd = GetStatusFileDescriptor(parent_process_id, write_handle_as_size_t,
 1559|       |                                     event_handle_as_size_t);
 1560|       |
 1561|       |#elif defined(GTEST_OS_FUCHSIA)
 1562|       |
 1563|       |  if (fields.size() != 3 || !ParseNaturalNumber(fields[1], &line) ||
 1564|       |      !ParseNaturalNumber(fields[2], &index)) {
 1565|       |    DeathTestAbort("Bad --gtest_internal_run_death_test flag: " +
 1566|       |                   GTEST_FLAG_GET(internal_run_death_test));
 1567|       |  }
 1568|       |
 1569|       |#else
 1570|       |
 1571|      0|  if (fields.size() != 4 || !ParseNaturalNumber(fields[1], &line) ||
  ------------------
  |  Branch (1571:7): [True: 0, False: 0]
  |  Branch (1571:29): [True: 0, False: 0]
  ------------------
 1572|      0|      !ParseNaturalNumber(fields[2], &index) ||
  ------------------
  |  Branch (1572:7): [True: 0, False: 0]
  ------------------
 1573|      0|      !ParseNaturalNumber(fields[3], &write_fd)) {
  ------------------
  |  Branch (1573:7): [True: 0, False: 0]
  ------------------
 1574|      0|    DeathTestAbort("Bad --gtest_internal_run_death_test flag: " +
 1575|      0|                   GTEST_FLAG_GET(internal_run_death_test));
  ------------------
  |  | 2310|      0|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2242|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
 1576|      0|  }
 1577|       |
 1578|      0|#endif  // GTEST_OS_WINDOWS
 1579|       |
 1580|      0|  return new InternalRunDeathTestFlag(fields[0], line, index, write_fd);
 1581|      2|}

_ZN7testing8internal8FilePath13GetCurrentDirEv:
  101|      2|FilePath FilePath::GetCurrentDir() {
  102|       |#if defined(GTEST_OS_WINDOWS_MOBILE) || defined(GTEST_OS_WINDOWS_PHONE) || \
  103|       |    defined(GTEST_OS_WINDOWS_RT) || defined(GTEST_OS_ESP8266) ||           \
  104|       |    defined(GTEST_OS_ESP32) || defined(GTEST_OS_XTENSA) ||                 \
  105|       |    defined(GTEST_OS_QURT) || defined(GTEST_OS_NXP_QN9090) ||              \
  106|       |    defined(GTEST_OS_NRF52)
  107|       |  // These platforms do not have a current directory, so we just return
  108|       |  // something reasonable.
  109|       |  return FilePath(kCurrentDirectoryString);
  110|       |#elif defined(GTEST_OS_WINDOWS)
  111|       |  char cwd[GTEST_PATH_MAX_ + 1] = {'\0'};
  112|       |  return FilePath(_getcwd(cwd, sizeof(cwd)) == nullptr ? "" : cwd);
  113|       |#else
  114|      2|  char cwd[GTEST_PATH_MAX_ + 1] = {'\0'};
  115|      2|  char* result = getcwd(cwd, sizeof(cwd));
  116|       |#ifdef GTEST_OS_NACL
  117|       |  // getcwd will likely fail in NaCl due to the sandbox, so return something
  118|       |  // reasonable. The user may have provided a shim implementation for getcwd,
  119|       |  // however, so fallback only when failure is detected.
  120|       |  return FilePath(result == nullptr ? kCurrentDirectoryString : cwd);
  121|       |#endif  // GTEST_OS_NACL
  122|      2|  return FilePath(result == nullptr ? "" : cwd);
  ------------------
  |  Branch (122:19): [True: 0, False: 2]
  ------------------
  123|      2|#endif  // GTEST_OS_WINDOWS_MOBILE
  124|      2|}
_ZN7testing8internal8FilePath9NormalizeEv:
  386|      2|void FilePath::Normalize() {
  387|      2|  auto out = pathname_.begin();
  388|       |
  389|      2|  auto i = pathname_.cbegin();
  390|       |#ifdef GTEST_OS_WINDOWS
  391|       |  // UNC paths are treated specially
  392|       |  if (pathname_.end() - i >= 3 && IsPathSeparator(*i) &&
  393|       |      IsPathSeparator(*(i + 1)) && !IsPathSeparator(*(i + 2))) {
  394|       |    *(out++) = kPathSeparator;
  395|       |    *(out++) = kPathSeparator;
  396|       |  }
  397|       |#endif
  398|     82|  while (i != pathname_.end()) {
  ------------------
  |  Branch (398:10): [True: 80, False: 2]
  ------------------
  399|     80|    const char character = *i;
  400|     80|    if (!IsPathSeparator(character)) {
  ------------------
  |  Branch (400:9): [True: 74, False: 6]
  ------------------
  401|     74|      *(out++) = character;
  402|     74|    } else if (out == pathname_.begin() || *std::prev(out) != kPathSeparator) {
  ------------------
  |  Branch (402:16): [True: 2, False: 4]
  |  Branch (402:16): [True: 6, False: 0]
  |  Branch (402:44): [True: 4, False: 0]
  ------------------
  403|      6|      *(out++) = kPathSeparator;
  404|      6|    }
  405|     80|    ++i;
  406|     80|  }
  407|       |
  408|      2|  pathname_.erase(out, pathname_.end());
  409|      2|}
gtest-all.cc:_ZN7testing8internalL15IsPathSeparatorEc:
   92|     80|static bool IsPathSeparator(char c) {
   93|       |#if GTEST_HAS_ALT_PATH_SEP_
   94|       |  return (c == kPathSeparator) || (c == kAlternatePathSeparator);
   95|       |#else
   96|     80|  return c == kPathSeparator;
   97|     80|#endif
   98|     80|}

_ZN7testing8internal15GetUnitTestImplEv:
  982|     30|inline UnitTestImpl* GetUnitTestImpl() {
  983|     30|  return UnitTest::GetInstance()->impl();
  984|     30|}
_ZN7testing8internal12UnitTestImpl17current_test_infoEv:
  757|      2|  TestInfo* current_test_info() { return current_test_info_; }
_ZN7testing8internal12UnitTestImpl9listenersEv:
  609|     12|  TestEventListeners* listeners() { return &listeners_; }
_ZN7testing8internal12UnitTestImpl33ignored_parameterized_test_suitesEv:
  704|      2|  std::set<std::string>* ignored_parameterized_test_suites() {
  705|      2|    return &ignored_parameterized_test_suites_;
  706|      2|  }
_ZN7testing8internal17TestPropertyKeyIsC2ERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
  348|      2|  explicit TestPropertyKeyIs(const std::string& key) : key_(key) {}
_ZN7testing8internal14GTestFlagSaverC2Ev:
  144|      2|  GTestFlagSaver() {
  145|      2|    also_run_disabled_tests_ = GTEST_FLAG_GET(also_run_disabled_tests);
  ------------------
  |  | 2310|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2242|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  146|      2|    break_on_failure_ = GTEST_FLAG_GET(break_on_failure);
  ------------------
  |  | 2310|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2242|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  147|      2|    catch_exceptions_ = GTEST_FLAG_GET(catch_exceptions);
  ------------------
  |  | 2310|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2242|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  148|      2|    color_ = GTEST_FLAG_GET(color);
  ------------------
  |  | 2310|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2242|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  149|      2|    death_test_style_ = GTEST_FLAG_GET(death_test_style);
  ------------------
  |  | 2310|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2242|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  150|      2|    death_test_use_fork_ = GTEST_FLAG_GET(death_test_use_fork);
  ------------------
  |  | 2310|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2242|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  151|      2|    fail_fast_ = GTEST_FLAG_GET(fail_fast);
  ------------------
  |  | 2310|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2242|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  152|      2|    filter_ = GTEST_FLAG_GET(filter);
  ------------------
  |  | 2310|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2242|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  153|      2|    internal_run_death_test_ = GTEST_FLAG_GET(internal_run_death_test);
  ------------------
  |  | 2310|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2242|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  154|      2|    list_tests_ = GTEST_FLAG_GET(list_tests);
  ------------------
  |  | 2310|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2242|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  155|      2|    output_ = GTEST_FLAG_GET(output);
  ------------------
  |  | 2310|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2242|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  156|      2|    brief_ = GTEST_FLAG_GET(brief);
  ------------------
  |  | 2310|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2242|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  157|      2|    print_time_ = GTEST_FLAG_GET(print_time);
  ------------------
  |  | 2310|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2242|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  158|      2|    print_utf8_ = GTEST_FLAG_GET(print_utf8);
  ------------------
  |  | 2310|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2242|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  159|      2|    random_seed_ = GTEST_FLAG_GET(random_seed);
  ------------------
  |  | 2310|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2242|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  160|      2|    repeat_ = GTEST_FLAG_GET(repeat);
  ------------------
  |  | 2310|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2242|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  161|      2|    recreate_environments_when_repeating_ =
  162|      2|        GTEST_FLAG_GET(recreate_environments_when_repeating);
  ------------------
  |  | 2310|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2242|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  163|      2|    shuffle_ = GTEST_FLAG_GET(shuffle);
  ------------------
  |  | 2310|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2242|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  164|      2|    stack_trace_depth_ = GTEST_FLAG_GET(stack_trace_depth);
  ------------------
  |  | 2310|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2242|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  165|      2|    stream_result_to_ = GTEST_FLAG_GET(stream_result_to);
  ------------------
  |  | 2310|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2242|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  166|      2|    throw_on_failure_ = GTEST_FLAG_GET(throw_on_failure);
  ------------------
  |  | 2310|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2242|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  167|      2|  }
_ZNK7testing8internal12UnitTestImpl18current_test_suiteEv:
  756|      2|  const TestSuite* current_test_suite() const { return current_test_suite_; }
_ZN7testing8internal12UnitTestImpl11AddTestInfoEPFvvES3_PNS_8TestInfoE:
  677|      2|                   TestInfo* test_info) {
  678|      2|#if GTEST_HAS_FILE_SYSTEM
  679|       |    // In order to support thread-safe death tests, we need to
  680|       |    // remember the original working directory when the test program
  681|       |    // was first invoked.  We cannot do this in RUN_ALL_TESTS(), as
  682|       |    // the user may have changed the current directory before calling
  683|       |    // RUN_ALL_TESTS().  Therefore we capture the current directory in
  684|       |    // AddTestInfo(), which is called to register a TEST or TEST_F
  685|       |    // before main() is reached.
  686|      2|    if (original_working_dir_.IsEmpty()) {
  ------------------
  |  Branch (686:9): [True: 2, False: 0]
  ------------------
  687|      2|      original_working_dir_ = FilePath::GetCurrentDir();
  688|      4|      GTEST_CHECK_(!original_working_dir_.IsEmpty())
  ------------------
  |  | 1087|      2|  GTEST_AMBIGUOUS_ELSE_BLOCKER_               \
  |  |  ------------------
  |  |  |  |  728|      4|  switch (0)                          \
  |  |  |  |  729|      4|  case 0:                             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (729:3): [True: 2, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  730|      2|  default:  // NOLINT
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (730:3): [True: 0, False: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1088|      2|  if (::testing::internal::IsTrue(condition)) \
  |  |  ------------------
  |  |  |  Branch (1088:7): [True: 2, False: 0]
  |  |  ------------------
  |  | 1089|      2|    ;                                         \
  |  | 1090|      2|  else                                        \
  |  | 1091|      2|    GTEST_LOG_(FATAL) << "Condition " #condition " failed. "
  |  |  ------------------
  |  |  |  | 1062|      0|  ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \
  |  |  |  | 1063|      0|                                __FILE__, __LINE__)                    \
  |  |  |  | 1064|      0|      .GetStream()
  |  |  ------------------
  ------------------
  689|      4|          << "Failed to get the current working directory.";
  690|      2|    }
  691|      2|#endif  // GTEST_HAS_FILE_SYSTEM
  692|       |
  693|      2|    GetTestSuite(test_info->test_suite_name_, test_info->type_param(),
  694|      2|                 set_up_tc, tear_down_tc)
  695|      2|        ->AddTestInfo(test_info);
  696|      2|  }
_ZNK7testing8internal12UnitTestImpl12GetTestSuiteEi:
  591|      6|  const TestSuite* GetTestSuite(int i) const {
  592|      6|    const int index = GetElementOr(test_suite_indices_, i, -1);
  593|      6|    return index < 0 ? nullptr : test_suites_[static_cast<size_t>(i)];
  ------------------
  |  Branch (593:12): [True: 0, False: 6]
  ------------------
  594|      6|  }
_ZN7testing8internal12UnitTestImpl19GetMutableSuiteCaseEi:
  603|      2|  TestSuite* GetMutableSuiteCase(int i) {
  604|      2|    const int index = GetElementOr(test_suite_indices_, i, -1);
  605|      2|    return index < 0 ? nullptr : test_suites_[static_cast<size_t>(index)];
  ------------------
  |  Branch (605:12): [True: 0, False: 2]
  ------------------
  606|      2|  }
_ZN7testing8internal12UnitTestImpl22set_current_test_suiteEPNS_9TestSuiteE:
  846|      2|  void set_current_test_suite(TestSuite* a_current_test_suite) {
  847|      2|    current_test_suite_ = a_current_test_suite;
  848|      2|  }
_ZN7testing8internal12UnitTestImpl21set_current_test_infoEPNS_8TestInfoE:
  853|      2|  void set_current_test_info(TestInfo* a_current_test_info) {
  854|      2|    current_test_info_ = a_current_test_info;
  855|      2|  }
_ZN7testing8internal12UnitTestImpl20set_catch_exceptionsEb:
  843|      2|  void set_catch_exceptions(bool value) { catch_exceptions_ = value; }
_ZN7testing8internal12UnitTestImpl27parameterized_test_registryEv:
  700|      2|  internal::ParameterizedTestSuiteRegistry& parameterized_test_registry() {
  701|      2|    return parameterized_test_registry_;
  702|      2|  }
_ZN7testing8internal12UnitTestImpl34InitDeathTestSubprocessControlInfoEv:
  773|      2|  void InitDeathTestSubprocessControlInfo() {
  774|      2|    internal_run_death_test_flag_.reset(ParseInternalRunDeathTestFlag());
  775|      2|  }
_ZN7testing8internal21GetRandomSeedFromFlagEi:
  114|      2|inline int GetRandomSeedFromFlag(int32_t random_seed_flag) {
  115|      2|  const unsigned int raw_seed =
  116|      2|      (random_seed_flag == 0) ? static_cast<unsigned int>(GetTimeInMillis())
  ------------------
  |  Branch (116:7): [True: 2, False: 0]
  ------------------
  117|      2|                              : static_cast<unsigned int>(random_seed_flag);
  118|       |
  119|       |  // Normalizes the actual seed to range [1, kMaxRandomSeed] such that
  120|       |  // it's easy to type.
  121|      2|  const int normalized_seed =
  122|      2|      static_cast<int>((raw_seed - 1U) %
  123|      2|                       static_cast<unsigned int>(kMaxRandomSeed)) +
  124|      2|      1;
  125|      2|  return normalized_seed;
  126|      2|}
_ZN7testing8internal12UnitTestImpl23ClearNonAdHocTestResultEv:
  730|      2|  void ClearNonAdHocTestResult() {
  731|      2|    ForEach(test_suites_, TestSuite::ClearTestSuiteResult);
  732|      2|  }
_ZN7testing8internal18OsStackTraceGetterC2Ev:
  440|      2|  OsStackTraceGetter() = default;
_ZN7testing8internal27OsStackTraceGetterInterfaceC2Ev:
  411|      2|  OsStackTraceGetterInterface() = default;
_ZN7testing8internal12GetElementOrIiEET_RKNSt3__16vectorIS2_NS3_9allocatorIS2_EEEEiS2_:
  295|     12|inline E GetElementOr(const std::vector<E>& v, int i, E default_value) {
  296|     12|  return (i < 0 || i >= static_cast<int>(v.size())) ? default_value
  ------------------
  |  Branch (296:11): [True: 0, False: 12]
  |  Branch (296:20): [True: 0, False: 12]
  ------------------
  297|     12|                                                    : v[static_cast<size_t>(i)];
  298|     12|}
_ZN7testing8internal7ForEachINSt3__16vectorIPNS_9TestSuiteENS2_9allocatorIS5_EEEEPFvS5_EEEvRKT_T0_:
  288|      2|void ForEach(const Container& c, Functor functor) {
  289|      2|  std::for_each(c.begin(), c.end(), functor);
  290|      2|}
_ZN7testing8internal7CountIfINSt3__16vectorIPNS_9TestSuiteENS2_9allocatorIS5_EEEEPFbPKS4_EEEiRKT_T0_:
  276|      2|inline int CountIf(const Container& c, Predicate predicate) {
  277|       |  // Implemented as an explicit loop since std::count_if() in libCstd on
  278|       |  // Solaris has a non-standard signature.
  279|      2|  int count = 0;
  280|      4|  for (auto it = c.begin(); it != c.end(); ++it) {
  ------------------
  |  Branch (280:29): [True: 2, False: 2]
  ------------------
  281|      2|    if (predicate(*it)) ++count;
  ------------------
  |  Branch (281:9): [True: 2, False: 0]
  ------------------
  282|      2|  }
  283|      2|  return count;
  284|      2|}
_ZN7testing8internal7CountIfINSt3__16vectorINS_14TestPartResultENS2_9allocatorIS4_EEEEPFbRKS4_EEEiRKT_T0_:
  276|     14|inline int CountIf(const Container& c, Predicate predicate) {
  277|       |  // Implemented as an explicit loop since std::count_if() in libCstd on
  278|       |  // Solaris has a non-standard signature.
  279|     14|  int count = 0;
  280|     14|  for (auto it = c.begin(); it != c.end(); ++it) {
  ------------------
  |  Branch (280:29): [True: 0, False: 14]
  ------------------
  281|      0|    if (predicate(*it)) ++count;
  ------------------
  |  Branch (281:9): [True: 0, False: 0]
  ------------------
  282|      0|  }
  283|     14|  return count;
  284|     14|}
_ZNK7testing8internal12UnitTestImpl16catch_exceptionsEv:
  826|     10|  bool catch_exceptions() const { return catch_exceptions_; }
_ZN7testing8internal7CountIfINSt3__16vectorIPNS_8TestInfoENS2_9allocatorIS5_EEEEPFbPKS4_EEEiRKT_T0_:
  276|      4|inline int CountIf(const Container& c, Predicate predicate) {
  277|       |  // Implemented as an explicit loop since std::count_if() in libCstd on
  278|       |  // Solaris has a non-standard signature.
  279|      4|  int count = 0;
  280|      8|  for (auto it = c.begin(); it != c.end(); ++it) {
  ------------------
  |  Branch (280:29): [True: 4, False: 4]
  ------------------
  281|      4|    if (predicate(*it)) ++count;
  ------------------
  |  Branch (281:9): [True: 4, False: 0]
  ------------------
  282|      4|  }
  283|      4|  return count;
  284|      4|}
_ZN7testing8internal7ForEachINSt3__16vectorIPNS_8TestInfoENS2_9allocatorIS5_EEEEPFvS5_EEEvRKT_T0_:
  288|      2|void ForEach(const Container& c, Functor functor) {
  289|      2|  std::for_each(c.begin(), c.end(), functor);
  290|      2|}
_ZN7testing8internal7ForEachINSt3__16vectorIPNS_11EnvironmentENS2_9allocatorIS5_EEEEPFvS5_EEEvRKT_T0_:
  288|      2|void ForEach(const Container& c, Functor functor) {
  289|      2|  std::for_each(c.begin(), c.end(), functor);
  290|      2|}

_ZN7testing8internal16BoolFromGTestEnvEPKcb:
 1366|     26|bool BoolFromGTestEnv(const char* flag, bool default_value) {
 1367|       |#if defined(GTEST_GET_BOOL_FROM_ENV_)
 1368|       |  return GTEST_GET_BOOL_FROM_ENV_(flag, default_value);
 1369|       |#else
 1370|     26|  const std::string env_var = FlagToEnvVar(flag);
 1371|     26|  const char* const string_value = posix::GetEnv(env_var.c_str());
 1372|     26|  return string_value == nullptr ? default_value
  ------------------
  |  Branch (1372:10): [True: 26, False: 0]
  ------------------
 1373|     26|                                 : strcmp(string_value, "0") != 0;
 1374|     26|#endif  // defined(GTEST_GET_BOOL_FROM_ENV_)
 1375|     26|}
_ZN7testing8internal17Int32FromGTestEnvEPKci:
 1380|      6|int32_t Int32FromGTestEnv(const char* flag, int32_t default_value) {
 1381|       |#if defined(GTEST_GET_INT32_FROM_ENV_)
 1382|       |  return GTEST_GET_INT32_FROM_ENV_(flag, default_value);
 1383|       |#else
 1384|      6|  const std::string env_var = FlagToEnvVar(flag);
 1385|      6|  const char* const string_value = posix::GetEnv(env_var.c_str());
 1386|      6|  if (string_value == nullptr) {
  ------------------
  |  Branch (1386:7): [True: 6, False: 0]
  ------------------
 1387|       |    // The environment variable is not set.
 1388|      6|    return default_value;
 1389|      6|  }
 1390|       |
 1391|      0|  int32_t result = default_value;
 1392|      0|  if (!ParseInt32(Message() << "Environment variable " << env_var, string_value,
  ------------------
  |  Branch (1392:7): [True: 0, False: 0]
  ------------------
 1393|      0|                  &result)) {
 1394|      0|    printf("The default value %s is used.\n",
 1395|      0|           (Message() << default_value).GetString().c_str());
 1396|      0|    fflush(stdout);
 1397|      0|    return default_value;
 1398|      0|  }
 1399|       |
 1400|      0|  return result;
 1401|      0|#endif  // defined(GTEST_GET_INT32_FROM_ENV_)
 1402|      0|}
_ZN7testing8internal25OutputFlagAlsoCheckEnvVarEv:
 1412|      2|std::string OutputFlagAlsoCheckEnvVar() {
 1413|      2|  std::string default_value_for_output_flag = "";
 1414|      2|  const char* xml_output_file_env = posix::GetEnv("XML_OUTPUT_FILE");
 1415|      2|  if (nullptr != xml_output_file_env) {
  ------------------
  |  Branch (1415:7): [True: 0, False: 2]
  ------------------
 1416|      0|    default_value_for_output_flag = std::string("xml:") + xml_output_file_env;
 1417|      0|  }
 1418|      2|  return default_value_for_output_flag;
 1419|      2|}
_ZN7testing8internal18StringFromGTestEnvEPKcS2_:
 1423|     12|const char* StringFromGTestEnv(const char* flag, const char* default_value) {
 1424|       |#if defined(GTEST_GET_STRING_FROM_ENV_)
 1425|       |  return GTEST_GET_STRING_FROM_ENV_(flag, default_value);
 1426|       |#else
 1427|     12|  const std::string env_var = FlagToEnvVar(flag);
 1428|     12|  const char* const value = posix::GetEnv(env_var.c_str());
 1429|     12|  return value == nullptr ? default_value : value;
  ------------------
  |  Branch (1429:10): [True: 12, False: 0]
  ------------------
 1430|     12|#endif  // defined(GTEST_GET_STRING_FROM_ENV_)
 1431|     12|}
gtest-all.cc:_ZN7testing8internalL12FlagToEnvVarEPKc:
 1309|     44|static std::string FlagToEnvVar(const char* flag) {
 1310|     44|  const std::string full_flag =
 1311|     44|      (Message() << GTEST_FLAG_PREFIX_ << flag).GetString();
  ------------------
  |  |  346|     44|#define GTEST_FLAG_PREFIX_ "gtest_"
  ------------------
 1312|       |
 1313|     44|  Message env_var;
 1314|    928|  for (size_t i = 0; i != full_flag.length(); i++) {
  ------------------
  |  Branch (1314:22): [True: 884, False: 44]
  ------------------
 1315|    884|    env_var << ToUpper(full_flag.c_str()[i]);
 1316|    884|  }
 1317|       |
 1318|     44|  return env_var.GetString();
 1319|     44|}

_ZN7testing8internal33GetIgnoredParameterizedTestSuitesEv:
  533|      2|std::set<std::string>* GetIgnoredParameterizedTestSuites() {
  534|      2|  return UnitTest::GetInstance()->impl()->ignored_parameterized_test_suites();
  535|      2|}
_ZN7testing8internal34TypeParameterizedTestSuiteRegistry22CheckForInstantiationsEv:
  617|      2|void TypeParameterizedTestSuiteRegistry::CheckForInstantiations() {
  618|      2|  const auto& ignored = *GetIgnoredParameterizedTestSuites();
  619|      2|  for (const auto& testcase : suites_) {
  ------------------
  |  Branch (619:29): [True: 0, False: 2]
  ------------------
  620|      0|    if (testcase.second.instantiated) continue;
  ------------------
  |  Branch (620:9): [True: 0, False: 0]
  ------------------
  621|      0|    if (ignored.find(testcase.first) != ignored.end()) continue;
  ------------------
  |  Branch (621:9): [True: 0, False: 0]
  ------------------
  622|       |
  623|      0|    std::string message =
  624|      0|        "Type parameterized test suite " + testcase.first +
  625|      0|        " is defined via REGISTER_TYPED_TEST_SUITE_P, but never instantiated "
  626|      0|        "via INSTANTIATE_TYPED_TEST_SUITE_P. None of the test cases will run."
  627|      0|        "\n\n"
  628|      0|        "Ideally, TYPED_TEST_P definitions should only ever be included as "
  629|      0|        "part of binaries that intend to use them. (As opposed to, for "
  630|      0|        "example, being placed in a library that may be linked in to get "
  631|      0|        "other "
  632|      0|        "utilities.)"
  633|      0|        "\n\n"
  634|      0|        "To suppress this error for this test suite, insert the following "
  635|      0|        "line "
  636|      0|        "(in a non-header) in the namespace it is defined in:"
  637|      0|        "\n\n"
  638|      0|        "GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(" +
  639|      0|        testcase.first + ");";
  640|       |
  641|      0|    std::string full_name =
  642|      0|        "UninstantiatedTypeParameterizedTestSuite<" + testcase.first + ">";
  643|      0|    RegisterTest(  //
  644|      0|        "GoogleTestVerification", full_name.c_str(),
  645|      0|        nullptr,  // No type parameter.
  646|      0|        nullptr,  // No value parameter.
  647|      0|        testcase.second.code_location.file.c_str(),
  648|      0|        testcase.second.code_location.line, [message, testcase] {
  649|      0|          return new FailureTest(testcase.second.code_location, message,
  650|      0|                                 kErrorOnUninstantiatedTypeParameterizedTest);
  651|      0|        });
  652|      0|  }
  653|      2|}
_ZN7testing8internal8GetArgvsEv:
  658|      4|::std::vector<std::string> GetArgvs() {
  659|       |#if defined(GTEST_CUSTOM_GET_ARGVS_)
  660|       |  // GTEST_CUSTOM_GET_ARGVS_() may return a container of std::string or
  661|       |  // ::string. This code converts it to the appropriate type.
  662|       |  const auto& custom = GTEST_CUSTOM_GET_ARGVS_();
  663|       |  return ::std::vector<std::string>(custom.begin(), custom.end());
  664|       |#else   // defined(GTEST_CUSTOM_GET_ARGVS_)
  665|      4|  return g_argvs;
  666|      4|#endif  // defined(GTEST_CUSTOM_GET_ARGVS_)
  667|      4|}
_ZN7testing8internal15UnitTestOptions15GetOutputFormatEv:
  691|      2|std::string UnitTestOptions::GetOutputFormat() {
  692|      2|  std::string s = GTEST_FLAG_GET(output);
  ------------------
  |  | 2310|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2242|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  693|      2|  const char* const gtest_output_flag = s.c_str();
  694|      2|  const char* const colon = strchr(gtest_output_flag, ':');
  695|      2|  return (colon == nullptr)
  ------------------
  |  Branch (695:10): [True: 2, False: 0]
  ------------------
  696|      2|             ? std::string(gtest_output_flag)
  697|      2|             : std::string(gtest_output_flag,
  698|      0|                           static_cast<size_t>(colon - gtest_output_flag));
  699|      2|}
_ZN7testing8internal13GetTestTypeIdEv:
  999|      2|TypeId GetTestTypeId() { return GetTypeId<Test>(); }
_ZN7testing8internal35DefaultGlobalTestPartResultReporterC2EPNS0_12UnitTestImplE:
 1062|      2|    : unit_test_(unit_test) {}
_ZN7testing8internal38DefaultPerThreadTestPartResultReporterC2EPNS0_12UnitTestImplE:
 1072|      2|    : unit_test_(unit_test) {}
_ZNK7testing8internal12UnitTestImpl22total_test_suite_countEv:
 1116|      6|int UnitTestImpl::total_test_suite_count() const {
 1117|      6|  return static_cast<int>(test_suites_.size());
 1118|      6|}
_ZNK7testing8internal12UnitTestImpl23test_suite_to_run_countEv:
 1122|      2|int UnitTestImpl::test_suite_to_run_count() const {
 1123|      2|  return CountIf(test_suites_, ShouldRunTestSuite);
 1124|      2|}
_ZNK7testing8internal12UnitTestImpl16total_test_countEv:
 1158|      2|int UnitTestImpl::total_test_count() const {
 1159|      2|  return SumOverTestSuiteList(test_suites_, &TestSuite::total_test_count);
 1160|      2|}
_ZNK7testing8internal12UnitTestImpl17test_to_run_countEv:
 1163|      2|int UnitTestImpl::test_to_run_count() const {
 1164|      2|  return SumOverTestSuiteList(test_suites_, &TestSuite::test_to_run_count);
 1165|      2|}
_ZN7testing8internal15GetTimeInMillisEv:
 1211|      8|TimeInMillis GetTimeInMillis() {
 1212|      8|  return std::chrono::duration_cast<std::chrono::milliseconds>(
 1213|      8|             std::chrono::system_clock::now() -
 1214|      8|             std::chrono::system_clock::from_time_t(0))
 1215|      8|      .count();
 1216|      8|}
_ZN7testing8internal6String13CStringEqualsEPKcS3_:
 1261|      2|bool String::CStringEquals(const char* lhs, const char* rhs) {
 1262|      2|  if (lhs == nullptr) return rhs == nullptr;
  ------------------
  |  Branch (1262:7): [True: 0, False: 2]
  ------------------
 1263|       |
 1264|      2|  if (rhs == nullptr) return false;
  ------------------
  |  Branch (1264:7): [True: 0, False: 2]
  ------------------
 1265|       |
 1266|      2|  return strcmp(lhs, rhs) == 0;
 1267|      2|}
_ZN7testing8internal11SplitStringERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEcPNS1_6vectorIS7_NS5_IS7_EEEE:
 1289|      8|                 ::std::vector< ::std::string>* dest) {
 1290|      8|  ::std::vector< ::std::string> parsed;
 1291|      8|  ::std::string::size_type pos = 0;
 1292|     12|  while (::testing::internal::AlwaysTrue()) {
  ------------------
  |  Branch (1292:10): [True: 12, False: 0]
  ------------------
 1293|     12|    const ::std::string::size_type colon = str.find(delimiter, pos);
 1294|     12|    if (colon == ::std::string::npos) {
  ------------------
  |  Branch (1294:9): [True: 8, False: 4]
  ------------------
 1295|      8|      parsed.push_back(str.substr(pos));
 1296|      8|      break;
 1297|      8|    } else {
 1298|      4|      parsed.push_back(str.substr(pos, colon - pos));
 1299|      4|      pos = colon + 1;
 1300|      4|    }
 1301|     12|  }
 1302|      8|  dest->swap(parsed);
 1303|      8|}
_ZN7testing7MessageC2Ev:
 1312|    122|Message::Message() : ss_(new ::std::stringstream) {
 1313|       |  // By default, we want there to be enough precision when printing
 1314|       |  // a double to a Message.
 1315|    122|  *ss_ << std::setprecision(std::numeric_limits<double>::digits10 + 2);
 1316|    122|}
_ZNK7testing7Message9GetStringEv:
 1338|    122|std::string Message::GetString() const {
 1339|    122|  return internal::StringStreamToString(ss_.get());
 1340|    122|}
_ZN7testing8internal6String28CaseInsensitiveCStringEqualsEPKcS3_:
 2183|      2|bool String::CaseInsensitiveCStringEquals(const char* lhs, const char* rhs) {
 2184|      2|  if (lhs == nullptr) return rhs == nullptr;
  ------------------
  |  Branch (2184:7): [True: 0, False: 2]
  ------------------
 2185|      2|  if (rhs == nullptr) return false;
  ------------------
  |  Branch (2185:7): [True: 0, False: 2]
  ------------------
 2186|      2|  return posix::StrCaseCmp(lhs, rhs) == 0;
 2187|      2|}
_ZN7testing8internal20StringStreamToStringEPNSt3__118basic_stringstreamIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 2268|    122|std::string StringStreamToString(::std::stringstream* ss) {
 2269|    122|  const ::std::string& str = ss->str();
 2270|    122|  const char* const start = str.c_str();
 2271|    122|  const char* const end = start + str.length();
 2272|       |
 2273|    122|  std::string result;
 2274|    122|  result.reserve(static_cast<size_t>(2 * (end - start)));
 2275|  2.91k|  for (const char* ch = start; ch != end; ++ch) {
  ------------------
  |  Branch (2275:32): [True: 2.78k, False: 122]
  ------------------
 2276|  2.78k|    if (*ch == '\0') {
  ------------------
  |  Branch (2276:9): [True: 0, False: 2.78k]
  ------------------
 2277|      0|      result += "\\0";  // Replaces NUL with "\\0";
 2278|  2.78k|    } else {
 2279|  2.78k|      result += *ch;
 2280|  2.78k|    }
 2281|  2.78k|  }
 2282|       |
 2283|    122|  return result;
 2284|    122|}
_ZN7testing10TestResultC2Ev:
 2306|      6|    : death_test_count_(0), start_timestamp_(0), elapsed_time_(0) {}
_ZN7testing10TestResult14RecordPropertyERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKNS_12TestPropertyE:
 2339|      2|                                const TestProperty& test_property) {
 2340|      2|  if (!ValidateTestProperty(xml_element, test_property)) {
  ------------------
  |  Branch (2340:7): [True: 0, False: 2]
  ------------------
 2341|      0|    return;
 2342|      0|  }
 2343|      2|  internal::MutexLock lock(&test_properties_mutex_);
 2344|      2|  const std::vector<TestProperty>::iterator property_with_matching_key =
 2345|      2|      std::find_if(test_properties_.begin(), test_properties_.end(),
 2346|      2|                   internal::TestPropertyKeyIs(test_property.key()));
 2347|      2|  if (property_with_matching_key == test_properties_.end()) {
  ------------------
  |  Branch (2347:7): [True: 2, False: 0]
  ------------------
 2348|      2|    test_properties_.push_back(test_property);
 2349|      2|    return;
 2350|      2|  }
 2351|      0|  property_with_matching_key->SetValue(test_property.value());
 2352|      0|}
_ZN7testing10TestResult20ValidateTestPropertyERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKNS_12TestPropertyE:
 2446|      2|                                      const TestProperty& test_property) {
 2447|      2|  return ValidateTestPropertyName(test_property.key(),
 2448|      2|                                  GetReservedAttributesForElement(xml_element));
 2449|      2|}
_ZN7testing10TestResult5ClearEv:
 2452|      4|void TestResult::Clear() {
 2453|      4|  test_part_results_.clear();
 2454|      4|  test_properties_.clear();
 2455|      4|  death_test_count_ = 0;
 2456|      4|  elapsed_time_ = 0;
 2457|      4|}
_ZNK7testing10TestResult7SkippedEv:
 2465|      8|bool TestResult::Skipped() const {
 2466|      8|  return !Failed() && CountIf(test_part_results_, TestPartSkipped) > 0;
  ------------------
  |  Branch (2466:10): [True: 8, False: 0]
  |  Branch (2466:23): [True: 0, False: 8]
  ------------------
 2467|      8|}
_ZNK7testing10TestResult6FailedEv:
 2470|     10|bool TestResult::Failed() const {
 2471|     10|  for (int i = 0; i < total_part_count(); ++i) {
  ------------------
  |  Branch (2471:19): [True: 0, False: 10]
  ------------------
 2472|      0|    if (GetTestPartResult(i).failed()) return true;
  ------------------
  |  Branch (2472:9): [True: 0, False: 0]
  ------------------
 2473|      0|  }
 2474|     10|  return false;
 2475|     10|}
_ZNK7testing10TestResult15HasFatalFailureEv:
 2483|      6|bool TestResult::HasFatalFailure() const {
 2484|      6|  return CountIf(test_part_results_, TestPartFatallyFailed) > 0;
 2485|      6|}
_ZNK7testing10TestResult16total_part_countEv:
 2499|     10|int TestResult::total_part_count() const {
 2500|     10|  return static_cast<int>(test_part_results_.size());
 2501|     10|}
_ZN7testing4TestC2Ev:
 2513|      2|Test::Test() : gtest_flag_saver_(new GTEST_FLAG_SAVER_) {}
  ------------------
  |  | 2308|      2|#define GTEST_FLAG_SAVER_ ::testing::internal::GTestFlagSaver
  ------------------
_ZN7testing4Test5SetUpEv:
 2523|      2|void Test::SetUp() {}
_ZN7testing4Test14RecordPropertyERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_:
 2531|      2|void Test::RecordProperty(const std::string& key, const std::string& value) {
 2532|      2|  UnitTest::GetInstance()->RecordProperty(key, value);
 2533|      2|}
_ZN7testing4Test19HasSameFixtureClassEv:
 2556|      2|bool Test::HasSameFixtureClass() {
 2557|      2|  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
 2558|      2|  const TestSuite* const test_suite = impl->current_test_suite();
 2559|       |
 2560|       |  // Info about the first test in the current test suite.
 2561|      2|  const TestInfo* const first_test_info = test_suite->test_info_list()[0];
 2562|      2|  const internal::TypeId first_fixture_id = first_test_info->fixture_class_id_;
 2563|      2|  const char* const first_test_name = first_test_info->name();
 2564|       |
 2565|       |  // Info about the current test.
 2566|      2|  const TestInfo* const this_test_info = impl->current_test_info();
 2567|      2|  const internal::TypeId this_fixture_id = this_test_info->fixture_class_id_;
 2568|      2|  const char* const this_test_name = this_test_info->name();
 2569|       |
 2570|      2|  if (this_fixture_id != first_fixture_id) {
  ------------------
  |  Branch (2570:7): [True: 0, False: 2]
  ------------------
 2571|       |    // Is the first test defined using TEST?
 2572|      0|    const bool first_is_TEST = first_fixture_id == internal::GetTestTypeId();
 2573|       |    // Is this test defined using TEST?
 2574|      0|    const bool this_is_TEST = this_fixture_id == internal::GetTestTypeId();
 2575|       |
 2576|      0|    if (first_is_TEST || this_is_TEST) {
  ------------------
  |  Branch (2576:9): [True: 0, False: 0]
  |  Branch (2576:26): [True: 0, False: 0]
  ------------------
 2577|       |      // Both TEST and TEST_F appear in same test suite, which is incorrect.
 2578|       |      // Tell the user how to fix this.
 2579|       |
 2580|       |      // Gets the name of the TEST and the name of the TEST_F.  Note
 2581|       |      // that first_is_TEST and this_is_TEST cannot both be true, as
 2582|       |      // the fixture IDs are different for the two tests.
 2583|      0|      const char* const TEST_name =
 2584|      0|          first_is_TEST ? first_test_name : this_test_name;
  ------------------
  |  Branch (2584:11): [True: 0, False: 0]
  ------------------
 2585|      0|      const char* const TEST_F_name =
 2586|      0|          first_is_TEST ? this_test_name : first_test_name;
  ------------------
  |  Branch (2586:11): [True: 0, False: 0]
  ------------------
 2587|       |
 2588|      0|      ADD_FAILURE()
  ------------------
  |  | 1750|      0|#define ADD_FAILURE() GTEST_NONFATAL_FAILURE_("Failed")
  |  |  ------------------
  |  |  |  | 1296|      0|  GTEST_MESSAGE_(message, ::testing::TestPartResult::kNonFatalFailure)
  |  |  |  |  ------------------
  |  |  |  |  |  | 1290|      0|  GTEST_MESSAGE_AT_(__FILE__, __LINE__, message, result_type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1286|      0|  ::testing::internal::AssertHelper(result_type, file, line, message) = \
  |  |  |  |  |  |  |  | 1287|      0|      ::testing::Message()
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2589|      0|          << "All tests in the same test suite must use the same test fixture\n"
 2590|      0|          << "class, so mixing TEST_F and TEST in the same test suite is\n"
 2591|      0|          << "illegal.  In test suite " << this_test_info->test_suite_name()
 2592|      0|          << ",\n"
 2593|      0|          << "test " << TEST_F_name << " is defined using TEST_F but\n"
 2594|      0|          << "test " << TEST_name << " is defined using TEST.  You probably\n"
 2595|      0|          << "want to change the TEST to TEST_F or move it to another test\n"
 2596|      0|          << "case.";
 2597|      0|    } else {
 2598|       |      // Two fixture classes with the same name appear in two different
 2599|       |      // namespaces, which is not allowed. Tell the user how to fix this.
 2600|      0|      ADD_FAILURE()
  ------------------
  |  | 1750|      0|#define ADD_FAILURE() GTEST_NONFATAL_FAILURE_("Failed")
  |  |  ------------------
  |  |  |  | 1296|      0|  GTEST_MESSAGE_(message, ::testing::TestPartResult::kNonFatalFailure)
  |  |  |  |  ------------------
  |  |  |  |  |  | 1290|      0|  GTEST_MESSAGE_AT_(__FILE__, __LINE__, message, result_type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1286|      0|  ::testing::internal::AssertHelper(result_type, file, line, message) = \
  |  |  |  |  |  |  |  | 1287|      0|      ::testing::Message()
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2601|      0|          << "All tests in the same test suite must use the same test fixture\n"
 2602|      0|          << "class.  However, in test suite "
 2603|      0|          << this_test_info->test_suite_name() << ",\n"
 2604|      0|          << "you defined test " << first_test_name << " and test "
 2605|      0|          << this_test_name << "\n"
 2606|      0|          << "using two different test fixture classes.  This can happen if\n"
 2607|      0|          << "the two classes are from different namespaces or translation\n"
 2608|      0|          << "units and have the same name.  You should probably rename one\n"
 2609|      0|          << "of the classes to put the tests into different test suites.";
 2610|      0|    }
 2611|      0|    return false;
 2612|      0|  }
 2613|       |
 2614|      2|  return true;
 2615|      2|}
_ZN7testing4Test3RunEv:
 2729|      2|void Test::Run() {
 2730|      2|  if (!HasSameFixtureClass()) return;
  ------------------
  |  Branch (2730:7): [True: 0, False: 2]
  ------------------
 2731|       |
 2732|      2|  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
 2733|      2|  impl->os_stack_trace_getter()->UponLeavingGTest();
 2734|      2|  internal::HandleExceptionsInMethodIfSupported(this, &Test::SetUp, "SetUp()");
 2735|       |  // We will run the test only if SetUp() was successful and didn't call
 2736|       |  // GTEST_SKIP().
 2737|      2|  if (!HasFatalFailure() && !IsSkipped()) {
  ------------------
  |  Branch (2737:7): [True: 2, False: 0]
  |  Branch (2737:29): [True: 2, False: 0]
  ------------------
 2738|      2|    impl->os_stack_trace_getter()->UponLeavingGTest();
 2739|      2|    internal::HandleExceptionsInMethodIfSupported(this, &Test::TestBody,
 2740|      2|                                                  "the test body");
 2741|      2|  }
 2742|       |
 2743|       |  // However, we want to clean up as much as possible.  Hence we will
 2744|       |  // always call TearDown(), even if SetUp() or the test body has
 2745|       |  // failed.
 2746|      2|  impl->os_stack_trace_getter()->UponLeavingGTest();
 2747|      2|  internal::HandleExceptionsInMethodIfSupported(this, &Test::TearDown,
 2748|      2|                                                "TearDown()");
 2749|      2|}
_ZN7testing4Test15HasFatalFailureEv:
 2752|      6|bool Test::HasFatalFailure() {
 2753|      6|  return internal::GetUnitTestImpl()->current_test_result()->HasFatalFailure();
 2754|      6|}
_ZN7testing4Test9IsSkippedEv:
 2764|      6|bool Test::IsSkipped() {
 2765|      6|  return internal::GetUnitTestImpl()->current_test_result()->Skipped();
 2766|      6|}
_ZN7testing8TestInfoC2ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES7_PKcS9_NS_8internal12CodeLocationEPKvPNSA_15TestFactoryBaseE:
 2777|      2|    : test_suite_name_(std::move(a_test_suite_name)),
 2778|      2|      name_(std::move(a_name)),
 2779|      2|      type_param_(a_type_param ? new std::string(a_type_param) : nullptr),
  ------------------
  |  Branch (2779:19): [True: 0, False: 2]
  ------------------
 2780|      2|      value_param_(a_value_param ? new std::string(a_value_param) : nullptr),
  ------------------
  |  Branch (2780:20): [True: 0, False: 2]
  ------------------
 2781|      2|      location_(std::move(a_code_location)),
 2782|      2|      fixture_class_id_(fixture_class_id),
 2783|      2|      should_run_(false),
 2784|      2|      is_disabled_(false),
 2785|      2|      matches_filter_(false),
 2786|      2|      is_in_another_shard_(false),
 2787|      2|      factory_(factory),
 2788|      2|      result_() {}
_ZN7testing8internal23MakeAndRegisterTestInfoENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPKcS9_S9_NS0_12CodeLocationEPKvPFvvESE_PNS0_15TestFactoryBaseE:
 2817|      2|    TearDownTestSuiteFunc tear_down_tc, TestFactoryBase* factory) {
 2818|      2|  TestInfo* const test_info =
 2819|      2|      new TestInfo(std::move(test_suite_name), name, type_param, value_param,
 2820|      2|                   std::move(code_location), fixture_class_id, factory);
 2821|      2|  GetUnitTestImpl()->AddTestInfo(set_up_tc, tear_down_tc, test_info);
 2822|      2|  return test_info;
 2823|      2|}
_ZN7testing8internal12UnitTestImpl26RegisterParameterizedTestsEv:
 2846|      2|void UnitTestImpl::RegisterParameterizedTests() {
 2847|      2|  if (!parameterized_tests_registered_) {
  ------------------
  |  Branch (2847:7): [True: 2, False: 0]
  ------------------
 2848|      2|    parameterized_test_registry_.RegisterTests();
 2849|      2|    type_parameterized_test_registry_.CheckForInstantiations();
 2850|      2|    parameterized_tests_registered_ = true;
 2851|      2|  }
 2852|      2|}
_ZN7testing8TestInfo3RunEv:
 2858|      2|void TestInfo::Run() {
 2859|      2|  TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
 2860|      2|  if (!should_run_) {
  ------------------
  |  Branch (2860:7): [True: 0, False: 2]
  ------------------
 2861|      0|    if (is_disabled_ && matches_filter_) repeater->OnTestDisabled(*this);
  ------------------
  |  Branch (2861:9): [True: 0, False: 0]
  |  Branch (2861:25): [True: 0, False: 0]
  ------------------
 2862|      0|    return;
 2863|      0|  }
 2864|       |
 2865|       |  // Tells UnitTest where to store test result.
 2866|      2|  UnitTest::GetInstance()->set_current_test_info(this);
 2867|       |
 2868|       |  // Notifies the unit test event listeners that a test is about to start.
 2869|      2|  repeater->OnTestStart(*this);
 2870|      2|  result_.set_start_timestamp(internal::GetTimeInMillis());
 2871|      2|  internal::Timer timer;
 2872|      2|  UnitTest::GetInstance()->UponLeavingGTest();
 2873|       |
 2874|       |  // Creates the test object.
 2875|      2|  Test* const test = internal::HandleExceptionsInMethodIfSupported(
 2876|      2|      factory_, &internal::TestFactoryBase::CreateTest,
 2877|      2|      "the test fixture's constructor");
 2878|       |
 2879|       |  // Runs the test if the constructor didn't generate a fatal failure or invoke
 2880|       |  // GTEST_SKIP().
 2881|       |  // Note that the object will not be null
 2882|      2|  if (!Test::HasFatalFailure() && !Test::IsSkipped()) {
  ------------------
  |  Branch (2882:7): [True: 2, False: 0]
  |  Branch (2882:35): [True: 2, False: 0]
  ------------------
 2883|       |    // This doesn't throw as all user code that can throw are wrapped into
 2884|       |    // exception handling code.
 2885|      2|    test->Run();
 2886|      2|  }
 2887|       |
 2888|      2|  if (test != nullptr) {
  ------------------
  |  Branch (2888:7): [True: 0, False: 2]
  ------------------
 2889|       |    // Deletes the test object.
 2890|      0|    UnitTest::GetInstance()->UponLeavingGTest();
 2891|      0|    internal::HandleExceptionsInMethodIfSupported(
 2892|      0|        test, &Test::DeleteSelf_, "the test fixture's destructor");
 2893|      0|  }
 2894|       |
 2895|      2|  result_.set_elapsed_time(timer.Elapsed());
 2896|       |
 2897|       |  // Notifies the unit test event listener that a test has just finished.
 2898|      2|  repeater->OnTestEnd(*this);
 2899|       |
 2900|       |  // Tells UnitTest to stop associating assertion results to this
 2901|       |  // test.
 2902|      2|  UnitTest::GetInstance()->set_current_test_info(nullptr);
 2903|      2|}
_ZNK7testing9TestSuite17test_to_run_countEv:
 2960|      4|int TestSuite::test_to_run_count() const {
 2961|      4|  return CountIf(test_info_list_, ShouldRunTest);
 2962|      4|}
_ZNK7testing9TestSuite16total_test_countEv:
 2965|      8|int TestSuite::total_test_count() const {
 2966|      8|  return static_cast<int>(test_info_list_.size());
 2967|      8|}
_ZN7testing9TestSuiteC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPKcPFvvESD_:
 2981|      2|    : name_(a_name),
 2982|      2|      type_param_(a_type_param ? new std::string(a_type_param) : nullptr),
  ------------------
  |  Branch (2982:19): [True: 0, False: 2]
  ------------------
 2983|      2|      set_up_tc_(set_up_tc),
 2984|      2|      tear_down_tc_(tear_down_tc),
 2985|      2|      should_run_(false),
 2986|      2|      start_timestamp_(0),
 2987|      2|      elapsed_time_(0) {}
_ZNK7testing9TestSuite11GetTestInfoEi:
 2997|      2|const TestInfo* TestSuite::GetTestInfo(int i) const {
 2998|      2|  const int index = GetElementOr(test_indices_, i, -1);
 2999|      2|  return index < 0 ? nullptr : test_info_list_[static_cast<size_t>(index)];
  ------------------
  |  Branch (2999:10): [True: 0, False: 2]
  ------------------
 3000|      2|}
_ZN7testing9TestSuite18GetMutableTestInfoEi:
 3004|      2|TestInfo* TestSuite::GetMutableTestInfo(int i) {
 3005|      2|  const int index = GetElementOr(test_indices_, i, -1);
 3006|      2|  return index < 0 ? nullptr : test_info_list_[static_cast<size_t>(index)];
  ------------------
  |  Branch (3006:10): [True: 0, False: 2]
  ------------------
 3007|      2|}
_ZN7testing9TestSuite11AddTestInfoEPNS_8TestInfoE:
 3011|      2|void TestSuite::AddTestInfo(TestInfo* test_info) {
 3012|      2|  test_info_list_.push_back(test_info);
 3013|      2|  test_indices_.push_back(static_cast<int>(test_indices_.size()));
 3014|      2|}
_ZN7testing9TestSuite3RunEv:
 3017|      2|void TestSuite::Run() {
 3018|      2|  if (!should_run_) return;
  ------------------
  |  Branch (3018:7): [True: 0, False: 2]
  ------------------
 3019|       |
 3020|      2|  UnitTest::GetInstance()->set_current_test_suite(this);
 3021|       |
 3022|      2|  TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
 3023|       |
 3024|       |  // Ensure our tests are in a deterministic order.
 3025|       |  //
 3026|       |  // We do this by sorting lexicographically on (file, line number), providing
 3027|       |  // an order matching what the user can see in the source code.
 3028|       |  //
 3029|       |  // In the common case the line number comparison shouldn't be necessary,
 3030|       |  // because the registrations made by the TEST macro are executed in order
 3031|       |  // within a translation unit. But this is not true of the manual registration
 3032|       |  // API, and in more exotic scenarios a single file may be part of multiple
 3033|       |  // translation units.
 3034|      2|  std::stable_sort(test_info_list_.begin(), test_info_list_.end(),
 3035|      2|                   [](const TestInfo* const a, const TestInfo* const b) {
 3036|      2|                     if (const int result = std::strcmp(a->file(), b->file())) {
 3037|      2|                       return result < 0;
 3038|      2|                     }
 3039|       |
 3040|      2|                     return a->line() < b->line();
 3041|      2|                   });
 3042|       |
 3043|       |  // Call both legacy and the new API
 3044|      2|  repeater->OnTestSuiteStart(*this);
 3045|       |//  Legacy API is deprecated but still available
 3046|      2|#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
 3047|      2|  repeater->OnTestCaseStart(*this);
 3048|      2|#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
 3049|       |
 3050|      2|  UnitTest::GetInstance()->UponLeavingGTest();
 3051|      2|  internal::HandleExceptionsInMethodIfSupported(
 3052|      2|      this, &TestSuite::RunSetUpTestSuite, "SetUpTestSuite()");
 3053|       |
 3054|      2|  const bool skip_all =
 3055|      2|      ad_hoc_test_result().Failed() || ad_hoc_test_result().Skipped();
  ------------------
  |  Branch (3055:7): [True: 0, False: 2]
  |  Branch (3055:40): [True: 0, False: 2]
  ------------------
 3056|       |
 3057|      2|  start_timestamp_ = internal::GetTimeInMillis();
 3058|      2|  internal::Timer timer;
 3059|      4|  for (int i = 0; i < total_test_count(); i++) {
  ------------------
  |  Branch (3059:19): [True: 2, False: 2]
  ------------------
 3060|      2|    if (skip_all) {
  ------------------
  |  Branch (3060:9): [True: 0, False: 2]
  ------------------
 3061|      0|      GetMutableTestInfo(i)->Skip();
 3062|      2|    } else {
 3063|      2|      GetMutableTestInfo(i)->Run();
 3064|      2|    }
 3065|      2|    if (GTEST_FLAG_GET(fail_fast) &&
  ------------------
  |  | 2310|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2242|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  |  |  |  Branch (2310:30): [True: 0, False: 2]
  |  |  ------------------
  ------------------
 3066|      0|        GetMutableTestInfo(i)->result()->Failed()) {
  ------------------
  |  Branch (3066:9): [True: 0, False: 0]
  ------------------
 3067|      0|      for (int j = i + 1; j < total_test_count(); j++) {
  ------------------
  |  Branch (3067:27): [True: 0, False: 0]
  ------------------
 3068|      0|        GetMutableTestInfo(j)->Skip();
 3069|      0|      }
 3070|      0|      break;
 3071|      0|    }
 3072|      2|  }
 3073|      2|  elapsed_time_ = timer.Elapsed();
 3074|       |
 3075|      2|  UnitTest::GetInstance()->UponLeavingGTest();
 3076|      2|  internal::HandleExceptionsInMethodIfSupported(
 3077|      2|      this, &TestSuite::RunTearDownTestSuite, "TearDownTestSuite()");
 3078|       |
 3079|       |  // Call both legacy and the new API
 3080|      2|  repeater->OnTestSuiteEnd(*this);
 3081|       |//  Legacy API is deprecated but still available
 3082|      2|#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
 3083|      2|  repeater->OnTestCaseEnd(*this);
 3084|      2|#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
 3085|       |
 3086|      2|  UnitTest::GetInstance()->set_current_test_suite(nullptr);
 3087|      2|}
_ZN7testing9TestSuite11ClearResultEv:
 3119|      2|void TestSuite::ClearResult() {
 3120|      2|  ad_hoc_test_result_.Clear();
 3121|      2|  ForEach(test_info_list_, TestInfo::ClearTestResult);
 3122|      2|}
_ZN7testing8internal14ShouldUseColorEb:
 3286|      2|bool ShouldUseColor(bool stdout_is_tty) {
 3287|      2|  std::string c = GTEST_FLAG_GET(color);
  ------------------
  |  | 2310|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2242|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
 3288|      2|  const char* const gtest_color = c.c_str();
 3289|       |
 3290|      2|  if (String::CaseInsensitiveCStringEquals(gtest_color, "auto")) {
  ------------------
  |  Branch (3290:7): [True: 2, False: 0]
  ------------------
 3291|       |#if defined(GTEST_OS_WINDOWS) && !defined(GTEST_OS_WINDOWS_MINGW)
 3292|       |    // On Windows the TERM variable is usually not set, but the
 3293|       |    // console there does support colors.
 3294|       |    return stdout_is_tty;
 3295|       |#else
 3296|       |    // On non-Windows platforms, we rely on the TERM variable.
 3297|      2|    const char* const term = posix::GetEnv("TERM");
 3298|      2|    const bool term_supports_color =
 3299|      2|        term != nullptr && (String::CStringEquals(term, "xterm") ||
  ------------------
  |  Branch (3299:9): [True: 0, False: 2]
  |  Branch (3299:29): [True: 0, False: 0]
  ------------------
 3300|      0|                            String::CStringEquals(term, "xterm-color") ||
  ------------------
  |  Branch (3300:29): [True: 0, False: 0]
  ------------------
 3301|      0|                            String::CStringEquals(term, "xterm-kitty") ||
  ------------------
  |  Branch (3301:29): [True: 0, False: 0]
  ------------------
 3302|      0|                            String::CStringEquals(term, "alacritty") ||
  ------------------
  |  Branch (3302:29): [True: 0, False: 0]
  ------------------
 3303|      0|                            String::CStringEquals(term, "screen") ||
  ------------------
  |  Branch (3303:29): [True: 0, False: 0]
  ------------------
 3304|      0|                            String::CStringEquals(term, "tmux") ||
  ------------------
  |  Branch (3304:29): [True: 0, False: 0]
  ------------------
 3305|      0|                            String::CStringEquals(term, "rxvt-unicode") ||
  ------------------
  |  Branch (3305:29): [True: 0, False: 0]
  ------------------
 3306|      0|                            String::CStringEquals(term, "linux") ||
  ------------------
  |  Branch (3306:29): [True: 0, False: 0]
  ------------------
 3307|      0|                            String::CStringEquals(term, "cygwin") ||
  ------------------
  |  Branch (3307:29): [True: 0, False: 0]
  ------------------
 3308|      0|                            String::EndsWithCaseInsensitive(term, "-256color"));
  ------------------
  |  Branch (3308:29): [True: 0, False: 0]
  ------------------
 3309|      2|    return stdout_is_tty && term_supports_color;
  ------------------
  |  Branch (3309:12): [True: 0, False: 2]
  |  Branch (3309:29): [True: 0, False: 0]
  ------------------
 3310|      2|#endif  // GTEST_OS_WINDOWS
 3311|      2|  }
 3312|       |
 3313|      0|  return String::CaseInsensitiveCStringEquals(gtest_color, "yes") ||
  ------------------
  |  Branch (3313:10): [True: 0, False: 0]
  ------------------
 3314|      0|         String::CaseInsensitiveCStringEquals(gtest_color, "true") ||
  ------------------
  |  Branch (3314:10): [True: 0, False: 0]
  ------------------
 3315|      0|         String::CaseInsensitiveCStringEquals(gtest_color, "t") ||
  ------------------
  |  Branch (3315:10): [True: 0, False: 0]
  ------------------
 3316|      0|         String::CStringEquals(gtest_color, "1");
  ------------------
  |  Branch (3316:10): [True: 0, False: 0]
  ------------------
 3317|       |  // We take "yes", "true", "t", and "1" as meaning "yes".  If the
 3318|       |  // value is neither one of these nor "auto", we treat it as "no" to
 3319|       |  // be conservative.
 3320|      2|}
_ZN7testing8internal27PrettyUnitTestResultPrinter20OnTestIterationStartERKNS_8UnitTestEi:
 3441|      2|    const UnitTest& unit_test, int iteration) {
 3442|      2|  if (GTEST_FLAG_GET(repeat) != 1)
  ------------------
  |  | 2310|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2242|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  |  Branch (3442:7): [True: 0, False: 2]
  ------------------
 3443|      0|    printf("\nRepeating all tests (iteration %d) . . .\n\n", iteration + 1);
 3444|       |
 3445|      2|  std::string f = GTEST_FLAG_GET(filter);
  ------------------
  |  | 2310|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2242|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
 3446|      2|  const char* const filter = f.c_str();
 3447|       |
 3448|       |  // Prints the filter if it's not *.  This reminds the user that some
 3449|       |  // tests may be skipped.
 3450|      2|  if (!String::CStringEquals(filter, kUniversalFilter)) {
  ------------------
  |  Branch (3450:7): [True: 2, False: 0]
  ------------------
 3451|      2|    ColoredPrintf(GTestColor::kYellow, "Note: %s filter = %s\n", GTEST_NAME_,
  ------------------
  |  |  349|      2|#define GTEST_NAME_ "Google Test"
  ------------------
 3452|      2|                  filter);
 3453|      2|  }
 3454|       |
 3455|      2|  if (internal::ShouldShard(kTestTotalShards, kTestShardIndex, false)) {
  ------------------
  |  Branch (3455:7): [True: 0, False: 2]
  ------------------
 3456|      0|    const int32_t shard_index = Int32FromEnvOrDie(kTestShardIndex, -1);
 3457|      0|    ColoredPrintf(GTestColor::kYellow, "Note: This is test shard %d of %s.\n",
 3458|      0|                  static_cast<int>(shard_index) + 1,
 3459|      0|                  internal::posix::GetEnv(kTestTotalShards));
 3460|      0|  }
 3461|       |
 3462|      2|  if (GTEST_FLAG_GET(shuffle)) {
  ------------------
  |  | 2310|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2242|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  |  |  |  Branch (2310:30): [True: 0, False: 2]
  |  |  ------------------
  ------------------
 3463|      0|    ColoredPrintf(GTestColor::kYellow,
 3464|      0|                  "Note: Randomizing tests' orders with a seed of %d .\n",
 3465|      0|                  unit_test.random_seed());
 3466|      0|  }
 3467|       |
 3468|      2|  ColoredPrintf(GTestColor::kGreen, "[==========] ");
 3469|      2|  printf("Running %s from %s.\n",
 3470|      2|         FormatTestCount(unit_test.test_to_run_count()).c_str(),
 3471|      2|         FormatTestSuiteCount(unit_test.test_suite_to_run_count()).c_str());
 3472|       |  fflush(stdout);
 3473|      2|}
_ZN7testing8internal27PrettyUnitTestResultPrinter24OnEnvironmentsSetUpStartERKNS_8UnitTestE:
 3476|      2|    const UnitTest& /*unit_test*/) {
 3477|      2|  ColoredPrintf(GTestColor::kGreen, "[----------] ");
 3478|      2|  printf("Global test environment set-up.\n");
 3479|       |  fflush(stdout);
 3480|      2|}
_ZN7testing8internal27PrettyUnitTestResultPrinter15OnTestCaseStartERKNS_9TestSuiteE:
 3483|      2|void PrettyUnitTestResultPrinter::OnTestCaseStart(const TestCase& test_case) {
 3484|      2|  const std::string counts =
 3485|      2|      FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
 3486|      2|  ColoredPrintf(GTestColor::kGreen, "[----------] ");
 3487|      2|  printf("%s from %s", counts.c_str(), test_case.name());
 3488|      2|  if (test_case.type_param() == nullptr) {
  ------------------
  |  Branch (3488:7): [True: 2, False: 0]
  ------------------
 3489|      2|    printf("\n");
 3490|      2|  } else {
 3491|      0|    printf(", where %s = %s\n", kTypeParamLabel, test_case.type_param());
 3492|      0|  }
 3493|       |  fflush(stdout);
 3494|      2|}
_ZN7testing8internal27PrettyUnitTestResultPrinter11OnTestStartERKNS_8TestInfoE:
 3511|      2|void PrettyUnitTestResultPrinter::OnTestStart(const TestInfo& test_info) {
 3512|      2|  ColoredPrintf(GTestColor::kGreen, "[ RUN      ] ");
 3513|      2|  PrintTestName(test_info.test_suite_name(), test_info.name());
 3514|      2|  printf("\n");
 3515|       |  fflush(stdout);
 3516|      2|}
_ZN7testing8internal17TestEventRepeater6AppendEPNS_17TestEventListenerE:
 3862|      6|void TestEventRepeater::Append(TestEventListener* listener) {
 3863|      6|  listeners_.push_back(listener);
 3864|      6|}
_ZN7testing8internal17TestEventRepeater7ReleaseEPNS_17TestEventListenerE:
 3866|      2|TestEventListener* TestEventRepeater::Release(TestEventListener* listener) {
 3867|      2|  for (size_t i = 0; i < listeners_.size(); ++i) {
  ------------------
  |  Branch (3867:22): [True: 0, False: 2]
  ------------------
 3868|      0|    if (listeners_[i] == listener) {
  ------------------
  |  Branch (3868:9): [True: 0, False: 0]
  ------------------
 3869|      0|      listeners_.erase(listeners_.begin() + static_cast<int>(i));
 3870|      0|      return listener;
 3871|      0|    }
 3872|      0|  }
 3873|       |
 3874|      2|  return nullptr;
 3875|      2|}
_ZN7testing8internal17TestEventRepeater18OnTestProgramStartERKNS_8UnitTestE:
 3880|      2|  void TestEventRepeater::Name(const Type& parameter) { \
 3881|      2|    if (forwarding_enabled_) {                          \
  ------------------
  |  Branch (3881:9): [True: 2, False: 0]
  ------------------
 3882|      8|      for (size_t i = 0; i < listeners_.size(); i++) {  \
  ------------------
  |  Branch (3882:26): [True: 6, False: 2]
  ------------------
 3883|      6|        listeners_[i]->Name(parameter);                 \
 3884|      6|      }                                                 \
 3885|      2|    }                                                   \
 3886|      2|  }
_ZN7testing8internal17TestEventRepeater24OnEnvironmentsSetUpStartERKNS_8UnitTestE:
 3880|      2|  void TestEventRepeater::Name(const Type& parameter) { \
 3881|      2|    if (forwarding_enabled_) {                          \
  ------------------
  |  Branch (3881:9): [True: 2, False: 0]
  ------------------
 3882|      8|      for (size_t i = 0; i < listeners_.size(); i++) {  \
  ------------------
  |  Branch (3882:26): [True: 6, False: 2]
  ------------------
 3883|      6|        listeners_[i]->Name(parameter);                 \
 3884|      6|      }                                                 \
 3885|      2|    }                                                   \
 3886|      2|  }
_ZN7testing8internal17TestEventRepeater15OnTestCaseStartERKNS_9TestSuiteE:
 3880|      2|  void TestEventRepeater::Name(const Type& parameter) { \
 3881|      2|    if (forwarding_enabled_) {                          \
  ------------------
  |  Branch (3881:9): [True: 2, False: 0]
  ------------------
 3882|      8|      for (size_t i = 0; i < listeners_.size(); i++) {  \
  ------------------
  |  Branch (3882:26): [True: 6, False: 2]
  ------------------
 3883|      6|        listeners_[i]->Name(parameter);                 \
 3884|      6|      }                                                 \
 3885|      2|    }                                                   \
 3886|      2|  }
_ZN7testing8internal17TestEventRepeater16OnTestSuiteStartERKNS_9TestSuiteE:
 3880|      2|  void TestEventRepeater::Name(const Type& parameter) { \
 3881|      2|    if (forwarding_enabled_) {                          \
  ------------------
  |  Branch (3881:9): [True: 2, False: 0]
  ------------------
 3882|      8|      for (size_t i = 0; i < listeners_.size(); i++) {  \
  ------------------
  |  Branch (3882:26): [True: 6, False: 2]
  ------------------
 3883|      6|        listeners_[i]->Name(parameter);                 \
 3884|      6|      }                                                 \
 3885|      2|    }                                                   \
 3886|      2|  }
_ZN7testing8internal17TestEventRepeater11OnTestStartERKNS_8TestInfoE:
 3880|      2|  void TestEventRepeater::Name(const Type& parameter) { \
 3881|      2|    if (forwarding_enabled_) {                          \
  ------------------
  |  Branch (3881:9): [True: 2, False: 0]
  ------------------
 3882|      8|      for (size_t i = 0; i < listeners_.size(); i++) {  \
  ------------------
  |  Branch (3882:26): [True: 6, False: 2]
  ------------------
 3883|      6|        listeners_[i]->Name(parameter);                 \
 3884|      6|      }                                                 \
 3885|      2|    }                                                   \
 3886|      2|  }
_ZN7testing8internal17TestEventRepeater22OnEnvironmentsSetUpEndERKNS_8UnitTestE:
 3890|      2|  void TestEventRepeater::Name(const Type& parameter) { \
 3891|      2|    if (forwarding_enabled_) {                          \
  ------------------
  |  Branch (3891:9): [True: 2, False: 0]
  ------------------
 3892|      8|      for (size_t i = listeners_.size(); i != 0; i--) { \
  ------------------
  |  Branch (3892:42): [True: 6, False: 2]
  ------------------
 3893|      6|        listeners_[i - 1]->Name(parameter);             \
 3894|      6|      }                                                 \
 3895|      2|    }                                                   \
 3896|      2|  }
_ZN7testing8internal17TestEventRepeater20OnTestIterationStartERKNS_8UnitTestEi:
 3923|      2|                                             int iteration) {
 3924|      2|  if (forwarding_enabled_) {
  ------------------
  |  Branch (3924:7): [True: 2, False: 0]
  ------------------
 3925|      8|    for (size_t i = 0; i < listeners_.size(); i++) {
  ------------------
  |  Branch (3925:24): [True: 6, False: 2]
  ------------------
 3926|      6|      listeners_[i]->OnTestIterationStart(unit_test, iteration);
 3927|      6|    }
 3928|      2|  }
 3929|      2|}
_ZN7testing8internal18OsStackTraceGetter16UponLeavingGTestEv:
 5115|      8|void OsStackTraceGetter::UponLeavingGTest() GTEST_LOCK_EXCLUDED_(mutex_) {
 5116|       |#ifdef GTEST_HAS_ABSL
 5117|       |  void* caller_frame = nullptr;
 5118|       |  if (absl::GetStackTrace(&caller_frame, 1, 3) <= 0) {
 5119|       |    caller_frame = nullptr;
 5120|       |  }
 5121|       |
 5122|       |  MutexLock lock(&mutex_);
 5123|       |  caller_frame_ = caller_frame;
 5124|       |#endif  // GTEST_HAS_ABSL
 5125|      8|}
_ZN7testing18TestEventListenersC2Ev:
 5172|      2|    : repeater_(new internal::TestEventRepeater()),
 5173|      2|      default_result_printer_(nullptr),
 5174|      2|      default_xml_generator_(nullptr) {}
_ZN7testing18TestEventListeners6AppendEPNS_17TestEventListenerE:
 5182|      6|void TestEventListeners::Append(TestEventListener* listener) {
 5183|      6|  repeater_->Append(listener);
 5184|      6|}
_ZN7testing18TestEventListeners7ReleaseEPNS_17TestEventListenerE:
 5189|      2|TestEventListener* TestEventListeners::Release(TestEventListener* listener) {
 5190|      2|  if (listener == default_result_printer_)
  ------------------
  |  Branch (5190:7): [True: 2, False: 0]
  ------------------
 5191|      2|    default_result_printer_ = nullptr;
 5192|      0|  else if (listener == default_xml_generator_)
  ------------------
  |  Branch (5192:12): [True: 0, False: 0]
  ------------------
 5193|      0|    default_xml_generator_ = nullptr;
 5194|      2|  return repeater_->Release(listener);
 5195|      2|}
_ZN7testing18TestEventListeners8repeaterEv:
 5199|      6|TestEventListener* TestEventListeners::repeater() { return repeater_; }
_ZN7testing18TestEventListeners23SetDefaultResultPrinterEPNS_17TestEventListenerE:
 5206|      2|void TestEventListeners::SetDefaultResultPrinter(TestEventListener* listener) {
 5207|      2|  if (default_result_printer_ != listener) {
  ------------------
  |  Branch (5207:7): [True: 2, False: 0]
  ------------------
 5208|       |    // It is an error to pass this method a listener that is already in the
 5209|       |    // list.
 5210|      2|    delete Release(default_result_printer_);
 5211|      2|    default_result_printer_ = listener;
 5212|      2|    if (listener != nullptr) Append(listener);
  ------------------
  |  Branch (5212:9): [True: 2, False: 0]
  ------------------
 5213|      2|  }
 5214|      2|}
_ZN7testing8UnitTest11GetInstanceEv:
 5250|     54|UnitTest* UnitTest::GetInstance() {
 5251|       |  // CodeGear C++Builder insists on a public destructor for the
 5252|       |  // default implementation.  Use this implementation to keep good OO
 5253|       |  // design with private destructor.
 5254|       |
 5255|       |#if defined(__BORLANDC__)
 5256|       |  static UnitTest* const instance = new UnitTest;
 5257|       |  return instance;
 5258|       |#else
 5259|     54|  static UnitTest instance;
 5260|     54|  return &instance;
 5261|     54|#endif  // defined(__BORLANDC__)
 5262|     54|}
_ZNK7testing8UnitTest22total_test_suite_countEv:
 5275|      4|int UnitTest::total_test_suite_count() const {
 5276|      4|  return impl()->total_test_suite_count();
 5277|      4|}
_ZNK7testing8UnitTest23test_suite_to_run_countEv:
 5281|      2|int UnitTest::test_suite_to_run_count() const {
 5282|      2|  return impl()->test_suite_to_run_count();
 5283|      2|}
_ZNK7testing8UnitTest17test_to_run_countEv:
 5333|      2|int UnitTest::test_to_run_count() const { return impl()->test_to_run_count(); }
_ZNK7testing8UnitTest12GetTestSuiteEi:
 5356|      6|const TestSuite* UnitTest::GetTestSuite(int i) const {
 5357|      6|  return impl()->GetTestSuite(i);
 5358|      6|}
_ZN7testing8UnitTest16UponLeavingGTestEv:
 5379|      4|void UnitTest::UponLeavingGTest() {
 5380|      4|  impl()->os_stack_trace_getter()->UponLeavingGTest();
 5381|      4|}
_ZN7testing8UnitTest22set_current_test_suiteEPNS_9TestSuiteE:
 5384|      2|void UnitTest::set_current_test_suite(TestSuite* a_current_test_suite) {
 5385|      2|  internal::MutexLock lock(&mutex_);
 5386|      2|  impl_->set_current_test_suite(a_current_test_suite);
 5387|      2|}
_ZN7testing8UnitTest21set_current_test_infoEPNS_8TestInfoE:
 5390|      2|void UnitTest::set_current_test_info(TestInfo* a_current_test_info) {
 5391|      2|  internal::MutexLock lock(&mutex_);
 5392|      2|  impl_->set_current_test_info(a_current_test_info);
 5393|      2|}
_ZN7testing8UnitTest9listenersEv:
 5397|      8|TestEventListeners& UnitTest::listeners() { return *impl()->listeners(); }
_ZN7testing8UnitTest14RecordPropertyERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_:
 5500|      2|                              const std::string& value) {
 5501|      2|  impl_->RecordProperty(TestProperty(key, value));
 5502|      2|}
_ZN7testing8UnitTest3RunEv:
 5509|      2|int UnitTest::Run() {
 5510|      2|#ifdef GTEST_HAS_DEATH_TEST
 5511|      2|  const bool in_death_test_child_process =
 5512|      2|      !GTEST_FLAG_GET(internal_run_death_test).empty();
  ------------------
  |  | 2310|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2242|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
 5513|       |
 5514|       |  // Google Test implements this protocol for catching that a test
 5515|       |  // program exits before returning control to Google Test:
 5516|       |  //
 5517|       |  //   1. Upon start, Google Test creates a file whose absolute path
 5518|       |  //      is specified by the environment variable
 5519|       |  //      TEST_PREMATURE_EXIT_FILE.
 5520|       |  //   2. When Google Test has finished its work, it deletes the file.
 5521|       |  //
 5522|       |  // This allows a test runner to set TEST_PREMATURE_EXIT_FILE before
 5523|       |  // running a Google-Test-based test program and check the existence
 5524|       |  // of the file at the end of the test execution to see if it has
 5525|       |  // exited prematurely.
 5526|       |
 5527|       |  // If we are in the child process of a death test, don't
 5528|       |  // create/delete the premature exit file, as doing so is unnecessary
 5529|       |  // and will confuse the parent process.  Otherwise, create/delete
 5530|       |  // the file upon entering/leaving this function.  If the program
 5531|       |  // somehow exits before this function has a chance to return, the
 5532|       |  // premature-exit file will be left undeleted, causing a test runner
 5533|       |  // that understands the premature-exit-file protocol to report the
 5534|       |  // test as having failed.
 5535|      2|  const internal::ScopedPrematureExitFile premature_exit_file(
 5536|      2|      in_death_test_child_process
  ------------------
  |  Branch (5536:7): [True: 0, False: 2]
  ------------------
 5537|      2|          ? nullptr
 5538|      2|          : internal::posix::GetEnv("TEST_PREMATURE_EXIT_FILE"));
 5539|       |#else
 5540|       |  const bool in_death_test_child_process = false;
 5541|       |#endif  // GTEST_HAS_DEATH_TEST
 5542|       |
 5543|       |  // Captures the value of GTEST_FLAG(catch_exceptions).  This value will be
 5544|       |  // used for the duration of the program.
 5545|      2|  impl()->set_catch_exceptions(GTEST_FLAG_GET(catch_exceptions));
  ------------------
  |  | 2310|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2242|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
 5546|       |
 5547|       |#ifdef GTEST_OS_WINDOWS
 5548|       |  // Either the user wants Google Test to catch exceptions thrown by the
 5549|       |  // tests or this is executing in the context of death test child
 5550|       |  // process. In either case the user does not want to see pop-up dialogs
 5551|       |  // about crashes - they are expected.
 5552|       |  if (impl()->catch_exceptions() || in_death_test_child_process) {
 5553|       |#if !defined(GTEST_OS_WINDOWS_MOBILE) && !defined(GTEST_OS_WINDOWS_PHONE) && \
 5554|       |    !defined(GTEST_OS_WINDOWS_RT) && !defined(GTEST_OS_WINDOWS_GAMES)
 5555|       |    // SetErrorMode doesn't exist on CE.
 5556|       |    SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOALIGNMENTFAULTEXCEPT |
 5557|       |                 SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX);
 5558|       |#endif  // !GTEST_OS_WINDOWS_MOBILE
 5559|       |
 5560|       |#if (defined(_MSC_VER) || defined(GTEST_OS_WINDOWS_MINGW)) && \
 5561|       |    !defined(GTEST_OS_WINDOWS_MOBILE)
 5562|       |    // Death test children can be terminated with _abort().  On Windows,
 5563|       |    // _abort() can show a dialog with a warning message.  This forces the
 5564|       |    // abort message to go to stderr instead.
 5565|       |    _set_error_mode(_OUT_TO_STDERR);
 5566|       |#endif
 5567|       |
 5568|       |#if defined(_MSC_VER) && !defined(GTEST_OS_WINDOWS_MOBILE)
 5569|       |    // In the debug version, Visual Studio pops up a separate dialog
 5570|       |    // offering a choice to debug the aborted program. We need to suppress
 5571|       |    // this dialog or it will pop up for every EXPECT/ASSERT_DEATH statement
 5572|       |    // executed. Google Test will notify the user of any unexpected
 5573|       |    // failure via stderr.
 5574|       |    if (!GTEST_FLAG_GET(break_on_failure))
 5575|       |      _set_abort_behavior(
 5576|       |          0x0,                                    // Clear the following flags:
 5577|       |          _WRITE_ABORT_MSG | _CALL_REPORTFAULT);  // pop-up window, core dump.
 5578|       |
 5579|       |    // In debug mode, the Windows CRT can crash with an assertion over invalid
 5580|       |    // input (e.g. passing an invalid file descriptor).  The default handling
 5581|       |    // for these assertions is to pop up a dialog and wait for user input.
 5582|       |    // Instead ask the CRT to dump such assertions to stderr non-interactively.
 5583|       |    if (!IsDebuggerPresent()) {
 5584|       |      (void)_CrtSetReportMode(_CRT_ASSERT,
 5585|       |                              _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
 5586|       |      (void)_CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
 5587|       |    }
 5588|       |#endif
 5589|       |  }
 5590|       |#else
 5591|      2|  (void)in_death_test_child_process;  // Needed inside the #if block above
 5592|      2|#endif  // GTEST_OS_WINDOWS
 5593|       |
 5594|      2|  return internal::HandleExceptionsInMethodIfSupported(
  ------------------
  |  Branch (5594:10): [True: 0, False: 2]
  ------------------
 5595|      2|             impl(), &internal::UnitTestImpl::RunAllTests,
 5596|      2|             "auxiliary test code (environments or event listeners)")
 5597|      2|             ? 0
 5598|      2|             : 1;
 5599|      2|}
_ZN7testing8UnitTest27parameterized_test_registryEv:
 5640|      2|UnitTest::parameterized_test_registry() GTEST_LOCK_EXCLUDED_(mutex_) {
 5641|      2|  return impl_->parameterized_test_registry();
 5642|      2|}
_ZN7testing8UnitTestC2Ev:
 5645|      2|UnitTest::UnitTest() { impl_ = new internal::UnitTestImpl(this); }
_ZN7testing8internal12UnitTestImplC2EPNS_8UnitTestE:
 5667|      2|    : parent_(parent),
 5668|       |      GTEST_DISABLE_MSC_WARNINGS_PUSH_(4355 /* using this in initializer */)
 5669|      2|          default_global_test_part_result_reporter_(this),
 5670|      2|      default_per_thread_test_part_result_reporter_(this),
 5671|       |      GTEST_DISABLE_MSC_WARNINGS_POP_() global_test_part_result_reporter_(
 5672|      2|          &default_global_test_part_result_reporter_),
 5673|      2|      per_thread_test_part_result_reporter_(
 5674|      2|          &default_per_thread_test_part_result_reporter_),
 5675|      2|      parameterized_test_registry_(),
 5676|      2|      parameterized_tests_registered_(false),
 5677|      2|      last_death_test_suite_(-1),
 5678|      2|      current_test_suite_(nullptr),
 5679|      2|      current_test_info_(nullptr),
 5680|      2|      ad_hoc_test_result_(),
 5681|      2|      os_stack_trace_getter_(nullptr),
 5682|      2|      post_flag_parse_init_performed_(false),
 5683|      2|      random_seed_(0),  // Will be overridden by the flag before first use.
 5684|      2|      random_(0),       // Will be reseeded before first use.
 5685|      2|      start_timestamp_(0),
 5686|      2|      elapsed_time_(0),
 5687|       |#ifdef GTEST_HAS_DEATH_TEST
 5688|      2|      death_test_factory_(new DefaultDeathTestFactory),
 5689|       |#endif
 5690|       |      // Will be overridden by the flag before first use.
 5691|      2|      catch_exceptions_(false) {
 5692|      2|  listeners()->SetDefaultResultPrinter(new PrettyUnitTestResultPrinter);
 5693|      2|}
_ZN7testing8internal12UnitTestImpl14RecordPropertyERKNS_12TestPropertyE:
 5710|      2|void UnitTestImpl::RecordProperty(const TestProperty& test_property) {
 5711|      2|  std::string xml_element;
 5712|      2|  TestResult* test_result;  // TestResult appropriate for property recording.
 5713|       |
 5714|      2|  if (current_test_info_ != nullptr) {
  ------------------
  |  Branch (5714:7): [True: 2, False: 0]
  ------------------
 5715|      2|    xml_element = "testcase";
 5716|      2|    test_result = &(current_test_info_->result_);
 5717|      2|  } else if (current_test_suite_ != nullptr) {
  ------------------
  |  Branch (5717:14): [True: 0, False: 0]
  ------------------
 5718|      0|    xml_element = "testsuite";
 5719|      0|    test_result = &(current_test_suite_->ad_hoc_test_result_);
 5720|      0|  } else {
 5721|      0|    xml_element = "testsuites";
 5722|      0|    test_result = &ad_hoc_test_result_;
 5723|      0|  }
 5724|      2|  test_result->RecordProperty(xml_element, test_property);
 5725|      2|}
_ZN7testing8internal12UnitTestImpl32SuppressTestEventsIfInSubprocessEv:
 5730|      2|void UnitTestImpl::SuppressTestEventsIfInSubprocess() {
 5731|      2|  if (internal_run_death_test_flag_ != nullptr)
  ------------------
  |  Branch (5731:7): [True: 0, False: 2]
  ------------------
 5732|      0|    listeners()->SuppressEventForwarding(true);
 5733|      2|}
_ZN7testing8internal12UnitTestImpl18ConfigureXmlOutputEv:
 5738|      2|void UnitTestImpl::ConfigureXmlOutput() {
 5739|      2|  const std::string& output_format = UnitTestOptions::GetOutputFormat();
 5740|      2|#if GTEST_HAS_FILE_SYSTEM
 5741|      2|  if (output_format == "xml") {
  ------------------
  |  Branch (5741:7): [True: 0, False: 2]
  ------------------
 5742|      0|    listeners()->SetDefaultXmlGenerator(new XmlUnitTestResultPrinter(
 5743|      0|        UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
 5744|      2|  } else if (output_format == "json") {
  ------------------
  |  Branch (5744:14): [True: 0, False: 2]
  ------------------
 5745|      0|    listeners()->SetDefaultXmlGenerator(new JsonUnitTestResultPrinter(
 5746|      0|        UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
 5747|      2|  } else if (!output_format.empty()) {
  ------------------
  |  Branch (5747:14): [True: 0, False: 2]
  ------------------
 5748|      0|    GTEST_LOG_(WARNING) << "WARNING: unrecognized output format \""
  ------------------
  |  | 1062|      0|  ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \
  |  | 1063|      0|                                __FILE__, __LINE__)                    \
  |  | 1064|      0|      .GetStream()
  ------------------
 5749|      0|                        << output_format << "\" ignored.";
 5750|      0|  }
 5751|       |#else
 5752|       |  if (!output_format.empty()) {
 5753|       |    GTEST_LOG_(ERROR) << "ERROR: alternative output formats require "
 5754|       |                      << "GTEST_HAS_FILE_SYSTEM to be enabled";
 5755|       |  }
 5756|       |#endif  // GTEST_HAS_FILE_SYSTEM
 5757|      2|}
_ZN7testing8internal12UnitTestImpl24ConfigureStreamingOutputEv:
 5762|      2|void UnitTestImpl::ConfigureStreamingOutput() {
 5763|      2|  const std::string& target = GTEST_FLAG_GET(stream_result_to);
  ------------------
  |  | 2310|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2242|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
 5764|      2|  if (!target.empty()) {
  ------------------
  |  Branch (5764:7): [True: 0, False: 2]
  ------------------
 5765|      0|    const size_t pos = target.find(':');
 5766|      0|    if (pos != std::string::npos) {
  ------------------
  |  Branch (5766:9): [True: 0, False: 0]
  ------------------
 5767|      0|      listeners()->Append(
 5768|      0|          new StreamingListener(target.substr(0, pos), target.substr(pos + 1)));
 5769|      0|    } else {
 5770|      0|      GTEST_LOG_(WARNING) << "unrecognized streaming target \"" << target
  ------------------
  |  | 1062|      0|  ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \
  |  | 1063|      0|                                __FILE__, __LINE__)                    \
  |  | 1064|      0|      .GetStream()
  ------------------
 5771|      0|                          << "\" ignored.";
 5772|      0|    }
 5773|      0|  }
 5774|      2|}
_ZN7testing8internal12UnitTestImpl19PostFlagParsingInitEv:
 5782|      4|void UnitTestImpl::PostFlagParsingInit() {
 5783|       |  // Ensures that this function does not execute more than once.
 5784|      4|  if (!post_flag_parse_init_performed_) {
  ------------------
  |  Branch (5784:7): [True: 2, False: 2]
  ------------------
 5785|      2|    post_flag_parse_init_performed_ = true;
 5786|       |
 5787|       |#if defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_)
 5788|       |    // Register to send notifications about key process state changes.
 5789|       |    listeners()->Append(new GTEST_CUSTOM_TEST_EVENT_LISTENER_());
 5790|       |#endif  // defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_)
 5791|       |
 5792|      2|#ifdef GTEST_HAS_DEATH_TEST
 5793|      2|    InitDeathTestSubprocessControlInfo();
 5794|      2|    SuppressTestEventsIfInSubprocess();
 5795|      2|#endif  // GTEST_HAS_DEATH_TEST
 5796|       |
 5797|       |    // Registers parameterized tests. This makes parameterized tests
 5798|       |    // available to the UnitTest reflection API without running
 5799|       |    // RUN_ALL_TESTS.
 5800|      2|    RegisterParameterizedTests();
 5801|       |
 5802|       |    // Configures listeners for XML output. This makes it possible for users
 5803|       |    // to shut down the default XML output before invoking RUN_ALL_TESTS.
 5804|      2|    ConfigureXmlOutput();
 5805|       |
 5806|      2|    if (GTEST_FLAG_GET(brief)) {
  ------------------
  |  | 2310|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2242|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  |  |  |  Branch (2310:30): [True: 0, False: 2]
  |  |  ------------------
  ------------------
 5807|      0|      listeners()->SetDefaultResultPrinter(new BriefUnitTestResultPrinter);
 5808|      0|    }
 5809|       |
 5810|      2|#if GTEST_CAN_STREAM_RESULTS_
 5811|       |    // Configures listeners for streaming test results to the specified server.
 5812|      2|    ConfigureStreamingOutput();
 5813|      2|#endif  // GTEST_CAN_STREAM_RESULTS_
 5814|       |
 5815|       |#ifdef GTEST_HAS_ABSL
 5816|       |    if (GTEST_FLAG_GET(install_failure_signal_handler)) {
 5817|       |      absl::FailureSignalHandlerOptions options;
 5818|       |      absl::InstallFailureSignalHandler(options);
 5819|       |    }
 5820|       |#endif  // GTEST_HAS_ABSL
 5821|      2|  }
 5822|      4|}
_ZN7testing8internal12UnitTestImpl12GetTestSuiteERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPKcPFvvESE_:
 5839|      2|    internal::TearDownTestSuiteFunc tear_down_tc) {
 5840|       |  // During initialization, all TestInfos for a given suite are added in
 5841|       |  // sequence. To optimize this case, see if the most recently added suite is
 5842|       |  // the one being requested now.
 5843|      2|  if (!test_suites_.empty() &&
  ------------------
  |  Branch (5843:7): [True: 0, False: 2]
  |  Branch (5843:7): [True: 0, False: 2]
  ------------------
 5844|      0|      (*test_suites_.rbegin())->name_ == test_suite_name) {
  ------------------
  |  Branch (5844:7): [True: 0, False: 0]
  ------------------
 5845|      0|    return *test_suites_.rbegin();
 5846|      0|  }
 5847|       |
 5848|       |  // Fall back to searching the collection.
 5849|      2|  auto item_it = test_suites_by_name_.find(test_suite_name);
 5850|      2|  if (item_it != test_suites_by_name_.end()) {
  ------------------
  |  Branch (5850:7): [True: 0, False: 2]
  ------------------
 5851|      0|    return item_it->second;
 5852|      0|  }
 5853|       |
 5854|       |  // Not found. Create a new instance.
 5855|      2|  auto* const new_test_suite =
 5856|      2|      new TestSuite(test_suite_name, type_param, set_up_tc, tear_down_tc);
 5857|      2|  test_suites_by_name_.emplace(test_suite_name, new_test_suite);
 5858|       |
 5859|      2|  const UnitTestFilter death_test_suite_filter(kDeathTestSuiteFilter);
 5860|       |  // Is this a death test suite?
 5861|      2|  if (death_test_suite_filter.MatchesName(test_suite_name)) {
  ------------------
  |  Branch (5861:7): [True: 0, False: 2]
  ------------------
 5862|       |    // Yes.  Inserts the test suite after the last death test suite
 5863|       |    // defined so far.  This only works when the test suites haven't
 5864|       |    // been shuffled.  Otherwise we may end up running a death test
 5865|       |    // after a non-death test.
 5866|      0|    ++last_death_test_suite_;
 5867|      0|    test_suites_.insert(test_suites_.begin() + last_death_test_suite_,
 5868|      0|                        new_test_suite);
 5869|      2|  } else {
 5870|       |    // No.  Appends to the end of the list.
 5871|      2|    test_suites_.push_back(new_test_suite);
 5872|      2|  }
 5873|       |
 5874|      2|  test_suite_indices_.push_back(static_cast<int>(test_suite_indices_.size()));
 5875|      2|  return new_test_suite;
 5876|      2|}
_ZN7testing8internal12UnitTestImpl11RunAllTestsEv:
 5909|      2|bool UnitTestImpl::RunAllTests() {
 5910|       |  // True if and only if Google Test is initialized before RUN_ALL_TESTS() is
 5911|       |  // called.
 5912|      2|  const bool gtest_is_initialized_before_run_all_tests = GTestIsInitialized();
 5913|       |
 5914|       |  // Do not run any test if the --help flag was specified.
 5915|      2|  if (g_help_flag) return true;
  ------------------
  |  Branch (5915:7): [True: 0, False: 2]
  ------------------
 5916|       |
 5917|       |  // Repeats the call to the post-flag parsing initialization in case the
 5918|       |  // user didn't call InitGoogleTest.
 5919|      2|  PostFlagParsingInit();
 5920|       |
 5921|       |  // Handle the case where the program has no tests linked.
 5922|       |  // Sometimes this is a programmer mistake, but sometimes it is intended.
 5923|      2|  if (total_test_count() == 0) {
  ------------------
  |  Branch (5923:7): [True: 0, False: 2]
  ------------------
 5924|      0|    constexpr char kNoTestLinkedMessage[] =
 5925|      0|        "This test program does NOT link in any test case.";
 5926|      0|    constexpr char kNoTestLinkedFatal[] =
 5927|      0|        "This is INVALID. Please make sure to link in at least one test case.";
 5928|      0|    constexpr char kNoTestLinkedWarning[] =
 5929|      0|        "Please make sure this is intended.";
 5930|      0|    const bool fail_if_no_test_linked = GTEST_FLAG_GET(fail_if_no_test_linked);
  ------------------
  |  | 2310|      0|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2242|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
 5931|      0|    ColoredPrintf(
 5932|      0|        GTestColor::kRed, "%s %s\n", kNoTestLinkedMessage,
 5933|      0|        fail_if_no_test_linked ? kNoTestLinkedFatal : kNoTestLinkedWarning);
  ------------------
  |  Branch (5933:9): [True: 0, False: 0]
  ------------------
 5934|      0|    if (fail_if_no_test_linked) {
  ------------------
  |  Branch (5934:9): [True: 0, False: 0]
  ------------------
 5935|      0|      return false;
 5936|      0|    }
 5937|      0|#if GTEST_HAS_FILE_SYSTEM
 5938|      0|    AppendToTestWarningsOutputFile(std::string(kNoTestLinkedMessage) + ' ' +
 5939|      0|                                   kNoTestLinkedWarning + '\n');
 5940|      0|#endif  // GTEST_HAS_FILE_SYSTEM
 5941|      0|  }
 5942|       |
 5943|      2|#if GTEST_HAS_FILE_SYSTEM
 5944|       |  // Even if sharding is not on, test runners may want to use the
 5945|       |  // GTEST_SHARD_STATUS_FILE to query whether the test supports the sharding
 5946|       |  // protocol.
 5947|      2|  internal::WriteToShardStatusFileIfNeeded();
 5948|      2|#endif  // GTEST_HAS_FILE_SYSTEM
 5949|       |
 5950|       |  // True if and only if we are in a subprocess for running a thread-safe-style
 5951|       |  // death test.
 5952|      2|  bool in_subprocess_for_death_test = false;
 5953|       |
 5954|      2|#ifdef GTEST_HAS_DEATH_TEST
 5955|      2|  in_subprocess_for_death_test = (internal_run_death_test_flag_ != nullptr);
 5956|       |#if defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_)
 5957|       |  if (in_subprocess_for_death_test) {
 5958|       |    GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_();
 5959|       |  }
 5960|       |#endif  // defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_)
 5961|      2|#endif  // GTEST_HAS_DEATH_TEST
 5962|       |
 5963|      2|  const bool should_shard = ShouldShard(kTestTotalShards, kTestShardIndex,
 5964|      2|                                        in_subprocess_for_death_test);
 5965|       |
 5966|       |  // Compares the full test names with the filter to decide which
 5967|       |  // tests to run.
 5968|      2|  const bool has_tests_to_run =
 5969|      2|      FilterTests(should_shard ? HONOR_SHARDING_PROTOCOL
  ------------------
  |  Branch (5969:19): [True: 0, False: 2]
  ------------------
 5970|      2|                               : IGNORE_SHARDING_PROTOCOL) > 0;
 5971|       |
 5972|       |  // Lists the tests and exits if the --gtest_list_tests flag was specified.
 5973|      2|  if (GTEST_FLAG_GET(list_tests)) {
  ------------------
  |  | 2310|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2242|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  |  |  |  Branch (2310:30): [True: 0, False: 2]
  |  |  ------------------
  ------------------
 5974|       |    // This must be called *after* FilterTests() has been called.
 5975|      0|    ListTestsMatchingFilter();
 5976|      0|    return true;
 5977|      0|  }
 5978|       |
 5979|      2|  random_seed_ = GetRandomSeedFromFlag(GTEST_FLAG_GET(random_seed));
  ------------------
  |  | 2310|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2242|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
 5980|       |
 5981|       |  // True if and only if at least one test has failed.
 5982|      2|  bool failed = false;
 5983|       |
 5984|      2|  TestEventListener* repeater = listeners()->repeater();
 5985|       |
 5986|      2|  start_timestamp_ = GetTimeInMillis();
 5987|      2|  repeater->OnTestProgramStart(*parent_);
 5988|       |
 5989|       |  // How many times to repeat the tests?  We don't want to repeat them
 5990|       |  // when we are inside the subprocess of a death test.
 5991|      2|  const int repeat = in_subprocess_for_death_test ? 1 : GTEST_FLAG_GET(repeat);
  ------------------
  |  | 2310|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2242|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  |  Branch (5991:22): [True: 0, False: 2]
  ------------------
 5992|       |
 5993|       |  // Repeats forever if the repeat count is negative.
 5994|      2|  const bool gtest_repeat_forever = repeat < 0;
 5995|       |
 5996|       |  // Should test environments be set up and torn down for each repeat, or only
 5997|       |  // set up on the first and torn down on the last iteration? If there is no
 5998|       |  // "last" iteration because the tests will repeat forever, always recreate the
 5999|       |  // environments to avoid leaks in case one of the environments is using
 6000|       |  // resources that are external to this process. Without this check there would
 6001|       |  // be no way to clean up those external resources automatically.
 6002|      2|  const bool recreate_environments_when_repeating =
 6003|      2|      GTEST_FLAG_GET(recreate_environments_when_repeating) ||
  ------------------
  |  | 2310|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2242|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  |  |  |  Branch (2310:30): [True: 0, False: 2]
  |  |  ------------------
  ------------------
 6004|      2|      gtest_repeat_forever;
  ------------------
  |  Branch (6004:7): [True: 0, False: 2]
  ------------------
 6005|       |
 6006|      4|  for (int i = 0; gtest_repeat_forever || i != repeat; i++) {
  ------------------
  |  Branch (6006:19): [True: 2, False: 2]
  |  Branch (6006:43): [True: 2, False: 0]
  ------------------
 6007|       |    // We want to preserve failures generated by ad-hoc test
 6008|       |    // assertions executed before RUN_ALL_TESTS().
 6009|      2|    ClearNonAdHocTestResult();
 6010|       |
 6011|      2|    Timer timer;
 6012|       |
 6013|       |    // Shuffles test suites and tests if requested.
 6014|      2|    if (has_tests_to_run && GTEST_FLAG_GET(shuffle)) {
  ------------------
  |  | 2310|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2242|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  |  |  |  Branch (2310:30): [True: 0, False: 2]
  |  |  ------------------
  ------------------
  |  Branch (6014:9): [True: 2, False: 0]
  ------------------
 6015|      0|      random()->Reseed(static_cast<uint32_t>(random_seed_));
 6016|       |      // This should be done before calling OnTestIterationStart(),
 6017|       |      // such that a test event listener can see the actual test order
 6018|       |      // in the event.
 6019|      0|      ShuffleTests();
 6020|      0|    }
 6021|       |
 6022|       |    // Tells the unit test event listeners that the tests are about to start.
 6023|      2|    repeater->OnTestIterationStart(*parent_, i);
 6024|       |
 6025|       |    // Runs each test suite if there is at least one test to run.
 6026|      2|    if (has_tests_to_run) {
  ------------------
  |  Branch (6026:9): [True: 2, False: 0]
  ------------------
 6027|       |      // Sets up all environments beforehand. If test environments aren't
 6028|       |      // recreated for each iteration, only do so on the first iteration.
 6029|      2|      if (i == 0 || recreate_environments_when_repeating) {
  ------------------
  |  Branch (6029:11): [True: 2, False: 0]
  |  Branch (6029:21): [True: 0, False: 0]
  ------------------
 6030|      2|        repeater->OnEnvironmentsSetUpStart(*parent_);
 6031|      2|        ForEach(environments_, SetUpEnvironment);
 6032|      2|        repeater->OnEnvironmentsSetUpEnd(*parent_);
 6033|      2|      }
 6034|       |
 6035|       |      // Runs the tests only if there was no fatal failure or skip triggered
 6036|       |      // during global set-up.
 6037|      2|      if (Test::IsSkipped()) {
  ------------------
  |  Branch (6037:11): [True: 0, False: 2]
  ------------------
 6038|       |        // Emit diagnostics when global set-up calls skip, as it will not be
 6039|       |        // emitted by default.
 6040|      0|        TestResult& test_result =
 6041|      0|            *internal::GetUnitTestImpl()->current_test_result();
 6042|      0|        for (int j = 0; j < test_result.total_part_count(); ++j) {
  ------------------
  |  Branch (6042:25): [True: 0, False: 0]
  ------------------
 6043|      0|          const TestPartResult& test_part_result =
 6044|      0|              test_result.GetTestPartResult(j);
 6045|      0|          if (test_part_result.type() == TestPartResult::kSkip) {
  ------------------
  |  Branch (6045:15): [True: 0, False: 0]
  ------------------
 6046|      0|            const std::string& result = test_part_result.message();
 6047|      0|            printf("%s\n", result.c_str());
 6048|      0|          }
 6049|      0|        }
 6050|      0|        fflush(stdout);
 6051|      2|      } else if (!Test::HasFatalFailure()) {
  ------------------
  |  Branch (6051:18): [True: 2, False: 0]
  ------------------
 6052|      4|        for (int test_index = 0; test_index < total_test_suite_count();
  ------------------
  |  Branch (6052:34): [True: 2, False: 2]
  ------------------
 6053|      2|             test_index++) {
 6054|      2|          GetMutableSuiteCase(test_index)->Run();
 6055|      2|          if (GTEST_FLAG_GET(fail_fast) &&
  ------------------
  |  | 2310|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2242|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  |  |  |  Branch (2310:30): [True: 0, False: 2]
  |  |  ------------------
  ------------------
 6056|      0|              GetMutableSuiteCase(test_index)->Failed()) {
  ------------------
  |  Branch (6056:15): [True: 0, False: 0]
  ------------------
 6057|      0|            for (int j = test_index + 1; j < total_test_suite_count(); j++) {
  ------------------
  |  Branch (6057:42): [True: 0, False: 0]
  ------------------
 6058|      0|              GetMutableSuiteCase(j)->Skip();
 6059|      0|            }
 6060|      0|            break;
 6061|      0|          }
 6062|      2|        }
 6063|      2|      } else if (Test::HasFatalFailure()) {
  ------------------
  |  Branch (6063:18): [True: 0, False: 0]
  ------------------
 6064|       |        // If there was a fatal failure during the global setup then we know we
 6065|       |        // aren't going to run any tests. Explicitly mark all of the tests as
 6066|       |        // skipped to make this obvious in the output.
 6067|      0|        for (int test_index = 0; test_index < total_test_suite_count();
  ------------------
  |  Branch (6067:34): [True: 0, False: 0]
  ------------------
 6068|      0|             test_index++) {
 6069|      0|          GetMutableSuiteCase(test_index)->Skip();
 6070|      0|        }
 6071|      0|      }
 6072|       |
 6073|       |      // Tears down all environments in reverse order afterwards. If test
 6074|       |      // environments aren't recreated for each iteration, only do so on the
 6075|       |      // last iteration.
 6076|      2|      if (i == repeat - 1 || recreate_environments_when_repeating) {
  ------------------
  |  Branch (6076:11): [True: 2, False: 0]
  |  Branch (6076:30): [True: 0, False: 0]
  ------------------
 6077|      0|        repeater->OnEnvironmentsTearDownStart(*parent_);
 6078|      0|        std::for_each(environments_.rbegin(), environments_.rend(),
 6079|      0|                      TearDownEnvironment);
 6080|      0|        repeater->OnEnvironmentsTearDownEnd(*parent_);
 6081|      0|      }
 6082|      2|    }
 6083|       |
 6084|      2|    elapsed_time_ = timer.Elapsed();
 6085|       |
 6086|       |    // Tells the unit test event listener that the tests have just finished.
 6087|      2|    repeater->OnTestIterationEnd(*parent_, i);
 6088|       |
 6089|       |    // Gets the result and clears it.
 6090|      2|    if (!Passed()) {
  ------------------
  |  Branch (6090:9): [True: 0, False: 2]
  ------------------
 6091|      0|      failed = true;
 6092|      0|    }
 6093|       |
 6094|       |    // Restores the original test order after the iteration.  This
 6095|       |    // allows the user to quickly repro a failure that happens in the
 6096|       |    // N-th iteration without repeating the first (N - 1) iterations.
 6097|       |    // This is not enclosed in "if (GTEST_FLAG(shuffle)) { ... }", in
 6098|       |    // case the user somehow changes the value of the flag somewhere
 6099|       |    // (it's always safe to unshuffle the tests).
 6100|      2|    UnshuffleTests();
 6101|       |
 6102|      2|    if (GTEST_FLAG_GET(shuffle)) {
  ------------------
  |  | 2310|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2242|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  |  |  |  Branch (2310:30): [True: 0, False: 2]
  |  |  ------------------
  ------------------
 6103|       |      // Picks a new random seed for each iteration.
 6104|      0|      random_seed_ = GetNextRandomSeed(random_seed_);
 6105|      0|    }
 6106|      2|  }
 6107|       |
 6108|      2|  repeater->OnTestProgramEnd(*parent_);
 6109|       |  // Destroy environments in normal code, not in static teardown.
 6110|      2|  bool delete_environment_on_teardown = true;
 6111|      2|  if (delete_environment_on_teardown) {
  ------------------
  |  Branch (6111:7): [True: 0, False: 2]
  ------------------
 6112|      0|    ForEach(environments_, internal::Delete<Environment>);
 6113|      0|    environments_.clear();
 6114|      0|  }
 6115|       |
 6116|       |  // Try to warn the user if no tests matched the test filter.
 6117|      2|  if (ShouldWarnIfNoTestsMatchFilter()) {
  ------------------
  |  Branch (6117:7): [True: 0, False: 2]
  ------------------
 6118|      0|    const std::string filter_warning =
 6119|      0|        std::string("filter \"") + GTEST_FLAG_GET(filter) +
  ------------------
  |  | 2310|      0|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2242|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
 6120|      0|        "\" did not match any test; no tests were run\n";
 6121|      0|    ColoredPrintf(GTestColor::kRed, "WARNING: %s", filter_warning.c_str());
 6122|      0|#if GTEST_HAS_FILE_SYSTEM
 6123|      0|    AppendToTestWarningsOutputFile(filter_warning);
 6124|      0|#endif  // GTEST_HAS_FILE_SYSTEM
 6125|      0|  }
 6126|       |
 6127|      2|  if (!gtest_is_initialized_before_run_all_tests) {
  ------------------
  |  Branch (6127:7): [True: 0, False: 2]
  ------------------
 6128|      0|    ColoredPrintf(
 6129|      0|        GTestColor::kRed,
 6130|      0|        "\nIMPORTANT NOTICE - DO NOT IGNORE:\n"
 6131|      0|        "This test program did NOT call " GTEST_INIT_GOOGLE_TEST_NAME_
 6132|      0|        "() before calling RUN_ALL_TESTS(). This is INVALID. Soon " GTEST_NAME_
 6133|      0|        " will start to enforce the valid usage. "
 6134|      0|        "Please fix it ASAP, or IT WILL START TO FAIL.\n");  // NOLINT
 6135|      0|  }
 6136|       |
 6137|      2|  return !failed;
 6138|      2|}
_ZN7testing8internal30WriteToShardStatusFileIfNeededEv:
 6145|      2|void WriteToShardStatusFileIfNeeded() {
 6146|      2|  const char* const test_shard_file = posix::GetEnv(kTestShardStatusFile);
 6147|      2|  if (test_shard_file != nullptr) {
  ------------------
  |  Branch (6147:7): [True: 0, False: 2]
  ------------------
 6148|      0|    FILE* const file = posix::FOpen(test_shard_file, "w");
 6149|      0|    if (file == nullptr) {
  ------------------
  |  Branch (6149:9): [True: 0, False: 0]
  ------------------
 6150|      0|      ColoredPrintf(GTestColor::kRed,
 6151|      0|                    "Could not write to the test shard status file \"%s\" "
 6152|      0|                    "specified by the %s environment variable.\n",
 6153|      0|                    test_shard_file, kTestShardStatusFile);
 6154|      0|      fflush(stdout);
 6155|      0|      exit(EXIT_FAILURE);
 6156|      0|    }
 6157|      0|    fclose(file);
 6158|      0|  }
 6159|      2|}
_ZN7testing8internal11ShouldShardEPKcS2_b:
 6169|      4|                 bool in_subprocess_for_death_test) {
 6170|      4|  if (in_subprocess_for_death_test) {
  ------------------
  |  Branch (6170:7): [True: 0, False: 4]
  ------------------
 6171|      0|    return false;
 6172|      0|  }
 6173|       |
 6174|      4|  const int32_t total_shards = Int32FromEnvOrDie(total_shards_env, -1);
 6175|      4|  const int32_t shard_index = Int32FromEnvOrDie(shard_index_env, -1);
 6176|       |
 6177|      4|  if (total_shards == -1 && shard_index == -1) {
  ------------------
  |  Branch (6177:7): [True: 4, False: 0]
  |  Branch (6177:29): [True: 4, False: 0]
  ------------------
 6178|      4|    return false;
 6179|      4|  } else if (total_shards == -1 && shard_index != -1) {
  ------------------
  |  Branch (6179:14): [True: 0, False: 0]
  |  Branch (6179:36): [True: 0, False: 0]
  ------------------
 6180|      0|    const Message msg = Message() << "Invalid environment variables: you have "
 6181|      0|                                  << kTestShardIndex << " = " << shard_index
 6182|      0|                                  << ", but have left " << kTestTotalShards
 6183|      0|                                  << " unset.\n";
 6184|      0|    ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str());
 6185|      0|    fflush(stdout);
 6186|      0|    exit(EXIT_FAILURE);
 6187|      0|  } else if (total_shards != -1 && shard_index == -1) {
  ------------------
  |  Branch (6187:14): [True: 0, False: 0]
  |  Branch (6187:36): [True: 0, False: 0]
  ------------------
 6188|      0|    const Message msg = Message()
 6189|      0|                        << "Invalid environment variables: you have "
 6190|      0|                        << kTestTotalShards << " = " << total_shards
 6191|      0|                        << ", but have left " << kTestShardIndex << " unset.\n";
 6192|      0|    ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str());
 6193|      0|    fflush(stdout);
 6194|      0|    exit(EXIT_FAILURE);
 6195|      0|  } else if (shard_index < 0 || shard_index >= total_shards) {
  ------------------
  |  Branch (6195:14): [True: 0, False: 0]
  |  Branch (6195:33): [True: 0, False: 0]
  ------------------
 6196|      0|    const Message msg =
 6197|      0|        Message() << "Invalid environment variables: we require 0 <= "
 6198|      0|                  << kTestShardIndex << " < " << kTestTotalShards
 6199|      0|                  << ", but you have " << kTestShardIndex << "=" << shard_index
 6200|      0|                  << ", " << kTestTotalShards << "=" << total_shards << ".\n";
 6201|      0|    ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str());
 6202|      0|    fflush(stdout);
 6203|      0|    exit(EXIT_FAILURE);
 6204|      0|  }
 6205|       |
 6206|      0|  return total_shards > 1;
 6207|      4|}
_ZN7testing8internal17Int32FromEnvOrDieEPKci:
 6212|      8|int32_t Int32FromEnvOrDie(const char* var, int32_t default_val) {
 6213|      8|  const char* str_val = posix::GetEnv(var);
 6214|      8|  if (str_val == nullptr) {
  ------------------
  |  Branch (6214:7): [True: 8, False: 0]
  ------------------
 6215|      8|    return default_val;
 6216|      8|  }
 6217|       |
 6218|      0|  int32_t result;
 6219|      0|  if (!ParseInt32(Message() << "The value of environment variable " << var,
  ------------------
  |  Branch (6219:7): [True: 0, False: 0]
  ------------------
 6220|      0|                  str_val, &result)) {
 6221|      0|    exit(EXIT_FAILURE);
 6222|      0|  }
 6223|      0|  return result;
 6224|      0|}
_ZN7testing8internal12UnitTestImpl11FilterTestsENS1_18ReactionToShardingE:
 6241|      2|int UnitTestImpl::FilterTests(ReactionToSharding shard_tests) {
 6242|      2|  const int32_t total_shards = shard_tests == HONOR_SHARDING_PROTOCOL
  ------------------
  |  Branch (6242:32): [True: 0, False: 2]
  ------------------
 6243|      2|                                   ? Int32FromEnvOrDie(kTestTotalShards, -1)
 6244|      2|                                   : -1;
 6245|      2|  const int32_t shard_index = shard_tests == HONOR_SHARDING_PROTOCOL
  ------------------
  |  Branch (6245:31): [True: 0, False: 2]
  ------------------
 6246|      2|                                  ? Int32FromEnvOrDie(kTestShardIndex, -1)
 6247|      2|                                  : -1;
 6248|       |
 6249|      2|  const PositiveAndNegativeUnitTestFilter gtest_flag_filter(
 6250|      2|      GTEST_FLAG_GET(filter));
  ------------------
  |  | 2310|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2242|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
 6251|      2|  const UnitTestFilter disable_test_filter(kDisableTestFilter);
 6252|       |  // num_runnable_tests are the number of tests that will
 6253|       |  // run across all shards (i.e., match filter and are not disabled).
 6254|       |  // num_selected_tests are the number of tests to be run on
 6255|       |  // this shard.
 6256|      2|  int num_runnable_tests = 0;
 6257|      2|  int num_selected_tests = 0;
 6258|      2|  for (auto* test_suite : test_suites_) {
  ------------------
  |  Branch (6258:25): [True: 2, False: 2]
  ------------------
 6259|      2|    const std::string& test_suite_name = test_suite->name_;
 6260|      2|    test_suite->set_should_run(false);
 6261|       |
 6262|      2|    for (TestInfo* test_info : test_suite->test_info_list()) {
  ------------------
  |  Branch (6262:30): [True: 2, False: 2]
  ------------------
 6263|      2|      const std::string& test_name = test_info->name_;
 6264|       |      // A test is disabled if test suite name or test name matches
 6265|       |      // kDisableTestFilter.
 6266|      2|      const bool is_disabled =
 6267|      2|          disable_test_filter.MatchesName(test_suite_name) ||
  ------------------
  |  Branch (6267:11): [True: 0, False: 2]
  ------------------
 6268|      2|          disable_test_filter.MatchesName(test_name);
  ------------------
  |  Branch (6268:11): [True: 0, False: 2]
  ------------------
 6269|      2|      test_info->is_disabled_ = is_disabled;
 6270|       |
 6271|      2|      const bool matches_filter =
 6272|      2|          gtest_flag_filter.MatchesTest(test_suite_name, test_name);
 6273|      2|      test_info->matches_filter_ = matches_filter;
 6274|       |
 6275|      2|      const bool is_runnable =
 6276|      2|          (GTEST_FLAG_GET(also_run_disabled_tests) || !is_disabled) &&
  ------------------
  |  | 2310|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2242|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  |  |  |  Branch (2310:30): [True: 0, False: 2]
  |  |  ------------------
  ------------------
  |  Branch (6276:55): [True: 2, False: 0]
  ------------------
 6277|      2|          matches_filter;
  ------------------
  |  Branch (6277:11): [True: 2, False: 0]
  ------------------
 6278|       |
 6279|      2|      const bool is_in_another_shard =
 6280|      2|          shard_tests != IGNORE_SHARDING_PROTOCOL &&
  ------------------
  |  Branch (6280:11): [True: 0, False: 2]
  ------------------
 6281|      0|          !ShouldRunTestOnShard(total_shards, shard_index, num_runnable_tests);
  ------------------
  |  Branch (6281:11): [True: 0, False: 0]
  ------------------
 6282|      2|      test_info->is_in_another_shard_ = is_in_another_shard;
 6283|      2|      const bool is_selected = is_runnable && !is_in_another_shard;
  ------------------
  |  Branch (6283:32): [True: 2, False: 0]
  |  Branch (6283:47): [True: 2, False: 0]
  ------------------
 6284|       |
 6285|      2|      num_runnable_tests += is_runnable;
 6286|      2|      num_selected_tests += is_selected;
 6287|       |
 6288|      2|      test_info->should_run_ = is_selected;
 6289|      2|      test_suite->set_should_run(test_suite->should_run() || is_selected);
  ------------------
  |  Branch (6289:34): [True: 0, False: 2]
  |  Branch (6289:62): [True: 2, False: 0]
  ------------------
 6290|      2|    }
 6291|      2|  }
 6292|      2|  return num_selected_tests;
 6293|      2|}
_ZN7testing8internal12UnitTestImpl21os_stack_trace_getterEv:
 6412|      8|OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
 6413|      8|  if (os_stack_trace_getter_ == nullptr) {
  ------------------
  |  Branch (6413:7): [True: 2, False: 6]
  ------------------
 6414|       |#ifdef GTEST_OS_STACK_TRACE_GETTER_
 6415|       |    os_stack_trace_getter_ = new GTEST_OS_STACK_TRACE_GETTER_;
 6416|       |#else
 6417|      2|    os_stack_trace_getter_ = new OsStackTraceGetter;
 6418|      2|#endif  // GTEST_OS_STACK_TRACE_GETTER_
 6419|      2|  }
 6420|       |
 6421|      8|  return os_stack_trace_getter_;
 6422|      8|}
_ZN7testing8internal12UnitTestImpl19current_test_resultEv:
 6425|     12|TestResult* UnitTestImpl::current_test_result() {
 6426|     12|  if (current_test_info_ != nullptr) {
  ------------------
  |  Branch (6426:7): [True: 8, False: 4]
  ------------------
 6427|      8|    return &current_test_info_->result_;
 6428|      8|  }
 6429|      4|  if (current_test_suite_ != nullptr) {
  ------------------
  |  Branch (6429:7): [True: 0, False: 4]
  ------------------
 6430|      0|    return &current_test_suite_->ad_hoc_test_result_;
 6431|      0|  }
 6432|      4|  return &ad_hoc_test_result_;
 6433|      4|}
_ZN7testing8internal6IsTrueEb:
 6484|     18|bool IsTrue(bool condition) { return condition; }
_ZN7testing8internal10AlwaysTrueEv:
 6486|     12|bool AlwaysTrue() {
 6487|     12|#if GTEST_HAS_EXCEPTIONS
 6488|       |  // This condition is always false so AlwaysTrue() never actually throws,
 6489|       |  // but it makes the compiler think that it may throw.
 6490|     12|  if (IsTrue(false)) throw ClassUniqueToAlwaysTrue();
  ------------------
  |  Branch (6490:7): [True: 0, False: 12]
  ------------------
 6491|     12|#endif  // GTEST_HAS_EXCEPTIONS
 6492|     12|  return true;
 6493|     12|}
_ZN7testing8internal10SkipPrefixEPKcPS2_:
 6498|     65|bool SkipPrefix(const char* prefix, const char** pstr) {
 6499|     65|  const size_t prefix_len = strlen(prefix);
 6500|     65|  if (strncmp(*pstr, prefix, prefix_len) == 0) {
  ------------------
  |  Branch (6500:7): [True: 13, False: 52]
  ------------------
 6501|     13|    *pstr += prefix_len;
 6502|     13|    return true;
 6503|     13|  }
 6504|     52|  return false;
 6505|     65|}
_ZN7testing8internal9ParseFlagEPKcS2_Pi:
 6566|     39|bool ParseFlag(const char* str, const char* flag_name, int32_t* value) {
 6567|       |  // Gets the value of the flag as a string.
 6568|     39|  const char* const value_str = ParseFlagValue(str, flag_name, false);
 6569|       |
 6570|       |  // Aborts if the parsing failed.
 6571|     39|  if (value_str == nullptr) return false;
  ------------------
  |  Branch (6571:7): [True: 39, False: 0]
  ------------------
 6572|       |
 6573|       |  // Sets *value to the value of the flag.
 6574|      0|  return ParseInt32(Message() << "The value of flag --" << flag_name, value_str,
 6575|      0|                    value);
 6576|     39|}
_ZN7testing8internal24ParseGoogleTestFlagsOnlyEPiPPc:
 6860|      2|void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
 6861|       |#ifdef GTEST_HAS_ABSL_FLAGS
 6862|       |  if (*argc <= 0) return;
 6863|       |
 6864|       |  std::vector<char*> positional_args;
 6865|       |  std::vector<absl::UnrecognizedFlag> unrecognized_flags;
 6866|       |  absl::ParseAbseilFlagsOnly(*argc, argv, positional_args, unrecognized_flags);
 6867|       |  absl::flat_hash_set<absl::string_view> unrecognized;
 6868|       |  for (const auto& flag : unrecognized_flags) {
 6869|       |    unrecognized.insert(flag.flag_name);
 6870|       |  }
 6871|       |  absl::flat_hash_set<char*> positional;
 6872|       |  for (const auto& arg : positional_args) {
 6873|       |    positional.insert(arg);
 6874|       |  }
 6875|       |
 6876|       |  int out_pos = 1;
 6877|       |  int in_pos = 1;
 6878|       |  for (; in_pos < *argc; ++in_pos) {
 6879|       |    char* arg = argv[in_pos];
 6880|       |    absl::string_view arg_str(arg);
 6881|       |    if (absl::ConsumePrefix(&arg_str, "--")) {
 6882|       |      // Flag-like argument. If the flag was unrecognized, keep it.
 6883|       |      // If it was a GoogleTest flag, remove it.
 6884|       |      if (unrecognized.contains(arg_str)) {
 6885|       |        argv[out_pos++] = argv[in_pos];
 6886|       |        continue;
 6887|       |      }
 6888|       |    }
 6889|       |
 6890|       |    if (arg_str.empty()) {
 6891|       |      ++in_pos;
 6892|       |      break;  // '--' indicates that the rest of the arguments are positional
 6893|       |    }
 6894|       |
 6895|       |    // Probably a positional argument. If it is in fact positional, keep it.
 6896|       |    // If it was a value for the flag argument, remove it.
 6897|       |    if (positional.contains(arg)) {
 6898|       |      argv[out_pos++] = arg;
 6899|       |    }
 6900|       |  }
 6901|       |
 6902|       |  // The rest are positional args for sure.
 6903|       |  while (in_pos < *argc) {
 6904|       |    argv[out_pos++] = argv[in_pos++];
 6905|       |  }
 6906|       |
 6907|       |  *argc = out_pos;
 6908|       |  argv[out_pos] = nullptr;
 6909|       |#else
 6910|      2|  ParseGoogleTestFlagsOnlyImpl(argc, argv);
 6911|      2|#endif
 6912|       |
 6913|       |  // Fix the value of *_NSGetArgc() on macOS, but if and only if
 6914|       |  // *_NSGetArgv() == argv
 6915|       |  // Only applicable to char** version of argv
 6916|       |#ifdef GTEST_OS_MAC
 6917|       |#ifndef GTEST_OS_IOS
 6918|       |  if (*_NSGetArgv() == argv) {
 6919|       |    *_NSGetArgc() = *argc;
 6920|       |  }
 6921|       |#endif
 6922|       |#endif
 6923|      2|}
_ZN7testing14InitGoogleTestEPiPPc:
 6971|      2|void InitGoogleTest(int* argc, char** argv) {
 6972|       |#if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
 6973|       |  GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(argc, argv);
 6974|       |#else   // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
 6975|      2|  internal::InitGoogleTestImpl(argc, argv);
 6976|      2|#endif  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
 6977|      2|}
gtest-all.cc:_ZN7testingL18GetDefaultFailFastEv:
  249|      2|static bool GetDefaultFailFast() {
  250|      2|  const char* const testbridge_test_runner_fail_fast =
  251|      2|      internal::posix::GetEnv("TESTBRIDGE_TEST_RUNNER_FAIL_FAST");
  252|      2|  if (testbridge_test_runner_fail_fast != nullptr) {
  ------------------
  |  Branch (252:7): [True: 0, False: 2]
  ------------------
  253|      0|    return strcmp(testbridge_test_runner_fail_fast, "1") == 0;
  254|      0|  }
  255|      2|  return false;
  256|      2|}
gtest-all.cc:_ZN7testingL16GetDefaultFilterEv:
  238|      2|static const char* GetDefaultFilter() {
  239|      2|  const char* const testbridge_test_only =
  240|      2|      internal::posix::GetEnv("TESTBRIDGE_TEST_ONLY");
  241|      2|  if (testbridge_test_only != nullptr) {
  ------------------
  |  Branch (241:7): [True: 0, False: 2]
  ------------------
  242|      0|    return testbridge_test_only;
  243|      0|  }
  244|      2|  return kUniversalFilter;
  245|      2|}
gtest-all.cc:_ZN7testing8internal12_GLOBAL__N_114UnitTestFilterC2ERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
  799|      6|  explicit UnitTestFilter(const std::string& filter) {
  800|       |    // By design "" filter matches "" string.
  801|      6|    std::vector<std::string> all_patterns;
  802|      6|    SplitString(filter, ':', &all_patterns);
  803|      6|    const auto exact_match_patterns_begin = std::partition(
  804|      6|        all_patterns.begin(), all_patterns.end(), &IsGlobPattern);
  805|       |
  806|      6|    glob_patterns_.reserve(static_cast<size_t>(
  807|      6|        std::distance(all_patterns.begin(), exact_match_patterns_begin)));
  808|      6|    std::move(all_patterns.begin(), exact_match_patterns_begin,
  809|      6|              std::inserter(glob_patterns_, glob_patterns_.begin()));
  810|      6|    std::move(
  811|      6|        exact_match_patterns_begin, all_patterns.end(),
  812|      6|        std::inserter(exact_match_patterns_, exact_match_patterns_.begin()));
  813|      6|  }
gtest-all.cc:_ZN7testing8internal12_GLOBAL__N_113IsGlobPatternERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
  789|     10|bool IsGlobPattern(const std::string& pattern) {
  790|     10|  return std::any_of(pattern.begin(), pattern.end(),
  791|     10|                     [](const char c) { return c == '?' || c == '*'; });
  792|     10|}
gtest-all.cc:_ZZN7testing8internal12_GLOBAL__N_113IsGlobPatternERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEENK3$_0clEc:
  791|     68|                     [](const char c) { return c == '?' || c == '*'; });
  ------------------
  |  Branch (791:48): [True: 0, False: 68]
  |  Branch (791:60): [True: 8, False: 60]
  ------------------
gtest-all.cc:_ZNK7testing8internal12_GLOBAL__N_114UnitTestFilter11MatchesNameERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
  817|     10|  bool MatchesName(const std::string& name) const {
  818|     10|    return exact_match_patterns_.find(name) != exact_match_patterns_.end() ||
  ------------------
  |  Branch (818:12): [True: 2, False: 8]
  ------------------
  819|      8|           std::any_of(glob_patterns_.begin(), glob_patterns_.end(),
  ------------------
  |  Branch (819:12): [True: 0, False: 8]
  ------------------
  820|      8|                       [&name](const std::string& pattern) {
  821|      8|                         return PatternMatchesString(
  822|      8|                             name, pattern.c_str(),
  823|      8|                             pattern.c_str() + pattern.size());
  824|      8|                       });
  825|     10|  }
gtest-all.cc:_ZZNK7testing8internal12_GLOBAL__N_114UnitTestFilter11MatchesNameERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEENKUlSB_E_clESB_:
  820|     12|                       [&name](const std::string& pattern) {
  821|     12|                         return PatternMatchesString(
  822|     12|                             name, pattern.c_str(),
  823|     12|                             pattern.c_str() + pattern.size());
  824|     12|                       });
gtest-all.cc:_ZN7testing8internalL20PatternMatchesStringERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPKcSB_:
  741|     12|                                 const char* pattern, const char* pattern_end) {
  742|     12|  const char* name = name_str.c_str();
  743|     12|  const char* const name_begin = name;
  744|     12|  const char* const name_end = name + name_str.size();
  745|       |
  746|     12|  const char* pattern_next = pattern;
  747|     12|  const char* name_next = name;
  748|       |
  749|    164|  while (pattern < pattern_end || name < name_end) {
  ------------------
  |  Branch (749:10): [True: 164, False: 0]
  |  Branch (749:35): [True: 0, False: 0]
  ------------------
  750|    164|    if (pattern < pattern_end) {
  ------------------
  |  Branch (750:9): [True: 164, False: 0]
  ------------------
  751|    164|      switch (*pattern) {
  752|     84|        default:  // Match an ordinary character.
  ------------------
  |  Branch (752:9): [True: 84, False: 80]
  ------------------
  753|     84|          if (name < name_end && *name == *pattern) {
  ------------------
  |  Branch (753:15): [True: 76, False: 8]
  |  Branch (753:34): [True: 0, False: 76]
  ------------------
  754|      0|            ++pattern;
  755|      0|            ++name;
  756|      0|            continue;
  757|      0|          }
  758|     84|          break;
  759|     84|        case '?':  // Match any single character.
  ------------------
  |  Branch (759:9): [True: 0, False: 164]
  ------------------
  760|      0|          if (name < name_end) {
  ------------------
  |  Branch (760:15): [True: 0, False: 0]
  ------------------
  761|      0|            ++pattern;
  762|      0|            ++name;
  763|      0|            continue;
  764|      0|          }
  765|      0|          break;
  766|     80|        case '*':
  ------------------
  |  Branch (766:9): [True: 80, False: 84]
  ------------------
  767|       |          // Match zero or more characters. Start by skipping over the wildcard
  768|       |          // and matching zero characters from name. If that fails, restart and
  769|       |          // match one more character than the last attempt.
  770|     80|          pattern_next = pattern;
  771|     80|          name_next = name + 1;
  772|     80|          ++pattern;
  773|     80|          continue;
  774|    164|      }
  775|    164|    }
  776|       |    // Failed to match a character. Restart if possible.
  777|     84|    if (name_begin < name_next && name_next <= name_end) {
  ------------------
  |  Branch (777:9): [True: 80, False: 4]
  |  Branch (777:35): [True: 72, False: 8]
  ------------------
  778|     72|      pattern = pattern_next;
  779|     72|      name = name_next;
  780|     72|      continue;
  781|     72|    }
  782|     12|    return false;
  783|     84|  }
  784|      0|  return true;
  785|     12|}
gtest-all.cc:_ZN7testing8internal12_GLOBAL__N_133PositiveAndNegativeUnitTestFilterC2ERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
  839|      2|  explicit PositiveAndNegativeUnitTestFilter(const std::string& filter) {
  840|      2|    std::vector<std::string> positive_and_negative_filters;
  841|       |
  842|       |    // NOTE: `SplitString` always returns a non-empty container.
  843|      2|    SplitString(filter, '-', &positive_and_negative_filters);
  844|      2|    const auto& positive_filter = positive_and_negative_filters.front();
  845|       |
  846|      2|    if (positive_and_negative_filters.size() > 1) {
  ------------------
  |  Branch (846:9): [True: 0, False: 2]
  ------------------
  847|      0|      positive_filter_ = UnitTestFilter(
  848|      0|          positive_filter.empty() ? kUniversalFilter : positive_filter);
  ------------------
  |  Branch (848:11): [True: 0, False: 0]
  ------------------
  849|       |
  850|       |      // TODO(b/214626361): Fail on multiple '-' characters
  851|       |      // For the moment to preserve old behavior we concatenate the rest of the
  852|       |      // string parts with `-` as separator to generate the negative filter.
  853|      0|      auto negative_filter_string = positive_and_negative_filters[1];
  854|      0|      for (std::size_t i = 2; i < positive_and_negative_filters.size(); i++)
  ------------------
  |  Branch (854:31): [True: 0, False: 0]
  ------------------
  855|      0|        negative_filter_string =
  856|      0|            negative_filter_string + '-' + positive_and_negative_filters[i];
  857|      0|      negative_filter_ = UnitTestFilter(negative_filter_string);
  858|      2|    } else {
  859|       |      // In case we don't have a negative filter and positive filter is ""
  860|       |      // we do not use kUniversalFilter by design as opposed to when we have a
  861|       |      // negative filter.
  862|      2|      positive_filter_ = UnitTestFilter(positive_filter);
  863|      2|    }
  864|      2|  }
gtest-all.cc:_ZN7testing8internal12_GLOBAL__N_114UnitTestFilterC2Ev:
  796|      4|  UnitTestFilter() = default;
gtest-all.cc:_ZNK7testing8internal12_GLOBAL__N_133PositiveAndNegativeUnitTestFilter11MatchesTestERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEESB_:
  870|      2|                   const std::string& test_name) const {
  871|      2|    return MatchesName(test_suite_name + "." + test_name);
  872|      2|  }
gtest-all.cc:_ZNK7testing8internal12_GLOBAL__N_133PositiveAndNegativeUnitTestFilter11MatchesNameERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
  876|      2|  bool MatchesName(const std::string& name) const {
  877|      2|    return positive_filter_.MatchesName(name) &&
  ------------------
  |  Branch (877:12): [True: 2, False: 0]
  ------------------
  878|      2|           !negative_filter_.MatchesName(name);
  ------------------
  |  Branch (878:12): [True: 2, False: 0]
  ------------------
  879|      2|  }
gtest-all.cc:_ZN7testing8internalL18ShouldRunTestSuiteEPKNS_9TestSuiteE:
  461|      2|static bool ShouldRunTestSuite(const TestSuite* test_suite) {
  462|      2|  return test_suite->should_run();
  463|      2|}
gtest-all.cc:_ZN7testing8internalL20SumOverTestSuiteListERKNSt3__16vectorIPNS_9TestSuiteENS1_9allocatorIS4_EEEEMS3_KFivE:
  441|      4|                                int (TestSuite::*method)() const) {
  442|      4|  int sum = 0;
  443|      8|  for (size_t i = 0; i < case_list.size(); i++) {
  ------------------
  |  Branch (443:22): [True: 4, False: 4]
  ------------------
  444|      4|    sum += (case_list[i]->*method)();
  445|      4|  }
  446|      4|  return sum;
  447|      4|}
gtest-all.cc:_ZN7testingL24ValidateTestPropertyNameERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEERKNS0_6vectorIS6_NS4_IS6_EEEE:
 2432|      2|    const std::vector<std::string>& reserved_names) {
 2433|      2|  if (std::find(reserved_names.begin(), reserved_names.end(), property_name) !=
  ------------------
  |  Branch (2433:7): [True: 0, False: 2]
  ------------------
 2434|      2|      reserved_names.end()) {
 2435|      0|    ADD_FAILURE() << "Reserved key used in RecordProperty(): " << property_name
  ------------------
  |  | 1750|      0|#define ADD_FAILURE() GTEST_NONFATAL_FAILURE_("Failed")
  |  |  ------------------
  |  |  |  | 1296|      0|  GTEST_MESSAGE_(message, ::testing::TestPartResult::kNonFatalFailure)
  |  |  |  |  ------------------
  |  |  |  |  |  | 1290|      0|  GTEST_MESSAGE_AT_(__FILE__, __LINE__, message, result_type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1286|      0|  ::testing::internal::AssertHelper(result_type, file, line, message) = \
  |  |  |  |  |  |  |  | 1287|      0|      ::testing::Message()
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2436|      0|                  << " (" << FormatWordList(reserved_names)
 2437|      0|                  << " are reserved by " << GTEST_NAME_ << ")";
  ------------------
  |  |  349|      0|#define GTEST_NAME_ "Google Test"
  ------------------
 2438|      0|    return false;
 2439|      0|  }
 2440|      2|  return true;
 2441|      2|}
gtest-all.cc:_ZN7testingL31GetReservedAttributesForElementERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE:
 2383|      2|    const std::string& xml_element) {
 2384|      2|  if (xml_element == "testsuites") {
  ------------------
  |  Branch (2384:7): [True: 0, False: 2]
  ------------------
 2385|      0|    return ArrayAsVector(kReservedTestSuitesAttributes);
 2386|      2|  } else if (xml_element == "testsuite") {
  ------------------
  |  Branch (2386:14): [True: 0, False: 2]
  ------------------
 2387|      0|    return ArrayAsVector(kReservedTestSuiteAttributes);
 2388|      2|  } else if (xml_element == "testcase") {
  ------------------
  |  Branch (2388:14): [True: 2, False: 0]
  ------------------
 2389|      2|    return ArrayAsVector(kReservedTestCaseAttributes);
 2390|      2|  } else {
 2391|      0|    GTEST_CHECK_(false) << "Unrecognized xml_element provided: " << xml_element;
  ------------------
  |  | 1087|      0|  GTEST_AMBIGUOUS_ELSE_BLOCKER_               \
  |  |  ------------------
  |  |  |  |  728|      0|  switch (0)                          \
  |  |  |  |  729|      0|  case 0:                             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (729:3): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  730|      0|  default:  // NOLINT
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (730:3): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1088|      0|  if (::testing::internal::IsTrue(condition)) \
  |  |  ------------------
  |  |  |  Branch (1088:7): [True: 0, False: 0]
  |  |  ------------------
  |  | 1089|      0|    ;                                         \
  |  | 1090|      0|  else                                        \
  |  | 1091|      0|    GTEST_LOG_(FATAL) << "Condition " #condition " failed. "
  |  |  ------------------
  |  |  |  | 1062|      0|  ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \
  |  |  |  | 1063|      0|                                __FILE__, __LINE__)                    \
  |  |  |  | 1064|      0|      .GetStream()
  |  |  ------------------
  ------------------
 2392|      0|  }
 2393|       |  // This code is unreachable but some compilers may not realizes that.
 2394|      0|  return std::vector<std::string>();
 2395|      2|}
_ZN7testing13ArrayAsVectorILm8EEENSt3__16vectorINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS6_IS8_EEEERAT__KPKc:
 2378|      2|std::vector<std::string> ArrayAsVector(const char* const (&array)[kSize]) {
 2379|      2|  return std::vector<std::string>(array, array + kSize);
 2380|      2|}
_ZN7testing8internal5TimerC2Ev:
 1188|      6|  Timer() : start_(clock::now()) {}
gtest-all.cc:_ZN7testing8internalL13ColoredPrintfENS0_12_GLOBAL__N_110GTestColorEPKcz:
 3328|     10|static void ColoredPrintf(GTestColor color, const char* fmt, ...) {
 3329|     10|  va_list args;
 3330|     10|  va_start(args, fmt);
 3331|       |
 3332|     10|  static const bool in_color_mode =
 3333|       |      // We don't condition this on GTEST_HAS_FILE_SYSTEM because we still need
 3334|       |      // to be able to detect terminal I/O regardless.
 3335|     10|      ShouldUseColor(posix::IsATTY(posix::FileNo(stdout)) != 0);
 3336|       |
 3337|     10|  const bool use_color = in_color_mode && (color != GTestColor::kDefault);
  ------------------
  |  Branch (3337:26): [True: 0, False: 10]
  |  Branch (3337:43): [True: 0, False: 0]
  ------------------
 3338|       |
 3339|     10|  if (!use_color) {
  ------------------
  |  Branch (3339:7): [True: 10, False: 0]
  ------------------
 3340|     10|    vprintf(fmt, args);
 3341|     10|    va_end(args);
 3342|     10|    return;
 3343|     10|  }
 3344|       |
 3345|       |#if defined(GTEST_OS_WINDOWS) && !defined(GTEST_OS_WINDOWS_MOBILE) &&       \
 3346|       |    !defined(GTEST_OS_WINDOWS_GAMES) && !defined(GTEST_OS_WINDOWS_PHONE) && \
 3347|       |    !defined(GTEST_OS_WINDOWS_RT) && !defined(GTEST_OS_WINDOWS_MINGW)
 3348|       |  const HANDLE stdout_handle = GetStdHandle(STD_OUTPUT_HANDLE);
 3349|       |
 3350|       |  // Gets the current text color.
 3351|       |  CONSOLE_SCREEN_BUFFER_INFO buffer_info;
 3352|       |  GetConsoleScreenBufferInfo(stdout_handle, &buffer_info);
 3353|       |  const WORD old_color_attrs = buffer_info.wAttributes;
 3354|       |  const WORD new_color = GetNewColor(color, old_color_attrs);
 3355|       |
 3356|       |  // We need to flush the stream buffers into the console before each
 3357|       |  // SetConsoleTextAttribute call lest it affect the text that is already
 3358|       |  // printed but has not yet reached the console.
 3359|       |  fflush(stdout);
 3360|       |  SetConsoleTextAttribute(stdout_handle, new_color);
 3361|       |
 3362|       |  vprintf(fmt, args);
 3363|       |
 3364|       |  fflush(stdout);
 3365|       |  // Restores the text color.
 3366|       |  SetConsoleTextAttribute(stdout_handle, old_color_attrs);
 3367|       |#else
 3368|      0|  printf("\033[0;3%sm", GetAnsiColorCode(color));
 3369|      0|  vprintf(fmt, args);
 3370|      0|  printf("\033[m");  // Resets the terminal to default.
 3371|      0|#endif  // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE
 3372|       |  va_end(args);
 3373|      0|}
gtest-all.cc:_ZN7testingL15FormatTestCountEi:
 3148|      2|static std::string FormatTestCount(int test_count) {
 3149|      2|  return FormatCountableNoun(test_count, "test", "tests");
 3150|      2|}
gtest-all.cc:_ZN7testingL20FormatTestSuiteCountEi:
 3153|      2|static std::string FormatTestSuiteCount(int test_suite_count) {
 3154|      2|  return FormatCountableNoun(test_suite_count, "test suite", "test suites");
 3155|      2|}
gtest-all.cc:_ZN7testingL19FormatCountableNounEiPKcS1_:
 3142|      6|                                       const char* plural_form) {
 3143|      6|  return internal::StreamableToString(count) + " " +
 3144|      6|         (count == 1 ? singular_form : plural_form);
  ------------------
  |  Branch (3144:11): [True: 6, False: 0]
  ------------------
 3145|      6|}
_ZN7testing8internal27PrettyUnitTestResultPrinter13PrintTestNameEPKcS3_:
 3402|      2|  static void PrintTestName(const char* test_suite, const char* test) {
 3403|      2|    printf("%s.%s", test_suite, test);
 3404|      2|  }
_ZN7testing8internal17TestEventRepeaterC2Ev:
 3814|      2|  TestEventRepeater() : forwarding_enabled_(true) {}
_ZN7testing8internal23ScopedPrematureExitFileC2EPKc:
 5133|      2|      : premature_exit_filepath_(
 5134|      2|            premature_exit_filepath ? premature_exit_filepath : "") {
  ------------------
  |  Branch (5134:13): [True: 0, False: 2]
  ------------------
 5135|       |    // If a path to the premature-exit file is specified...
 5136|      2|    if (!premature_exit_filepath_.empty()) {
  ------------------
  |  Branch (5136:9): [True: 0, False: 2]
  ------------------
 5137|       |      // create the file with a single "0" character in it.  I/O
 5138|       |      // errors are ignored as there's nothing better we can do and we
 5139|       |      // don't want to fail the test because of this.
 5140|      0|      FILE* pfile = posix::FOpen(premature_exit_filepath_.c_str(), "w");
 5141|      0|      fwrite("0", 1, 1, pfile);
 5142|      0|      fclose(pfile);
 5143|      0|    }
 5144|      2|  }
_ZN7testing8internal27PrettyUnitTestResultPrinterC2Ev:
 3401|      2|  PrettyUnitTestResultPrinter() = default;
gtest-all.cc:_ZN7testing8internalL18GTestIsInitializedEv:
  435|      4|static bool GTestIsInitialized() { return !GetArgvs().empty(); }
gtest-all.cc:_ZN7testing8internalL14ParseFlagValueEPKcS2_b:
 6513|    299|                                  bool def_optional) {
 6514|       |  // str and flag must not be NULL.
 6515|    299|  if (str == nullptr || flag_name == nullptr) return nullptr;
  ------------------
  |  Branch (6515:7): [True: 0, False: 299]
  |  Branch (6515:25): [True: 0, False: 299]
  ------------------
 6516|       |
 6517|       |  // The flag must start with "--" followed by GTEST_FLAG_PREFIX_.
 6518|    299|  const std::string flag_str =
 6519|    299|      std::string("--") + GTEST_FLAG_PREFIX_ + flag_name;
  ------------------
  |  |  346|    299|#define GTEST_FLAG_PREFIX_ "gtest_"
  ------------------
 6520|    299|  const size_t flag_len = flag_str.length();
 6521|    299|  if (strncmp(str, flag_str.c_str(), flag_len) != 0) return nullptr;
  ------------------
  |  Branch (6521:7): [True: 299, False: 0]
  ------------------
 6522|       |
 6523|       |  // Skips the flag name.
 6524|      0|  const char* flag_end = str + flag_len;
 6525|       |
 6526|       |  // When def_optional is true, it's OK to not have a "=value" part.
 6527|      0|  if (def_optional && (flag_end[0] == '\0')) {
  ------------------
  |  Branch (6527:7): [True: 0, False: 0]
  |  Branch (6527:23): [True: 0, False: 0]
  ------------------
 6528|      0|    return flag_end;
 6529|      0|  }
 6530|       |
 6531|       |  // If def_optional is true and there are more characters after the
 6532|       |  // flag name, or if def_optional is false, there must be a '=' after
 6533|       |  // the flag name.
 6534|      0|  if (flag_end[0] != '=') return nullptr;
  ------------------
  |  Branch (6534:7): [True: 0, False: 0]
  ------------------
 6535|       |
 6536|       |  // Returns the string after "=".
 6537|      0|  return flag_end + 1;
 6538|      0|}
_ZN7testing8internal27PrettyUnitTestResultPrinter18OnTestProgramStartERKNS_8UnitTestE:
 3407|      2|  void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
_ZN7testing8internal27PrettyUnitTestResultPrinter22OnEnvironmentsSetUpEndERKNS_8UnitTestE:
 3410|      2|  void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) override {}
_ZN7testing8internal35HandleExceptionsInMethodIfSupportedINS_4TestEvEET0_PT_MS4_FS3_vEPKc:
 2673|      4|                                           const char* location) {
 2674|       |  // NOTE: The user code can affect the way in which Google Test handles
 2675|       |  // exceptions by setting GTEST_FLAG(catch_exceptions), but only before
 2676|       |  // RUN_ALL_TESTS() starts. It is technically possible to check the flag
 2677|       |  // after the exception is caught and either report or re-throw the
 2678|       |  // exception based on the flag's value:
 2679|       |  //
 2680|       |  // try {
 2681|       |  //   // Perform the test method.
 2682|       |  // } catch (...) {
 2683|       |  //   if (GTEST_FLAG_GET(catch_exceptions))
 2684|       |  //     // Report the exception as failure.
 2685|       |  //   else
 2686|       |  //     throw;  // Re-throws the original exception.
 2687|       |  // }
 2688|       |  //
 2689|       |  // However, the purpose of this flag is to allow the program to drop into
 2690|       |  // the debugger when the exception is thrown. On most platforms, once the
 2691|       |  // control enters the catch block, the exception origin information is
 2692|       |  // lost and the debugger will stop the program at the point of the
 2693|       |  // re-throw in this function -- instead of at the point of the original
 2694|       |  // throw statement in the code under test.  For this reason, we perform
 2695|       |  // the check early, sacrificing the ability to affect Google Test's
 2696|       |  // exception handling in the method where the exception is thrown.
 2697|      4|  if (internal::GetUnitTestImpl()->catch_exceptions()) {
  ------------------
  |  Branch (2697:7): [True: 4, False: 0]
  ------------------
 2698|      4|#if GTEST_HAS_EXCEPTIONS
 2699|      4|    try {
 2700|      4|      return HandleSehExceptionsInMethodIfSupported(object, method, location);
 2701|      4|    } catch (const AssertionException&) {  // NOLINT
 2702|       |      // This failure was reported already.
 2703|      0|    } catch (const internal::GoogleTestFailureException&) {  // NOLINT
 2704|       |      // This exception type can only be thrown by a failed Google
 2705|       |      // Test assertion with the intention of letting another testing
 2706|       |      // framework catch it.  Therefore we just re-throw it.
 2707|      0|      throw;
 2708|      0|    } catch (const std::exception& e) {  // NOLINT
 2709|      0|      internal::ReportFailureInUnknownLocation(
 2710|      0|          TestPartResult::kFatalFailure,
 2711|      0|          FormatCxxExceptionMessage(e.what(), location));
 2712|      0|    } catch (...) {  // NOLINT
 2713|      0|      internal::ReportFailureInUnknownLocation(
 2714|      0|          TestPartResult::kFatalFailure,
 2715|      0|          FormatCxxExceptionMessage(nullptr, location));
 2716|      0|    }
 2717|      0|    return static_cast<Result>(0);
 2718|       |#else
 2719|       |    return HandleSehExceptionsInMethodIfSupported(object, method, location);
 2720|       |#endif  // GTEST_HAS_EXCEPTIONS
 2721|      4|  } else {
 2722|      0|    return (object->*method)();
 2723|      0|  }
 2724|      4|}
_ZN7testing8internal38HandleSehExceptionsInMethodIfSupportedINS_4TestEvEET0_PT_MS4_FS3_vEPKc:
 2654|      4|                                              const char* location) {
 2655|       |#if GTEST_HAS_SEH
 2656|       |  __try {
 2657|       |    return (object->*method)();
 2658|       |  } __except (internal::UnitTestOptions::GTestProcessSEH(  // NOLINT
 2659|       |      GetExceptionCode(), location)) {
 2660|       |    return static_cast<Result>(0);
 2661|       |  }
 2662|       |#else
 2663|      4|  (void)location;
 2664|      4|  return (object->*method)();
 2665|      4|#endif  // GTEST_HAS_SEH
 2666|      4|}
_ZN7testing8internal35HandleExceptionsInMethodIfSupportedINS0_15TestFactoryBaseEPNS_4TestEEET0_PT_MS6_FS5_vEPKc:
 2673|      2|                                           const char* location) {
 2674|       |  // NOTE: The user code can affect the way in which Google Test handles
 2675|       |  // exceptions by setting GTEST_FLAG(catch_exceptions), but only before
 2676|       |  // RUN_ALL_TESTS() starts. It is technically possible to check the flag
 2677|       |  // after the exception is caught and either report or re-throw the
 2678|       |  // exception based on the flag's value:
 2679|       |  //
 2680|       |  // try {
 2681|       |  //   // Perform the test method.
 2682|       |  // } catch (...) {
 2683|       |  //   if (GTEST_FLAG_GET(catch_exceptions))
 2684|       |  //     // Report the exception as failure.
 2685|       |  //   else
 2686|       |  //     throw;  // Re-throws the original exception.
 2687|       |  // }
 2688|       |  //
 2689|       |  // However, the purpose of this flag is to allow the program to drop into
 2690|       |  // the debugger when the exception is thrown. On most platforms, once the
 2691|       |  // control enters the catch block, the exception origin information is
 2692|       |  // lost and the debugger will stop the program at the point of the
 2693|       |  // re-throw in this function -- instead of at the point of the original
 2694|       |  // throw statement in the code under test.  For this reason, we perform
 2695|       |  // the check early, sacrificing the ability to affect Google Test's
 2696|       |  // exception handling in the method where the exception is thrown.
 2697|      2|  if (internal::GetUnitTestImpl()->catch_exceptions()) {
  ------------------
  |  Branch (2697:7): [True: 2, False: 0]
  ------------------
 2698|      2|#if GTEST_HAS_EXCEPTIONS
 2699|      2|    try {
 2700|      2|      return HandleSehExceptionsInMethodIfSupported(object, method, location);
 2701|      2|    } catch (const AssertionException&) {  // NOLINT
 2702|       |      // This failure was reported already.
 2703|      0|    } catch (const internal::GoogleTestFailureException&) {  // NOLINT
 2704|       |      // This exception type can only be thrown by a failed Google
 2705|       |      // Test assertion with the intention of letting another testing
 2706|       |      // framework catch it.  Therefore we just re-throw it.
 2707|      0|      throw;
 2708|      0|    } catch (const std::exception& e) {  // NOLINT
 2709|      0|      internal::ReportFailureInUnknownLocation(
 2710|      0|          TestPartResult::kFatalFailure,
 2711|      0|          FormatCxxExceptionMessage(e.what(), location));
 2712|      0|    } catch (...) {  // NOLINT
 2713|      0|      internal::ReportFailureInUnknownLocation(
 2714|      0|          TestPartResult::kFatalFailure,
 2715|      0|          FormatCxxExceptionMessage(nullptr, location));
 2716|      0|    }
 2717|      0|    return static_cast<Result>(0);
 2718|       |#else
 2719|       |    return HandleSehExceptionsInMethodIfSupported(object, method, location);
 2720|       |#endif  // GTEST_HAS_EXCEPTIONS
 2721|      2|  } else {
 2722|      0|    return (object->*method)();
 2723|      0|  }
 2724|      2|}
_ZN7testing8internal38HandleSehExceptionsInMethodIfSupportedINS0_15TestFactoryBaseEPNS_4TestEEET0_PT_MS6_FS5_vEPKc:
 2654|      2|                                              const char* location) {
 2655|       |#if GTEST_HAS_SEH
 2656|       |  __try {
 2657|       |    return (object->*method)();
 2658|       |  } __except (internal::UnitTestOptions::GTestProcessSEH(  // NOLINT
 2659|       |      GetExceptionCode(), location)) {
 2660|       |    return static_cast<Result>(0);
 2661|       |  }
 2662|       |#else
 2663|      2|  (void)location;
 2664|      2|  return (object->*method)();
 2665|      2|#endif  // GTEST_HAS_SEH
 2666|      2|}
_ZN7testing8internal35HandleExceptionsInMethodIfSupportedINS_9TestSuiteEvEET0_PT_MS4_FS3_vEPKc:
 2673|      2|                                           const char* location) {
 2674|       |  // NOTE: The user code can affect the way in which Google Test handles
 2675|       |  // exceptions by setting GTEST_FLAG(catch_exceptions), but only before
 2676|       |  // RUN_ALL_TESTS() starts. It is technically possible to check the flag
 2677|       |  // after the exception is caught and either report or re-throw the
 2678|       |  // exception based on the flag's value:
 2679|       |  //
 2680|       |  // try {
 2681|       |  //   // Perform the test method.
 2682|       |  // } catch (...) {
 2683|       |  //   if (GTEST_FLAG_GET(catch_exceptions))
 2684|       |  //     // Report the exception as failure.
 2685|       |  //   else
 2686|       |  //     throw;  // Re-throws the original exception.
 2687|       |  // }
 2688|       |  //
 2689|       |  // However, the purpose of this flag is to allow the program to drop into
 2690|       |  // the debugger when the exception is thrown. On most platforms, once the
 2691|       |  // control enters the catch block, the exception origin information is
 2692|       |  // lost and the debugger will stop the program at the point of the
 2693|       |  // re-throw in this function -- instead of at the point of the original
 2694|       |  // throw statement in the code under test.  For this reason, we perform
 2695|       |  // the check early, sacrificing the ability to affect Google Test's
 2696|       |  // exception handling in the method where the exception is thrown.
 2697|      2|  if (internal::GetUnitTestImpl()->catch_exceptions()) {
  ------------------
  |  Branch (2697:7): [True: 2, False: 0]
  ------------------
 2698|      2|#if GTEST_HAS_EXCEPTIONS
 2699|      2|    try {
 2700|      2|      return HandleSehExceptionsInMethodIfSupported(object, method, location);
 2701|      2|    } catch (const AssertionException&) {  // NOLINT
 2702|       |      // This failure was reported already.
 2703|      0|    } catch (const internal::GoogleTestFailureException&) {  // NOLINT
 2704|       |      // This exception type can only be thrown by a failed Google
 2705|       |      // Test assertion with the intention of letting another testing
 2706|       |      // framework catch it.  Therefore we just re-throw it.
 2707|      0|      throw;
 2708|      0|    } catch (const std::exception& e) {  // NOLINT
 2709|      0|      internal::ReportFailureInUnknownLocation(
 2710|      0|          TestPartResult::kFatalFailure,
 2711|      0|          FormatCxxExceptionMessage(e.what(), location));
 2712|      0|    } catch (...) {  // NOLINT
 2713|      0|      internal::ReportFailureInUnknownLocation(
 2714|      0|          TestPartResult::kFatalFailure,
 2715|      0|          FormatCxxExceptionMessage(nullptr, location));
 2716|      0|    }
 2717|      0|    return static_cast<Result>(0);
 2718|       |#else
 2719|       |    return HandleSehExceptionsInMethodIfSupported(object, method, location);
 2720|       |#endif  // GTEST_HAS_EXCEPTIONS
 2721|      2|  } else {
 2722|      0|    return (object->*method)();
 2723|      0|  }
 2724|      2|}
_ZN7testing8internal38HandleSehExceptionsInMethodIfSupportedINS_9TestSuiteEvEET0_PT_MS4_FS3_vEPKc:
 2654|      2|                                              const char* location) {
 2655|       |#if GTEST_HAS_SEH
 2656|       |  __try {
 2657|       |    return (object->*method)();
 2658|       |  } __except (internal::UnitTestOptions::GTestProcessSEH(  // NOLINT
 2659|       |      GetExceptionCode(), location)) {
 2660|       |    return static_cast<Result>(0);
 2661|       |  }
 2662|       |#else
 2663|      2|  (void)location;
 2664|      2|  return (object->*method)();
 2665|      2|#endif  // GTEST_HAS_SEH
 2666|      2|}
_ZN7testing8internal35HandleExceptionsInMethodIfSupportedINS0_12UnitTestImplEbEET0_PT_MS4_FS3_vEPKc:
 2673|      2|                                           const char* location) {
 2674|       |  // NOTE: The user code can affect the way in which Google Test handles
 2675|       |  // exceptions by setting GTEST_FLAG(catch_exceptions), but only before
 2676|       |  // RUN_ALL_TESTS() starts. It is technically possible to check the flag
 2677|       |  // after the exception is caught and either report or re-throw the
 2678|       |  // exception based on the flag's value:
 2679|       |  //
 2680|       |  // try {
 2681|       |  //   // Perform the test method.
 2682|       |  // } catch (...) {
 2683|       |  //   if (GTEST_FLAG_GET(catch_exceptions))
 2684|       |  //     // Report the exception as failure.
 2685|       |  //   else
 2686|       |  //     throw;  // Re-throws the original exception.
 2687|       |  // }
 2688|       |  //
 2689|       |  // However, the purpose of this flag is to allow the program to drop into
 2690|       |  // the debugger when the exception is thrown. On most platforms, once the
 2691|       |  // control enters the catch block, the exception origin information is
 2692|       |  // lost and the debugger will stop the program at the point of the
 2693|       |  // re-throw in this function -- instead of at the point of the original
 2694|       |  // throw statement in the code under test.  For this reason, we perform
 2695|       |  // the check early, sacrificing the ability to affect Google Test's
 2696|       |  // exception handling in the method where the exception is thrown.
 2697|      2|  if (internal::GetUnitTestImpl()->catch_exceptions()) {
  ------------------
  |  Branch (2697:7): [True: 2, False: 0]
  ------------------
 2698|      2|#if GTEST_HAS_EXCEPTIONS
 2699|      2|    try {
 2700|      2|      return HandleSehExceptionsInMethodIfSupported(object, method, location);
 2701|      2|    } catch (const AssertionException&) {  // NOLINT
 2702|       |      // This failure was reported already.
 2703|      0|    } catch (const internal::GoogleTestFailureException&) {  // NOLINT
 2704|       |      // This exception type can only be thrown by a failed Google
 2705|       |      // Test assertion with the intention of letting another testing
 2706|       |      // framework catch it.  Therefore we just re-throw it.
 2707|      0|      throw;
 2708|      0|    } catch (const std::exception& e) {  // NOLINT
 2709|      0|      internal::ReportFailureInUnknownLocation(
 2710|      0|          TestPartResult::kFatalFailure,
 2711|      0|          FormatCxxExceptionMessage(e.what(), location));
 2712|      0|    } catch (...) {  // NOLINT
 2713|      0|      internal::ReportFailureInUnknownLocation(
 2714|      0|          TestPartResult::kFatalFailure,
 2715|      0|          FormatCxxExceptionMessage(nullptr, location));
 2716|      0|    }
 2717|      0|    return static_cast<Result>(0);
 2718|       |#else
 2719|       |    return HandleSehExceptionsInMethodIfSupported(object, method, location);
 2720|       |#endif  // GTEST_HAS_EXCEPTIONS
 2721|      2|  } else {
 2722|      0|    return (object->*method)();
 2723|      0|  }
 2724|      2|}
_ZN7testing8internal38HandleSehExceptionsInMethodIfSupportedINS0_12UnitTestImplEbEET0_PT_MS4_FS3_vEPKc:
 2654|      2|                                              const char* location) {
 2655|       |#if GTEST_HAS_SEH
 2656|       |  __try {
 2657|       |    return (object->*method)();
 2658|       |  } __except (internal::UnitTestOptions::GTestProcessSEH(  // NOLINT
 2659|       |      GetExceptionCode(), location)) {
 2660|       |    return static_cast<Result>(0);
 2661|       |  }
 2662|       |#else
 2663|      2|  (void)location;
 2664|      2|  return (object->*method)();
 2665|      2|#endif  // GTEST_HAS_SEH
 2666|      2|}
_ZN7testing8internal28ParseGoogleTestFlagsOnlyImplIcEEvPiPPT_:
 6805|      2|void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
 6806|      2|  std::string flagfile_value;
 6807|     15|  for (int i = 1; i < *argc; i++) {
  ------------------
  |  Branch (6807:19): [True: 13, False: 2]
  ------------------
 6808|     13|    const std::string arg_string = StreamableToString(argv[i]);
 6809|     13|    const char* const arg = arg_string.c_str();
 6810|       |
 6811|     13|    using internal::ParseFlag;
 6812|       |
 6813|     13|    bool remove_flag = false;
 6814|     13|    if (ParseGoogleTestFlag(arg)) {
  ------------------
  |  Branch (6814:9): [True: 0, False: 13]
  ------------------
 6815|      0|      remove_flag = true;
 6816|      0|#if GTEST_USE_OWN_FLAGFILE_FLAG_ && GTEST_HAS_FILE_SYSTEM
 6817|     13|    } else if (ParseFlag(arg, "flagfile", &flagfile_value)) {
  ------------------
  |  Branch (6817:16): [True: 0, False: 13]
  ------------------
 6818|      0|      GTEST_FLAG_SET(flagfile, flagfile_value);
  ------------------
  |  | 2311|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  ------------------
  |  |  |  | 2242|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
 6819|      0|      LoadFlagsFromFile(flagfile_value);
 6820|      0|      remove_flag = true;
 6821|      0|#endif  // GTEST_USE_OWN_FLAGFILE_FLAG_ && GTEST_HAS_FILE_SYSTEM
 6822|     13|    } else if (arg_string == "--help" || HasGoogleTestFlagPrefix(arg)) {
  ------------------
  |  Branch (6822:16): [True: 0, False: 13]
  |  Branch (6822:42): [True: 0, False: 13]
  ------------------
 6823|       |      // Both help flag and unrecognized Google Test flags (excluding
 6824|       |      // internal ones) trigger help display.
 6825|      0|      g_help_flag = true;
 6826|      0|    }
 6827|       |
 6828|     13|    if (remove_flag) {
  ------------------
  |  Branch (6828:9): [True: 0, False: 13]
  ------------------
 6829|       |      // Shift the remainder of the argv list left by one.
 6830|      0|      for (int j = i + 1; j < *argc; ++j) {
  ------------------
  |  Branch (6830:27): [True: 0, False: 0]
  ------------------
 6831|      0|        argv[j - 1] = argv[j];
 6832|      0|      }
 6833|       |
 6834|       |      // Decrements the argument count.
 6835|      0|      (*argc)--;
 6836|       |
 6837|       |      // Terminate the array with nullptr.
 6838|      0|      argv[*argc] = nullptr;
 6839|       |
 6840|       |      // We also need to decrement the iterator as we just removed
 6841|       |      // an element.
 6842|      0|      i--;
 6843|      0|    }
 6844|     13|  }
 6845|       |
 6846|      2|  if (g_help_flag) {
  ------------------
  |  Branch (6846:7): [True: 0, False: 2]
  ------------------
 6847|       |    // We print the help here instead of in RUN_ALL_TESTS(), as the
 6848|       |    // latter may not be called at all if the user is using Google
 6849|       |    // Test with another testing framework.
 6850|      0|    PrintColorEncoded(kColorEncodedHelpMessage);
 6851|      0|  }
 6852|      2|}
gtest-all.cc:_ZN7testing8internalL19ParseGoogleTestFlagEPKc:
 6748|     13|static bool ParseGoogleTestFlag(const char* const arg) {
 6749|     13|#define GTEST_INTERNAL_PARSE_FLAG(flag_name)  \
 6750|     13|  do {                                        \
 6751|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
 6752|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
 6753|     13|      GTEST_FLAG_SET(flag_name, value);       \
 6754|     13|      return true;                            \
 6755|     13|    }                                         \
 6756|     13|  } while (false)
 6757|       |
 6758|     13|  GTEST_INTERNAL_PARSE_FLAG(also_run_disabled_tests);
  ------------------
  |  | 6750|     13|  do {                                        \
  |  | 6751|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2310|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2242|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6752|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6752:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6753|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2311|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2242|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6754|      0|      return true;                            \
  |  | 6755|      0|    }                                         \
  |  | 6756|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6756:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6759|     13|  GTEST_INTERNAL_PARSE_FLAG(break_on_failure);
  ------------------
  |  | 6750|     13|  do {                                        \
  |  | 6751|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2310|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2242|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6752|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6752:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6753|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2311|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2242|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6754|      0|      return true;                            \
  |  | 6755|      0|    }                                         \
  |  | 6756|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6756:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6760|     13|  GTEST_INTERNAL_PARSE_FLAG(catch_exceptions);
  ------------------
  |  | 6750|     13|  do {                                        \
  |  | 6751|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2310|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2242|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6752|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6752:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6753|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2311|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2242|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6754|      0|      return true;                            \
  |  | 6755|      0|    }                                         \
  |  | 6756|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6756:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6761|     13|  GTEST_INTERNAL_PARSE_FLAG(color);
  ------------------
  |  | 6750|     13|  do {                                        \
  |  | 6751|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2310|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2242|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6752|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6752:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6753|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2311|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2242|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6754|      0|      return true;                            \
  |  | 6755|      0|    }                                         \
  |  | 6756|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6756:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6762|     13|  GTEST_INTERNAL_PARSE_FLAG(death_test_style);
  ------------------
  |  | 6750|     13|  do {                                        \
  |  | 6751|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2310|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2242|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6752|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6752:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6753|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2311|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2242|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6754|      0|      return true;                            \
  |  | 6755|      0|    }                                         \
  |  | 6756|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6756:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6763|     13|  GTEST_INTERNAL_PARSE_FLAG(death_test_use_fork);
  ------------------
  |  | 6750|     13|  do {                                        \
  |  | 6751|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2310|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2242|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6752|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6752:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6753|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2311|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2242|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6754|      0|      return true;                            \
  |  | 6755|      0|    }                                         \
  |  | 6756|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6756:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6764|     13|  GTEST_INTERNAL_PARSE_FLAG(fail_fast);
  ------------------
  |  | 6750|     13|  do {                                        \
  |  | 6751|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2310|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2242|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6752|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6752:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6753|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2311|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2242|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6754|      0|      return true;                            \
  |  | 6755|      0|    }                                         \
  |  | 6756|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6756:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6765|     13|  GTEST_INTERNAL_PARSE_FLAG(fail_if_no_test_linked);
  ------------------
  |  | 6750|     13|  do {                                        \
  |  | 6751|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2310|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2242|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6752|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6752:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6753|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2311|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2242|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6754|      0|      return true;                            \
  |  | 6755|      0|    }                                         \
  |  | 6756|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6756:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6766|     13|  GTEST_INTERNAL_PARSE_FLAG(filter);
  ------------------
  |  | 6750|     13|  do {                                        \
  |  | 6751|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2310|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2242|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6752|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6752:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6753|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2311|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2242|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6754|      0|      return true;                            \
  |  | 6755|      0|    }                                         \
  |  | 6756|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6756:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6767|     13|  GTEST_INTERNAL_PARSE_FLAG(internal_run_death_test);
  ------------------
  |  | 6750|     13|  do {                                        \
  |  | 6751|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2310|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2242|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6752|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6752:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6753|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2311|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2242|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6754|      0|      return true;                            \
  |  | 6755|      0|    }                                         \
  |  | 6756|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6756:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6768|     13|  GTEST_INTERNAL_PARSE_FLAG(list_tests);
  ------------------
  |  | 6750|     13|  do {                                        \
  |  | 6751|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2310|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2242|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6752|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6752:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6753|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2311|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2242|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6754|      0|      return true;                            \
  |  | 6755|      0|    }                                         \
  |  | 6756|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6756:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6769|     13|  GTEST_INTERNAL_PARSE_FLAG(output);
  ------------------
  |  | 6750|     13|  do {                                        \
  |  | 6751|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2310|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2242|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6752|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6752:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6753|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2311|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2242|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6754|      0|      return true;                            \
  |  | 6755|      0|    }                                         \
  |  | 6756|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6756:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6770|     13|  GTEST_INTERNAL_PARSE_FLAG(brief);
  ------------------
  |  | 6750|     13|  do {                                        \
  |  | 6751|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2310|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2242|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6752|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6752:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6753|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2311|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2242|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6754|      0|      return true;                            \
  |  | 6755|      0|    }                                         \
  |  | 6756|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6756:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6771|     13|  GTEST_INTERNAL_PARSE_FLAG(print_time);
  ------------------
  |  | 6750|     13|  do {                                        \
  |  | 6751|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2310|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2242|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6752|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6752:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6753|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2311|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2242|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6754|      0|      return true;                            \
  |  | 6755|      0|    }                                         \
  |  | 6756|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6756:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6772|     13|  GTEST_INTERNAL_PARSE_FLAG(print_utf8);
  ------------------
  |  | 6750|     13|  do {                                        \
  |  | 6751|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2310|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2242|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6752|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6752:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6753|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2311|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2242|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6754|      0|      return true;                            \
  |  | 6755|      0|    }                                         \
  |  | 6756|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6756:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6773|     13|  GTEST_INTERNAL_PARSE_FLAG(random_seed);
  ------------------
  |  | 6750|     13|  do {                                        \
  |  | 6751|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2310|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2242|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6752|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6752:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6753|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2311|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2242|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6754|      0|      return true;                            \
  |  | 6755|      0|    }                                         \
  |  | 6756|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6756:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6774|     13|  GTEST_INTERNAL_PARSE_FLAG(repeat);
  ------------------
  |  | 6750|     13|  do {                                        \
  |  | 6751|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2310|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2242|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6752|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6752:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6753|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2311|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2242|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6754|      0|      return true;                            \
  |  | 6755|      0|    }                                         \
  |  | 6756|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6756:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6775|     13|  GTEST_INTERNAL_PARSE_FLAG(recreate_environments_when_repeating);
  ------------------
  |  | 6750|     13|  do {                                        \
  |  | 6751|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2310|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2242|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6752|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6752:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6753|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2311|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2242|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6754|      0|      return true;                            \
  |  | 6755|      0|    }                                         \
  |  | 6756|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6756:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6776|     13|  GTEST_INTERNAL_PARSE_FLAG(shuffle);
  ------------------
  |  | 6750|     13|  do {                                        \
  |  | 6751|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2310|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2242|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6752|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6752:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6753|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2311|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2242|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6754|      0|      return true;                            \
  |  | 6755|      0|    }                                         \
  |  | 6756|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6756:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6777|     13|  GTEST_INTERNAL_PARSE_FLAG(stack_trace_depth);
  ------------------
  |  | 6750|     13|  do {                                        \
  |  | 6751|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2310|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2242|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6752|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6752:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6753|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2311|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2242|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6754|      0|      return true;                            \
  |  | 6755|      0|    }                                         \
  |  | 6756|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6756:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6778|     13|  GTEST_INTERNAL_PARSE_FLAG(stream_result_to);
  ------------------
  |  | 6750|     13|  do {                                        \
  |  | 6751|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2310|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2242|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6752|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6752:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6753|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2311|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2242|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6754|      0|      return true;                            \
  |  | 6755|      0|    }                                         \
  |  | 6756|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6756:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6779|     13|  GTEST_INTERNAL_PARSE_FLAG(throw_on_failure);
  ------------------
  |  | 6750|     13|  do {                                        \
  |  | 6751|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2310|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2242|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6752|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6752:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6753|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2311|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2242|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6754|      0|      return true;                            \
  |  | 6755|      0|    }                                         \
  |  | 6756|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6756:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6780|     13|  return false;
 6781|     13|}
gtest-all.cc:_ZN7testing8internalL9ParseFlagEPKcS2_Pb:
 6550|    169|static bool ParseFlag(const char* str, const char* flag_name, bool* value) {
 6551|       |  // Gets the value of the flag as a string.
 6552|    169|  const char* const value_str = ParseFlagValue(str, flag_name, true);
 6553|       |
 6554|       |  // Aborts if the parsing failed.
 6555|    169|  if (value_str == nullptr) return false;
  ------------------
  |  Branch (6555:7): [True: 169, False: 0]
  ------------------
 6556|       |
 6557|       |  // Converts the string value to a bool.
 6558|      0|  *value = !(*value_str == '0' || *value_str == 'f' || *value_str == 'F');
  ------------------
  |  Branch (6558:14): [True: 0, False: 0]
  |  Branch (6558:35): [True: 0, False: 0]
  |  Branch (6558:56): [True: 0, False: 0]
  ------------------
 6559|      0|  return true;
 6560|    169|}
gtest-all.cc:_ZN7testing8internalL9ParseFlagINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEbPKcSA_PT_:
 6583|     91|static bool ParseFlag(const char* str, const char* flag_name, String* value) {
 6584|       |  // Gets the value of the flag as a string.
 6585|     91|  const char* const value_str = ParseFlagValue(str, flag_name, false);
 6586|       |
 6587|       |  // Aborts if the parsing failed.
 6588|     91|  if (value_str == nullptr) return false;
  ------------------
  |  Branch (6588:7): [True: 91, False: 0]
  ------------------
 6589|       |
 6590|       |  // Sets *value to the value of the flag.
 6591|      0|  *value = value_str;
 6592|      0|  return true;
 6593|     91|}
gtest-all.cc:_ZN7testing8internalL23HasGoogleTestFlagPrefixEPKc:
 6601|     13|static bool HasGoogleTestFlagPrefix(const char* str) {
 6602|     13|  return (SkipPrefix("--", &str) || SkipPrefix("-", &str) ||
  ------------------
  |  Branch (6602:11): [True: 4, False: 9]
  |  Branch (6602:37): [True: 5, False: 4]
  ------------------
 6603|      4|          SkipPrefix("/", &str)) &&
  ------------------
  |  Branch (6603:11): [True: 4, False: 0]
  ------------------
 6604|     13|         !SkipPrefix(GTEST_FLAG_PREFIX_ "internal_", &str) &&
  ------------------
  |  |  346|     13|#define GTEST_FLAG_PREFIX_ "gtest_"
  ------------------
  |  Branch (6604:10): [True: 13, False: 0]
  ------------------
 6605|     13|         (SkipPrefix(GTEST_FLAG_PREFIX_, &str) ||
  ------------------
  |  |  346|     13|#define GTEST_FLAG_PREFIX_ "gtest_"
  ------------------
  |  Branch (6605:11): [True: 0, False: 13]
  ------------------
 6606|     13|          SkipPrefix(GTEST_FLAG_PREFIX_DASH_, &str));
  ------------------
  |  |  347|     13|#define GTEST_FLAG_PREFIX_DASH_ "gtest-"
  ------------------
  |  Branch (6606:11): [True: 0, False: 13]
  ------------------
 6607|     13|}
_ZN7testing8internal18InitGoogleTestImplIcEEvPiPPT_:
 6933|      2|void InitGoogleTestImpl(int* argc, CharType** argv) {
 6934|       |  // We don't want to run the initialization code twice.
 6935|      2|  if (GTestIsInitialized()) return;
  ------------------
  |  Branch (6935:7): [True: 0, False: 2]
  ------------------
 6936|       |
 6937|      2|  if (*argc <= 0) return;
  ------------------
  |  Branch (6937:7): [True: 0, False: 2]
  ------------------
 6938|       |
 6939|      2|  g_argvs.clear();
 6940|     17|  for (int i = 0; i != *argc; i++) {
  ------------------
  |  Branch (6940:19): [True: 15, False: 2]
  ------------------
 6941|     15|    g_argvs.push_back(StreamableToString(argv[i]));
 6942|     15|  }
 6943|       |
 6944|       |#ifdef GTEST_HAS_ABSL
 6945|       |  absl::InitializeSymbolizer(g_argvs[0].c_str());
 6946|       |
 6947|       |#ifdef GTEST_HAS_ABSL_FLAGS
 6948|       |  // When using the Abseil Flags library, set the program usage message to the
 6949|       |  // help message, but remove the color-encoding from the message first.
 6950|       |  absl::SetProgramUsageMessage(absl::StrReplaceAll(
 6951|       |      kColorEncodedHelpMessage,
 6952|       |      {{"@D", ""}, {"@R", ""}, {"@G", ""}, {"@Y", ""}, {"@@", "@"}}));
 6953|       |#endif  // GTEST_HAS_ABSL_FLAGS
 6954|       |#endif  // GTEST_HAS_ABSL
 6955|       |
 6956|      2|  ParseGoogleTestFlagsOnly(argc, argv);
 6957|      2|  GetUnitTestImpl()->PostFlagParsingInit();
 6958|      2|}

webp_info_fuzzer.cc:_ZL12WebPInfoInitP8WebPInfo:
  115|  1.13k|static void WebPInfoInit(WebPInfo* const webp_info) {
  116|  1.13k|  memset(webp_info, 0, sizeof(*webp_info));
  117|  1.13k|}
webp_info_fuzzer.cc:_ZL11AnalyzeWebPP8WebPInfoPK8WebPData:
 1069|  1.13k|                                  const WebPData* webp_data) {
 1070|  1.13k|  ChunkData chunk_data;
 1071|  1.13k|  MemBuffer mem_buffer;
 1072|  1.13k|  WebPInfoStatus webp_info_status = WEBP_INFO_OK;
 1073|       |
 1074|  1.13k|  InitMemBuffer(&mem_buffer, webp_data);
 1075|  1.13k|  webp_info_status = ParseRIFFHeader(webp_info, &mem_buffer);
 1076|  1.13k|  if (webp_info_status != WEBP_INFO_OK) goto Error;
  ------------------
  |  Branch (1076:7): [True: 189, False: 944]
  ------------------
 1077|       |
 1078|       |  //  Loop through all the chunks. Terminate immediately in case of error.
 1079|  2.16k|  while (webp_info_status == WEBP_INFO_OK && MemDataSize(&mem_buffer) > 0) {
  ------------------
  |  Branch (1079:10): [True: 1.80k, False: 355]
  |  Branch (1079:46): [True: 1.34k, False: 459]
  ------------------
 1080|  1.34k|    webp_info_status = ParseChunk(webp_info, &mem_buffer, &chunk_data);
 1081|  1.34k|    if (webp_info_status != WEBP_INFO_OK) goto Error;
  ------------------
  |  Branch (1081:9): [True: 130, False: 1.21k]
  ------------------
 1082|  1.21k|    webp_info_status = ProcessChunk(&chunk_data, webp_info);
 1083|  1.21k|  }
 1084|    814|  if (webp_info_status != WEBP_INFO_OK) goto Error;
  ------------------
  |  Branch (1084:7): [True: 355, False: 459]
  ------------------
 1085|    459|  if (webp_info->show_summary) ShowSummary(webp_info);
  ------------------
  |  Branch (1085:7): [True: 0, False: 459]
  ------------------
 1086|       |
 1087|       |  //  Final check.
 1088|    459|  webp_info_status = Validate(webp_info);
 1089|       |
 1090|  1.13k|Error:
 1091|  1.13k|  if (!webp_info->quiet) {
  ------------------
  |  Branch (1091:7): [True: 0, False: 1.13k]
  ------------------
 1092|      0|    if (webp_info_status == WEBP_INFO_OK) {
  ------------------
  |  Branch (1092:9): [True: 0, False: 0]
  ------------------
 1093|      0|      printf("No error detected.\n");
 1094|      0|    } else {
 1095|      0|      printf("Errors detected.\n");
 1096|      0|    }
 1097|      0|    if (webp_info->num_warnings > 0) {
  ------------------
  |  Branch (1097:9): [True: 0, False: 0]
  ------------------
 1098|      0|      printf("There were %d warning(s).\n", webp_info->num_warnings);
 1099|      0|    }
 1100|      0|  }
 1101|  1.13k|  return webp_info_status;
 1102|    459|}
webp_info_fuzzer.cc:_ZL13InitMemBufferP9MemBufferPK8WebPData:
  177|  1.13k|static void InitMemBuffer(MemBuffer* const mem, const WebPData* webp_data) {
  178|  1.13k|  mem->buf = webp_data->bytes;
  179|  1.13k|  mem->start = 0;
  180|  1.13k|  mem->end = webp_data->size;
  181|  1.13k|}
webp_info_fuzzer.cc:_ZL15ParseRIFFHeaderP8WebPInfoP9MemBuffer:
  578|  1.13k|                                      MemBuffer* const mem) {
  579|  1.13k|  const size_t min_size = RIFF_HEADER_SIZE + CHUNK_HEADER_SIZE;
  ------------------
  |  |   83|  1.13k|#define RIFF_HEADER_SIZE 12  // Size of the RIFF header ("RIFFnnnnWEBP").
  ------------------
                const size_t min_size = RIFF_HEADER_SIZE + CHUNK_HEADER_SIZE;
  ------------------
  |  |   82|  1.13k|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  580|  1.13k|  size_t riff_size;
  581|       |
  582|  1.13k|  if (MemDataSize(mem) < min_size) {
  ------------------
  |  Branch (582:7): [True: 26, False: 1.10k]
  ------------------
  583|     26|    LOG_ERROR("Truncated data detected when parsing RIFF header.");
  ------------------
  |  |   36|     26|  do {                                         \
  |  |   37|     26|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 26]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|     26|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 26]
  |  |  ------------------
  ------------------
  584|     26|    return WEBP_INFO_TRUNCATED_DATA;
  585|     26|  }
  586|  1.10k|  if (memcmp(GetBuffer(mem), "RIFF", CHUNK_SIZE_BYTES) ||
  ------------------
  |  |   81|  1.10k|#define CHUNK_SIZE_BYTES 4   // Size needed to store chunk's size.
  ------------------
  |  Branch (586:7): [True: 68, False: 1.03k]
  ------------------
  587|  1.03k|      memcmp(GetBuffer(mem) + CHUNK_HEADER_SIZE, "WEBP", CHUNK_SIZE_BYTES)) {
  ------------------
  |  |   82|  1.03k|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
                    memcmp(GetBuffer(mem) + CHUNK_HEADER_SIZE, "WEBP", CHUNK_SIZE_BYTES)) {
  ------------------
  |  |   81|  1.03k|#define CHUNK_SIZE_BYTES 4   // Size needed to store chunk's size.
  ------------------
  |  Branch (587:7): [True: 3, False: 1.03k]
  ------------------
  588|     71|    LOG_ERROR("Corrupted RIFF header.");
  ------------------
  |  |   36|     71|  do {                                         \
  |  |   37|     71|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 71]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|     71|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 71]
  |  |  ------------------
  ------------------
  589|     71|    return WEBP_INFO_PARSE_ERROR;
  590|     71|  }
  591|  1.03k|  riff_size = GetLE32(GetBuffer(mem) + TAG_SIZE);
  ------------------
  |  |   80|  1.03k|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  592|  1.03k|  if (riff_size < CHUNK_HEADER_SIZE) {
  ------------------
  |  |   82|  1.03k|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  |  Branch (592:7): [True: 1, False: 1.03k]
  ------------------
  593|      1|    LOG_ERROR("RIFF size is too small.");
  ------------------
  |  |   36|      1|  do {                                         \
  |  |   37|      1|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 1]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      1|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 1]
  |  |  ------------------
  ------------------
  594|      1|    return WEBP_INFO_PARSE_ERROR;
  595|      1|  }
  596|  1.03k|  if (riff_size > MAX_CHUNK_PAYLOAD) {
  ------------------
  |  |   96|  1.03k|#define MAX_CHUNK_PAYLOAD (~0U - CHUNK_HEADER_SIZE - 1)
  |  |  ------------------
  |  |  |  |   82|  1.03k|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  |  |  ------------------
  ------------------
  |  Branch (596:7): [True: 1, False: 1.03k]
  ------------------
  597|      1|    LOG_ERROR("RIFF size is over limit.");
  ------------------
  |  |   36|      1|  do {                                         \
  |  |   37|      1|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 1]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      1|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 1]
  |  |  ------------------
  ------------------
  598|      1|    return WEBP_INFO_PARSE_ERROR;
  599|      1|  }
  600|  1.03k|  riff_size += CHUNK_HEADER_SIZE;
  ------------------
  |  |   82|  1.03k|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  601|  1.03k|  if (!webp_info->quiet) {
  ------------------
  |  Branch (601:7): [True: 0, False: 1.03k]
  ------------------
  602|      0|    printf("RIFF HEADER:\n");
  603|      0|    printf("  File size: %6d\n", (int)riff_size);
  604|      0|  }
  605|  1.03k|  if (riff_size < mem->end) {
  ------------------
  |  Branch (605:7): [True: 12, False: 1.02k]
  ------------------
  606|     12|    LOG_WARN("RIFF size is smaller than the file size.");
  ------------------
  |  |   43|     12|  do {                                           \
  |  |   44|     12|    if (webp_info->show_diagnosis) {             \
  |  |  ------------------
  |  |  |  Branch (44:9): [True: 0, False: 12]
  |  |  ------------------
  |  |   45|      0|      fprintf(stderr, "Warning: %s\n", MESSAGE); \
  |  |   46|      0|    }                                            \
  |  |   47|     12|    ++webp_info->num_warnings;                   \
  |  |   48|     12|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded, False: 12]
  |  |  ------------------
  ------------------
  607|     12|    mem->end = riff_size;
  608|  1.02k|  } else if (riff_size > mem->end) {
  ------------------
  |  Branch (608:14): [True: 90, False: 932]
  ------------------
  609|     90|    LOG_ERROR("Truncated data detected when parsing RIFF payload.");
  ------------------
  |  |   36|     90|  do {                                         \
  |  |   37|     90|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 90]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|     90|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 90]
  |  |  ------------------
  ------------------
  610|     90|    return WEBP_INFO_TRUNCATED_DATA;
  611|     90|  }
  612|    944|  Skip(mem, RIFF_HEADER_SIZE);
  ------------------
  |  |   83|    944|#define RIFF_HEADER_SIZE 12  // Size of the RIFF header ("RIFFnnnnWEBP").
  ------------------
  613|    944|  return WEBP_INFO_OK;
  614|  1.03k|}
webp_info_fuzzer.cc:_ZL9GetBufferP9MemBuffer:
  187|  4.39k|static const uint8_t* GetBuffer(MemBuffer* const mem) {
  188|  4.39k|  return mem->buf + mem->start;
  189|  4.39k|}
webp_info_fuzzer.cc:_ZL7GetLE32PKh:
  142|  3.65k|static uint32_t GetLE32(const uint8_t* const data) {
  143|  3.65k|  return GetLE16(data) | ((uint32_t)GetLE16(data + 2) << 16);
  144|  3.65k|}
webp_info_fuzzer.cc:_ZL7GetLE16PKh:
  134|  7.48k|static int GetLE16(const uint8_t* const data) {
  135|  7.48k|  return (data[0] << 0) | (data[1] << 8);
  136|  7.48k|}
webp_info_fuzzer.cc:_ZL4SkipP9MemBufferm:
  191|  4.77k|static void Skip(MemBuffer* const mem, size_t size) { mem->start += size; }
webp_info_fuzzer.cc:_ZL11MemDataSizePK9MemBuffer:
  183|  5.59k|static size_t MemDataSize(const MemBuffer* const mem) {
  184|  5.59k|  return (mem->end - mem->start);
  185|  5.59k|}
webp_info_fuzzer.cc:_ZL10ParseChunkPK8WebPInfoP9MemBufferP9ChunkData:
  618|  1.34k|                                 ChunkData* const chunk_data) {
  619|  1.34k|  memset(chunk_data, 0, sizeof(*chunk_data));
  620|  1.34k|  if (MemDataSize(mem) < CHUNK_HEADER_SIZE) {
  ------------------
  |  |   82|  1.34k|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  |  Branch (620:7): [True: 39, False: 1.30k]
  ------------------
  621|     39|    LOG_ERROR("Truncated data detected when parsing chunk header.");
  ------------------
  |  |   36|     39|  do {                                         \
  |  |   37|     39|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 39]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|     39|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 39]
  |  |  ------------------
  ------------------
  622|     39|    return WEBP_INFO_TRUNCATED_DATA;
  623|  1.30k|  } else {
  624|  1.30k|    const size_t chunk_start_offset = mem->start;
  625|  1.30k|    const uint32_t fourcc = ReadMemBufLE32(mem);
  626|  1.30k|    const uint32_t payload_size = ReadMemBufLE32(mem);
  627|  1.30k|    const uint32_t payload_size_padded = payload_size + (payload_size & 1);
  628|  1.30k|    const size_t chunk_size = CHUNK_HEADER_SIZE + payload_size_padded;
  ------------------
  |  |   82|  1.30k|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  629|  1.30k|    int i;
  630|  1.30k|    if (payload_size > MAX_CHUNK_PAYLOAD) {
  ------------------
  |  |   96|  1.30k|#define MAX_CHUNK_PAYLOAD (~0U - CHUNK_HEADER_SIZE - 1)
  |  |  ------------------
  |  |  |  |   82|  1.30k|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  |  |  ------------------
  ------------------
  |  Branch (630:9): [True: 1, False: 1.30k]
  ------------------
  631|      1|      LOG_ERROR("Size of chunk payload is over limit.");
  ------------------
  |  |   36|      1|  do {                                         \
  |  |   37|      1|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 1]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      1|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 1]
  |  |  ------------------
  ------------------
  632|      1|      return WEBP_INFO_INVALID_PARAM;
  633|      1|    }
  634|  1.30k|    if (payload_size_padded > MemDataSize(mem)) {
  ------------------
  |  Branch (634:9): [True: 89, False: 1.21k]
  ------------------
  635|     89|      LOG_ERROR("Truncated data detected when parsing chunk payload.");
  ------------------
  |  |   36|     89|  do {                                         \
  |  |   37|     89|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 89]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|     89|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 89]
  |  |  ------------------
  ------------------
  636|     89|      return WEBP_INFO_TRUNCATED_DATA;
  637|     89|    }
  638|  7.15k|    for (i = 0; i < CHUNK_TYPES; ++i) {
  ------------------
  |  Branch (638:17): [True: 6.53k, False: 622]
  ------------------
  639|  6.53k|      if (kWebPChunkTags[i] == fourcc) break;
  ------------------
  |  Branch (639:11): [True: 595, False: 5.94k]
  ------------------
  640|  6.53k|    }
  641|  1.21k|    chunk_data->offset = chunk_start_offset;
  642|  1.21k|    chunk_data->size = chunk_size;
  643|  1.21k|    chunk_data->id = (ChunkID)i;
  644|  1.21k|    chunk_data->payload = GetBuffer(mem);
  645|  1.21k|    if (chunk_data->id == CHUNK_ANMF) {
  ------------------
  |  Branch (645:9): [True: 2, False: 1.21k]
  ------------------
  646|      2|      if (payload_size != payload_size_padded) {
  ------------------
  |  Branch (646:11): [True: 1, False: 1]
  ------------------
  647|      1|        LOG_ERROR("ANMF chunk size should always be even.");
  ------------------
  |  |   36|      1|  do {                                         \
  |  |   37|      1|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 1]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      1|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 1]
  |  |  ------------------
  ------------------
  648|      1|        return WEBP_INFO_PARSE_ERROR;
  649|      1|      }
  650|       |      // There are sub-chunks to be parsed in an ANMF chunk.
  651|      1|      Skip(mem, (payload_size >= ANMF_CHUNK_SIZE) ? ANMF_CHUNK_SIZE
  ------------------
  |  |   84|      1|#define ANMF_CHUNK_SIZE 16   // Size of an ANMF chunk.
  ------------------
                    Skip(mem, (payload_size >= ANMF_CHUNK_SIZE) ? ANMF_CHUNK_SIZE
  ------------------
  |  |   84|      0|#define ANMF_CHUNK_SIZE 16   // Size of an ANMF chunk.
  ------------------
  |  Branch (651:17): [True: 0, False: 1]
  ------------------
  652|      1|                                                  : payload_size_padded);
  653|  1.21k|    } else {
  654|  1.21k|      Skip(mem, payload_size_padded);
  655|  1.21k|    }
  656|  1.21k|    return WEBP_INFO_OK;
  657|  1.21k|  }
  658|  1.34k|}
webp_info_fuzzer.cc:_ZL14ReadMemBufLE32P9MemBuffer:
  193|  2.61k|static uint32_t ReadMemBufLE32(MemBuffer* const mem) {
  194|  2.61k|  const uint8_t* const data = mem->buf + mem->start;
  195|  2.61k|  const uint32_t val = GetLE32(data);
  196|       |  assert(MemDataSize(mem) >= 4);
  197|  2.61k|  Skip(mem, 4);
  198|  2.61k|  return val;
  199|  2.61k|}
webp_info_fuzzer.cc:_ZL12ProcessChunkPK9ChunkDataP8WebPInfo:
  925|  1.21k|                                   WebPInfo* const webp_info) {
  926|  1.21k|  WebPInfoStatus status = WEBP_INFO_OK;
  927|  1.21k|  ChunkID id = chunk_data->id;
  928|  1.21k|  if (chunk_data->id == CHUNK_UNKNOWN) {
  ------------------
  |  Branch (928:7): [True: 622, False: 594]
  ------------------
  929|    622|    char error_message[50];
  930|    622|    snprintf(error_message, 50, "Unknown chunk at offset %6d, length %6d",
  931|    622|             (int)chunk_data->offset, (int)chunk_data->size);
  932|    622|    LOG_WARN(error_message);
  ------------------
  |  |   43|    622|  do {                                           \
  |  |   44|    622|    if (webp_info->show_diagnosis) {             \
  |  |  ------------------
  |  |  |  Branch (44:9): [True: 0, False: 622]
  |  |  ------------------
  |  |   45|      0|      fprintf(stderr, "Warning: %s\n", MESSAGE); \
  |  |   46|      0|    }                                            \
  |  |   47|    622|    ++webp_info->num_warnings;                   \
  |  |   48|    622|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded, False: 622]
  |  |  ------------------
  ------------------
  933|    622|  } else {
  934|    594|    if (!webp_info->quiet) {
  ------------------
  |  Branch (934:9): [True: 0, False: 594]
  ------------------
  935|      0|      char tag[4];
  936|      0|      uint32_t fourcc = kWebPChunkTags[chunk_data->id];
  937|       |#ifdef WORDS_BIGENDIAN
  938|       |      fourcc = (fourcc >> 24) | ((fourcc >> 8) & 0xff00) |
  939|       |               ((fourcc << 8) & 0xff0000) | (fourcc << 24);
  940|       |#endif
  941|      0|      memcpy(tag, &fourcc, sizeof(tag));
  942|      0|      printf("Chunk %c%c%c%c at offset %6d, length %6d\n", tag[0], tag[1],
  943|      0|             tag[2], tag[3], (int)chunk_data->offset, (int)chunk_data->size);
  944|      0|    }
  945|    594|  }
  946|  1.21k|  switch (id) {
  947|    392|    case CHUNK_VP8:
  ------------------
  |  Branch (947:5): [True: 392, False: 824]
  ------------------
  948|    482|    case CHUNK_VP8L:
  ------------------
  |  Branch (948:5): [True: 90, False: 1.12k]
  ------------------
  949|    482|      status = ProcessImageChunk(chunk_data, webp_info);
  950|    482|      break;
  951|    105|    case CHUNK_VP8X:
  ------------------
  |  Branch (951:5): [True: 105, False: 1.11k]
  ------------------
  952|    105|      status = ProcessVP8XChunk(chunk_data, webp_info);
  953|    105|      break;
  954|      1|    case CHUNK_ALPHA:
  ------------------
  |  Branch (954:5): [True: 1, False: 1.21k]
  ------------------
  955|      1|      status = ProcessALPHChunk(chunk_data, webp_info);
  956|      1|      break;
  957|      1|    case CHUNK_ANIM:
  ------------------
  |  Branch (957:5): [True: 1, False: 1.21k]
  ------------------
  958|      1|      status = ProcessANIMChunk(chunk_data, webp_info);
  959|      1|      break;
  960|      1|    case CHUNK_ANMF:
  ------------------
  |  Branch (960:5): [True: 1, False: 1.21k]
  ------------------
  961|      1|      status = ProcessANMFChunk(chunk_data, webp_info);
  962|      1|      break;
  963|      2|    case CHUNK_ICCP:
  ------------------
  |  Branch (963:5): [True: 2, False: 1.21k]
  ------------------
  964|      2|      status = ProcessICCPChunk(chunk_data, webp_info);
  965|      2|      break;
  966|      1|    case CHUNK_EXIF:
  ------------------
  |  Branch (966:5): [True: 1, False: 1.21k]
  ------------------
  967|      2|    case CHUNK_XMP:
  ------------------
  |  Branch (967:5): [True: 1, False: 1.21k]
  ------------------
  968|      2|      ++webp_info->chunk_counts[id];
  969|      2|      break;
  970|    622|    case CHUNK_UNKNOWN:
  ------------------
  |  Branch (970:5): [True: 622, False: 594]
  ------------------
  971|    622|    default:
  ------------------
  |  Branch (971:5): [True: 0, False: 1.21k]
  ------------------
  972|    622|      break;
  973|  1.21k|  }
  974|  1.21k|  if (status != WEBP_INFO_OK) return status;
  ------------------
  |  Branch (974:7): [True: 355, False: 861]
  ------------------
  975|    861|  if (webp_info->is_processing_anim_frame && id != CHUNK_ANMF) {
  ------------------
  |  Branch (975:7): [True: 0, False: 861]
  |  Branch (975:46): [True: 0, False: 0]
  ------------------
  976|      0|    if (webp_info->anim_frame_data_size == chunk_data->size) {
  ------------------
  |  Branch (976:9): [True: 0, False: 0]
  ------------------
  977|      0|      if (!webp_info->seen_image_subchunk) {
  ------------------
  |  Branch (977:11): [True: 0, False: 0]
  ------------------
  978|      0|        LOG_ERROR("No VP8/VP8L chunk detected in an ANMF chunk.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  979|      0|        return WEBP_INFO_PARSE_ERROR;
  980|      0|      }
  981|      0|      webp_info->is_processing_anim_frame = 0;
  982|      0|    } else if (webp_info->anim_frame_data_size > chunk_data->size) {
  ------------------
  |  Branch (982:16): [True: 0, False: 0]
  ------------------
  983|      0|      webp_info->anim_frame_data_size -= chunk_data->size;
  984|      0|    } else {
  985|      0|      LOG_ERROR("Truncated data detected when parsing ANMF chunk.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  986|      0|      return WEBP_INFO_TRUNCATED_DATA;
  987|      0|    }
  988|      0|  }
  989|    861|  return status;
  990|    861|}
webp_info_fuzzer.cc:_ZL17ProcessImageChunkPK9ChunkDataP8WebPInfo:
  785|    482|                                        WebPInfo* const webp_info) {
  786|    482|  const uint8_t* data = chunk_data->payload - CHUNK_HEADER_SIZE;
  ------------------
  |  |   82|    482|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  787|    482|  WebPBitstreamFeatures features;
  788|    482|  const VP8StatusCode vp8_status =
  789|    482|      WebPGetFeatures(data, chunk_data->size, &features);
  790|    482|  if (vp8_status != VP8_STATUS_OK) {
  ------------------
  |  Branch (790:7): [True: 67, False: 415]
  ------------------
  791|     67|    LOG_ERROR("VP8/VP8L bitstream error.");
  ------------------
  |  |   36|     67|  do {                                         \
  |  |   37|     67|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 67]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|     67|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 67]
  |  |  ------------------
  ------------------
  792|     67|    return WEBP_INFO_BITSTREAM_ERROR;
  793|     67|  }
  794|    415|  if (!webp_info->quiet) {
  ------------------
  |  Branch (794:7): [True: 0, False: 415]
  ------------------
  795|      0|    assert(features.format >= 0 && features.format <= 2);
  796|      0|    printf(
  797|      0|        "  Width: %d\n  Height: %d\n  Alpha: %d\n  Animation: %d\n"
  798|      0|        "  Format: %s (%d)\n",
  799|      0|        features.width, features.height, features.has_alpha,
  800|      0|        features.has_animation, kFormats[features.format], features.format);
  801|      0|  }
  802|    415|  if (webp_info->is_processing_anim_frame) {
  ------------------
  |  Branch (802:7): [True: 0, False: 415]
  ------------------
  803|      0|    ++webp_info->anmf_subchunk_counts[chunk_data->id == CHUNK_VP8 ? 0 : 1];
  ------------------
  |  Branch (803:39): [True: 0, False: 0]
  ------------------
  804|      0|    if (chunk_data->id == CHUNK_VP8L && webp_info->seen_alpha_subchunk) {
  ------------------
  |  Branch (804:9): [True: 0, False: 0]
  |  Branch (804:41): [True: 0, False: 0]
  ------------------
  805|      0|      LOG_ERROR("Both VP8L and ALPH sub-chunks are present in an ANMF chunk.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  806|      0|      return WEBP_INFO_PARSE_ERROR;
  807|      0|    }
  808|      0|    if (webp_info->frame_width != features.width ||
  ------------------
  |  Branch (808:9): [True: 0, False: 0]
  ------------------
  809|      0|        webp_info->frame_height != features.height) {
  ------------------
  |  Branch (809:9): [True: 0, False: 0]
  ------------------
  810|      0|      LOG_ERROR("Frame size in VP8/VP8L sub-chunk differs from ANMF header.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  811|      0|      return WEBP_INFO_PARSE_ERROR;
  812|      0|    }
  813|      0|    if (webp_info->seen_image_subchunk) {
  ------------------
  |  Branch (813:9): [True: 0, False: 0]
  ------------------
  814|      0|      LOG_ERROR("Consecutive VP8/VP8L sub-chunks in an ANMF chunk.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  815|      0|      return WEBP_INFO_PARSE_ERROR;
  816|      0|    }
  817|      0|    webp_info->seen_image_subchunk = 1;
  818|    415|  } else {
  819|    415|    if (webp_info->chunk_counts[CHUNK_VP8] ||
  ------------------
  |  Branch (819:9): [True: 0, False: 415]
  ------------------
  820|    415|        webp_info->chunk_counts[CHUNK_VP8L]) {
  ------------------
  |  Branch (820:9): [True: 0, False: 415]
  ------------------
  821|      0|      LOG_ERROR("Multiple VP8/VP8L chunks detected.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  822|      0|      return WEBP_INFO_PARSE_ERROR;
  823|      0|    }
  824|    415|    if (chunk_data->id == CHUNK_VP8L && webp_info->chunk_counts[CHUNK_ALPHA]) {
  ------------------
  |  Branch (824:9): [True: 79, False: 336]
  |  Branch (824:41): [True: 0, False: 79]
  ------------------
  825|      0|      LOG_WARN("Both VP8L and ALPH chunks are detected.");
  ------------------
  |  |   43|      0|  do {                                           \
  |  |   44|      0|    if (webp_info->show_diagnosis) {             \
  |  |  ------------------
  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   45|      0|      fprintf(stderr, "Warning: %s\n", MESSAGE); \
  |  |   46|      0|    }                                            \
  |  |   47|      0|    ++webp_info->num_warnings;                   \
  |  |   48|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  826|      0|    }
  827|    415|    if (webp_info->chunk_counts[CHUNK_ANIM] ||
  ------------------
  |  Branch (827:9): [True: 0, False: 415]
  ------------------
  828|    415|        webp_info->chunk_counts[CHUNK_ANMF]) {
  ------------------
  |  Branch (828:9): [True: 0, False: 415]
  ------------------
  829|      0|      LOG_ERROR("VP8/VP8L chunk and ANIM/ANMF chunk are both detected.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  830|      0|      return WEBP_INFO_PARSE_ERROR;
  831|      0|    }
  832|    415|    if (webp_info->chunk_counts[CHUNK_VP8X]) {
  ------------------
  |  Branch (832:9): [True: 0, False: 415]
  ------------------
  833|      0|      if (webp_info->canvas_width != features.width ||
  ------------------
  |  Branch (833:11): [True: 0, False: 0]
  ------------------
  834|      0|          webp_info->canvas_height != features.height) {
  ------------------
  |  Branch (834:11): [True: 0, False: 0]
  ------------------
  835|      0|        LOG_ERROR("Image size in VP8/VP8L chunk differs from VP8X chunk.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  836|      0|        return WEBP_INFO_PARSE_ERROR;
  837|      0|      }
  838|    415|    } else {
  839|    415|      webp_info->canvas_width = features.width;
  840|    415|      webp_info->canvas_height = features.height;
  841|    415|      if (webp_info->canvas_width < 1 || webp_info->canvas_height < 1 ||
  ------------------
  |  Branch (841:11): [True: 0, False: 415]
  |  Branch (841:42): [True: 0, False: 415]
  ------------------
  842|    415|          webp_info->canvas_width > MAX_CANVAS_SIZE ||
  ------------------
  |  |   88|    830|#define MAX_CANVAS_SIZE (1 << 24)      // 24-bit max for VP8X width/height.
  ------------------
  |  Branch (842:11): [True: 0, False: 415]
  ------------------
  843|    415|          webp_info->canvas_height > MAX_CANVAS_SIZE ||
  ------------------
  |  |   88|    830|#define MAX_CANVAS_SIZE (1 << 24)      // 24-bit max for VP8X width/height.
  ------------------
  |  Branch (843:11): [True: 0, False: 415]
  ------------------
  844|    415|          (uint64_t)webp_info->canvas_width * webp_info->canvas_height >
  ------------------
  |  Branch (844:11): [True: 0, False: 415]
  ------------------
  845|    415|              MAX_IMAGE_AREA) {
  ------------------
  |  |   89|    415|#define MAX_IMAGE_AREA (1ULL << 32)    // 32-bit max for width x height.
  ------------------
  846|      0|        LOG_WARN("Invalid parameters in VP8/VP8L chunk.");
  ------------------
  |  |   43|      0|  do {                                           \
  |  |   44|      0|    if (webp_info->show_diagnosis) {             \
  |  |  ------------------
  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   45|      0|      fprintf(stderr, "Warning: %s\n", MESSAGE); \
  |  |   46|      0|    }                                            \
  |  |   47|      0|    ++webp_info->num_warnings;                   \
  |  |   48|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  847|      0|      }
  848|    415|    }
  849|    415|    ++webp_info->chunk_counts[chunk_data->id];
  850|    415|  }
  851|    415|  ++webp_info->num_frames;
  852|    415|  webp_info->has_alpha |= features.has_alpha;
  853|    415|  if (webp_info->parse_bitstream) {
  ------------------
  |  Branch (853:7): [True: 415, False: 0]
  ------------------
  854|    415|    const int is_lossy = (chunk_data->id == CHUNK_VP8);
  855|    415|    const WebPInfoStatus status =
  856|    415|        is_lossy ? ParseLossyHeader(chunk_data, webp_info)
  ------------------
  |  Branch (856:9): [True: 336, False: 79]
  ------------------
  857|    415|                 : ParseLosslessHeader(chunk_data, webp_info);
  858|    415|    if (status != WEBP_INFO_OK) return status;
  ------------------
  |  Branch (858:9): [True: 272, False: 143]
  ------------------
  859|    415|  }
  860|    143|  return WEBP_INFO_OK;
  861|    415|}
webp_info_fuzzer.cc:_ZL16ParseLossyHeaderPK9ChunkDataPK8WebPInfo:
  325|    336|                                       const WebPInfo* const webp_info) {
  326|    336|  const uint8_t* data = chunk_data->payload;
  327|    336|  size_t data_size = chunk_data->size - CHUNK_HEADER_SIZE;
  ------------------
  |  |   82|    336|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  328|    336|  const uint32_t bits = (uint32_t)data[0] | (data[1] << 8) | (data[2] << 16);
  329|    336|  const int key_frame = !(bits & 1);
  330|    336|  const int profile = (bits >> 1) & 7;
  331|    336|  const int display = (bits >> 4) & 1;
  332|    336|  const uint32_t partition0_length = (bits >> 5);
  333|    336|  WebPInfoStatus status = WEBP_INFO_OK;
  334|    336|  uint64_t bit_position = 0;
  335|    336|  uint64_t* const bit_pos = &bit_position;
  336|    336|  int colorspace, clamp_type;
  337|    336|  printf("  Parsing lossy bitstream...\n");
  338|       |  // Calling WebPGetFeatures() in ProcessImageChunk() should ensure this.
  339|    336|  assert(chunk_data->size >= CHUNK_HEADER_SIZE + 10);
  340|    336|  if (profile > 3) {
  ------------------
  |  Branch (340:7): [True: 0, False: 336]
  ------------------
  341|      0|    LOG_ERROR("Unknown profile.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  342|      0|    return WEBP_INFO_BITSTREAM_ERROR;
  343|      0|  }
  344|    336|  if (!display) {
  ------------------
  |  Branch (344:7): [True: 0, False: 336]
  ------------------
  345|      0|    LOG_ERROR("Frame is not displayable.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  346|      0|    return WEBP_INFO_BITSTREAM_ERROR;
  347|      0|  }
  348|    336|  data += 3;
  349|    336|  data_size -= 3;
  350|    336|  printf(
  351|    336|      "  Key frame:        %s\n"
  352|    336|      "  Profile:          %d\n"
  353|    336|      "  Display:          Yes\n"
  354|    336|      "  Part. 0 length:   %d\n",
  355|    336|      key_frame ? "Yes" : "No", profile, partition0_length);
  ------------------
  |  Branch (355:7): [True: 336, False: 0]
  ------------------
  356|    336|  if (key_frame) {
  ------------------
  |  Branch (356:7): [True: 336, False: 0]
  ------------------
  357|    336|    if (!(data[0] == 0x9d && data[1] == 0x01 && data[2] == 0x2a)) {
  ------------------
  |  Branch (357:11): [True: 336, False: 0]
  |  Branch (357:30): [True: 336, False: 0]
  |  Branch (357:49): [True: 336, False: 0]
  ------------------
  358|      0|      LOG_ERROR("Invalid lossy bitstream signature.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  359|      0|      return WEBP_INFO_BITSTREAM_ERROR;
  360|      0|    }
  361|    336|    printf(
  362|    336|        "  Width:            %d\n"
  363|    336|        "  X scale:          %d\n"
  364|    336|        "  Height:           %d\n"
  365|    336|        "  Y scale:          %d\n",
  366|    336|        ((data[4] << 8) | data[3]) & 0x3fff, data[4] >> 6,
  367|    336|        ((data[6] << 8) | data[5]) & 0x3fff, data[6] >> 6);
  368|    336|    data += 7;
  369|    336|    data_size -= 7;
  370|    336|  } else {
  371|      0|    LOG_ERROR("Non-keyframe detected in lossy bitstream.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  372|      0|    return WEBP_INFO_BITSTREAM_ERROR;
  373|      0|  }
  374|    336|  if (partition0_length >= data_size) {
  ------------------
  |  Branch (374:7): [True: 11, False: 325]
  ------------------
  375|     11|    LOG_ERROR("Bad partition length.");
  ------------------
  |  |   36|     11|  do {                                         \
  |  |   37|     11|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 11]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|     11|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 11]
  |  |  ------------------
  ------------------
  376|     11|    return WEBP_INFO_BITSTREAM_ERROR;
  377|     11|  }
  378|    325|  GET_BITS(colorspace, 1);
  ------------------
  |  |  229|    325|  do {                                                 \
  |  |  230|    325|    if (!GetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (230:9): [True: 0, False: 325]
  |  |  ------------------
  |  |  231|      0|      LOG_ERROR("Truncated lossy bitstream.");         \
  |  |  ------------------
  |  |  |  |   36|      0|  do {                                         \
  |  |  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  232|      0|      return WEBP_INFO_TRUNCATED_DATA;                 \
  |  |  233|      0|    }                                                  \
  |  |  234|    325|  } while (0)
  |  |  ------------------
  |  |  |  Branch (234:12): [Folded, False: 325]
  |  |  ------------------
  ------------------
  379|    325|  GET_BITS(clamp_type, 1);
  ------------------
  |  |  229|    325|  do {                                                 \
  |  |  230|    325|    if (!GetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (230:9): [True: 0, False: 325]
  |  |  ------------------
  |  |  231|      0|      LOG_ERROR("Truncated lossy bitstream.");         \
  |  |  ------------------
  |  |  |  |   36|      0|  do {                                         \
  |  |  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  232|      0|      return WEBP_INFO_TRUNCATED_DATA;                 \
  |  |  233|      0|    }                                                  \
  |  |  234|    325|  } while (0)
  |  |  ------------------
  |  |  |  Branch (234:12): [Folded, False: 325]
  |  |  ------------------
  ------------------
  380|    325|  printf("  Color space:      %d\n", colorspace);
  381|    325|  printf("  Clamp type:       %d\n", clamp_type);
  382|    325|  status = ParseLossySegmentHeader(webp_info, data, data_size, bit_pos);
  383|    325|  if (status != WEBP_INFO_OK) return status;
  ------------------
  |  Branch (383:7): [True: 31, False: 294]
  ------------------
  384|    294|  status = ParseLossyFilterHeader(webp_info, data, data_size, bit_pos);
  385|    294|  if (status != WEBP_INFO_OK) return status;
  ------------------
  |  Branch (385:7): [True: 31, False: 263]
  ------------------
  386|    263|  {  // Partition number and size.
  387|    263|    const uint8_t* part_size = data + partition0_length;
  388|    263|    int num_parts, i;
  389|    263|    size_t part_data_size;
  390|    263|    GET_BITS(num_parts, 2);
  ------------------
  |  |  229|    263|  do {                                                 \
  |  |  230|    263|    if (!GetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (230:9): [True: 4, False: 259]
  |  |  ------------------
  |  |  231|      4|      LOG_ERROR("Truncated lossy bitstream.");         \
  |  |  ------------------
  |  |  |  |   36|      4|  do {                                         \
  |  |  |  |   37|      4|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 4]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      4|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 4]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  232|      4|      return WEBP_INFO_TRUNCATED_DATA;                 \
  |  |  233|      4|    }                                                  \
  |  |  234|    263|  } while (0)
  |  |  ------------------
  |  |  |  Branch (234:12): [Folded, False: 259]
  |  |  ------------------
  ------------------
  391|    259|    num_parts = 1 << num_parts;
  392|    259|    if ((int)(data_size - partition0_length) < (num_parts - 1) * 3) {
  ------------------
  |  Branch (392:9): [True: 11, False: 248]
  ------------------
  393|     11|      LOG_ERROR("Truncated lossy bitstream.");
  ------------------
  |  |   36|     11|  do {                                         \
  |  |   37|     11|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 11]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|     11|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 11]
  |  |  ------------------
  ------------------
  394|     11|      return WEBP_INFO_TRUNCATED_DATA;
  395|     11|    }
  396|    248|    part_data_size = data_size - partition0_length - (num_parts - 1) * 3;
  397|    248|    printf("  Total partitions: %d\n", num_parts);
  398|    308|    for (i = 1; i < num_parts; ++i) {
  ------------------
  |  Branch (398:17): [True: 158, False: 150]
  ------------------
  399|    158|      const size_t psize =
  400|    158|          part_size[0] | (part_size[1] << 8) | (part_size[2] << 16);
  401|    158|      if (psize > part_data_size) {
  ------------------
  |  Branch (401:11): [True: 98, False: 60]
  ------------------
  402|     98|        LOG_ERROR("Truncated partition.");
  ------------------
  |  |   36|     98|  do {                                         \
  |  |   37|     98|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 98]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|     98|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 98]
  |  |  ------------------
  ------------------
  403|     98|        return WEBP_INFO_TRUNCATED_DATA;
  404|     98|      }
  405|     60|      printf("  Part. %d length:   %d\n", i, (int)psize);
  406|     60|      part_data_size -= psize;
  407|     60|      part_size += 3;
  408|     60|    }
  409|    248|  }
  410|       |  // Quantizer.
  411|    150|  {
  412|    150|    int base_q, bit;
  413|    150|    int dq_y1_dc = 0, dq_y2_dc = 0, dq_y2_ac = 0, dq_uv_dc = 0, dq_uv_ac = 0;
  414|    150|    GET_BITS(base_q, 7);
  ------------------
  |  |  229|    150|  do {                                                 \
  |  |  230|    150|    if (!GetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (230:9): [True: 11, False: 139]
  |  |  ------------------
  |  |  231|     11|      LOG_ERROR("Truncated lossy bitstream.");         \
  |  |  ------------------
  |  |  |  |   36|     11|  do {                                         \
  |  |  |  |   37|     11|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 11]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|     11|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 11]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  232|     11|      return WEBP_INFO_TRUNCATED_DATA;                 \
  |  |  233|     11|    }                                                  \
  |  |  234|    150|  } while (0)
  |  |  ------------------
  |  |  |  Branch (234:12): [Folded, False: 139]
  |  |  ------------------
  ------------------
  415|    139|    GET_BITS(bit, 1);
  ------------------
  |  |  229|    139|  do {                                                 \
  |  |  230|    139|    if (!GetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (230:9): [True: 3, False: 136]
  |  |  ------------------
  |  |  231|      3|      LOG_ERROR("Truncated lossy bitstream.");         \
  |  |  ------------------
  |  |  |  |   36|      3|  do {                                         \
  |  |  |  |   37|      3|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 3]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      3|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 3]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  232|      3|      return WEBP_INFO_TRUNCATED_DATA;                 \
  |  |  233|      3|    }                                                  \
  |  |  234|    139|  } while (0)
  |  |  ------------------
  |  |  |  Branch (234:12): [Folded, False: 136]
  |  |  ------------------
  ------------------
  416|    136|    if (bit) GET_SIGNED_BITS(dq_y1_dc, 4);
  ------------------
  |  |  237|     52|  do {                                                       \
  |  |  238|     52|    if (!GetSignedBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (238:9): [True: 3, False: 49]
  |  |  ------------------
  |  |  239|      3|      LOG_ERROR("Truncated lossy bitstream.");               \
  |  |  ------------------
  |  |  |  |   36|      3|  do {                                         \
  |  |  |  |   37|      3|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 3]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      3|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 3]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  240|      3|      return WEBP_INFO_TRUNCATED_DATA;                       \
  |  |  241|      3|    }                                                        \
  |  |  242|     52|  } while (0)
  |  |  ------------------
  |  |  |  Branch (242:12): [Folded, False: 49]
  |  |  ------------------
  ------------------
  |  Branch (416:9): [True: 52, False: 84]
  ------------------
  417|    133|    GET_BITS(bit, 1);
  ------------------
  |  |  229|    133|  do {                                                 \
  |  |  230|    133|    if (!GetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (230:9): [True: 2, False: 131]
  |  |  ------------------
  |  |  231|      2|      LOG_ERROR("Truncated lossy bitstream.");         \
  |  |  ------------------
  |  |  |  |   36|      2|  do {                                         \
  |  |  |  |   37|      2|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 2]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      2|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  232|      2|      return WEBP_INFO_TRUNCATED_DATA;                 \
  |  |  233|      2|    }                                                  \
  |  |  234|    133|  } while (0)
  |  |  ------------------
  |  |  |  Branch (234:12): [Folded, False: 131]
  |  |  ------------------
  ------------------
  418|    131|    if (bit) GET_SIGNED_BITS(dq_y2_dc, 4);
  ------------------
  |  |  237|     68|  do {                                                       \
  |  |  238|     68|    if (!GetSignedBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (238:9): [True: 2, False: 66]
  |  |  ------------------
  |  |  239|      2|      LOG_ERROR("Truncated lossy bitstream.");               \
  |  |  ------------------
  |  |  |  |   36|      2|  do {                                         \
  |  |  |  |   37|      2|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 2]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      2|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  240|      2|      return WEBP_INFO_TRUNCATED_DATA;                       \
  |  |  241|      2|    }                                                        \
  |  |  242|     68|  } while (0)
  |  |  ------------------
  |  |  |  Branch (242:12): [Folded, False: 66]
  |  |  ------------------
  ------------------
  |  Branch (418:9): [True: 68, False: 63]
  ------------------
  419|    129|    GET_BITS(bit, 1);
  ------------------
  |  |  229|    129|  do {                                                 \
  |  |  230|    129|    if (!GetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (230:9): [True: 2, False: 127]
  |  |  ------------------
  |  |  231|      2|      LOG_ERROR("Truncated lossy bitstream.");         \
  |  |  ------------------
  |  |  |  |   36|      2|  do {                                         \
  |  |  |  |   37|      2|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 2]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      2|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  232|      2|      return WEBP_INFO_TRUNCATED_DATA;                 \
  |  |  233|      2|    }                                                  \
  |  |  234|    129|  } while (0)
  |  |  ------------------
  |  |  |  Branch (234:12): [Folded, False: 127]
  |  |  ------------------
  ------------------
  420|    127|    if (bit) GET_SIGNED_BITS(dq_y2_ac, 4);
  ------------------
  |  |  237|     60|  do {                                                       \
  |  |  238|     60|    if (!GetSignedBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (238:9): [True: 1, False: 59]
  |  |  ------------------
  |  |  239|      1|      LOG_ERROR("Truncated lossy bitstream.");               \
  |  |  ------------------
  |  |  |  |   36|      1|  do {                                         \
  |  |  |  |   37|      1|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 1]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      1|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 1]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  240|      1|      return WEBP_INFO_TRUNCATED_DATA;                       \
  |  |  241|      1|    }                                                        \
  |  |  242|     60|  } while (0)
  |  |  ------------------
  |  |  |  Branch (242:12): [Folded, False: 59]
  |  |  ------------------
  ------------------
  |  Branch (420:9): [True: 60, False: 67]
  ------------------
  421|    126|    GET_BITS(bit, 1);
  ------------------
  |  |  229|    126|  do {                                                 \
  |  |  230|    126|    if (!GetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (230:9): [True: 2, False: 124]
  |  |  ------------------
  |  |  231|      2|      LOG_ERROR("Truncated lossy bitstream.");         \
  |  |  ------------------
  |  |  |  |   36|      2|  do {                                         \
  |  |  |  |   37|      2|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 2]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      2|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  232|      2|      return WEBP_INFO_TRUNCATED_DATA;                 \
  |  |  233|      2|    }                                                  \
  |  |  234|    126|  } while (0)
  |  |  ------------------
  |  |  |  Branch (234:12): [Folded, False: 124]
  |  |  ------------------
  ------------------
  422|    124|    if (bit) GET_SIGNED_BITS(dq_uv_dc, 4);
  ------------------
  |  |  237|     61|  do {                                                       \
  |  |  238|     61|    if (!GetSignedBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (238:9): [True: 2, False: 59]
  |  |  ------------------
  |  |  239|      2|      LOG_ERROR("Truncated lossy bitstream.");               \
  |  |  ------------------
  |  |  |  |   36|      2|  do {                                         \
  |  |  |  |   37|      2|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 2]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      2|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  240|      2|      return WEBP_INFO_TRUNCATED_DATA;                       \
  |  |  241|      2|    }                                                        \
  |  |  242|     61|  } while (0)
  |  |  ------------------
  |  |  |  Branch (242:12): [Folded, False: 59]
  |  |  ------------------
  ------------------
  |  Branch (422:9): [True: 61, False: 63]
  ------------------
  423|    122|    GET_BITS(bit, 1);
  ------------------
  |  |  229|    122|  do {                                                 \
  |  |  230|    122|    if (!GetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (230:9): [True: 2, False: 120]
  |  |  ------------------
  |  |  231|      2|      LOG_ERROR("Truncated lossy bitstream.");         \
  |  |  ------------------
  |  |  |  |   36|      2|  do {                                         \
  |  |  |  |   37|      2|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 2]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      2|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  232|      2|      return WEBP_INFO_TRUNCATED_DATA;                 \
  |  |  233|      2|    }                                                  \
  |  |  234|    122|  } while (0)
  |  |  ------------------
  |  |  |  Branch (234:12): [Folded, False: 120]
  |  |  ------------------
  ------------------
  424|    120|    if (bit) GET_SIGNED_BITS(dq_uv_ac, 4);
  ------------------
  |  |  237|     56|  do {                                                       \
  |  |  238|     56|    if (!GetSignedBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (238:9): [True: 3, False: 53]
  |  |  ------------------
  |  |  239|      3|      LOG_ERROR("Truncated lossy bitstream.");               \
  |  |  ------------------
  |  |  |  |   36|      3|  do {                                         \
  |  |  |  |   37|      3|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 3]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      3|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 3]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  240|      3|      return WEBP_INFO_TRUNCATED_DATA;                       \
  |  |  241|      3|    }                                                        \
  |  |  242|     56|  } while (0)
  |  |  ------------------
  |  |  |  Branch (242:12): [Folded, False: 53]
  |  |  ------------------
  ------------------
  |  Branch (424:9): [True: 56, False: 64]
  ------------------
  425|    117|    printf("  Base Q:           %d\n", base_q);
  426|    117|    printf("  DQ Y1 DC:         %d\n", dq_y1_dc);
  427|    117|    printf("  DQ Y2 DC:         %d\n", dq_y2_dc);
  428|    117|    printf("  DQ Y2 AC:         %d\n", dq_y2_ac);
  429|    117|    printf("  DQ UV DC:         %d\n", dq_uv_dc);
  430|    117|    printf("  DQ UV AC:         %d\n", dq_uv_ac);
  431|    117|  }
  432|    117|  if ((*bit_pos >> 3) >= partition0_length) {
  ------------------
  |  Branch (432:7): [True: 48, False: 69]
  ------------------
  433|     48|    LOG_ERROR("Truncated lossy bitstream.");
  ------------------
  |  |   36|     48|  do {                                         \
  |  |   37|     48|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 48]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|     48|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 48]
  |  |  ------------------
  ------------------
  434|     48|    return WEBP_INFO_TRUNCATED_DATA;
  435|     48|  }
  436|     69|  return WEBP_INFO_OK;
  437|    117|}
webp_info_fuzzer.cc:_ZL7GetBitsPKhmmPiPm:
  205|  11.2k|                   int* val, uint64_t* const bit_pos) {
  206|  11.2k|  *val = 0;
  207|  39.6k|  while (nb-- > 0) {
  ------------------
  |  Branch (207:10): [True: 28.4k, False: 11.1k]
  ------------------
  208|  28.4k|    const uint64_t p = (*bit_pos)++;
  209|  28.4k|    if ((p >> 3) >= data_size) {
  ------------------
  |  Branch (209:9): [True: 99, False: 28.3k]
  ------------------
  210|     99|      return 0;
  211|  28.3k|    } else {
  212|  28.3k|      const int bit = !!(data[p >> 3] & (128 >> ((p & 7))));
  213|  28.3k|      *val = (*val << 1) | bit;
  214|  28.3k|    }
  215|  28.4k|  }
  216|  11.1k|  return 1;
  217|  11.2k|}
webp_info_fuzzer.cc:_ZL23ParseLossySegmentHeaderPK8WebPInfoPKhmPm:
  247|    325|                                              uint64_t* const bit_pos) {
  248|    325|  int use_segment;
  249|    325|  GET_BITS(use_segment, 1);
  ------------------
  |  |  229|    325|  do {                                                 \
  |  |  230|    325|    if (!GetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (230:9): [True: 0, False: 325]
  |  |  ------------------
  |  |  231|      0|      LOG_ERROR("Truncated lossy bitstream.");         \
  |  |  ------------------
  |  |  |  |   36|      0|  do {                                         \
  |  |  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  232|      0|      return WEBP_INFO_TRUNCATED_DATA;                 \
  |  |  233|      0|    }                                                  \
  |  |  234|    325|  } while (0)
  |  |  ------------------
  |  |  |  Branch (234:12): [Folded, False: 325]
  |  |  ------------------
  ------------------
  250|    325|  printf("  Use segment:      %d\n", use_segment);
  251|    325|  if (use_segment) {
  ------------------
  |  Branch (251:7): [True: 260, False: 65]
  ------------------
  252|    260|    int update_map, update_data;
  253|    260|    GET_BITS(update_map, 1);
  ------------------
  |  |  229|    260|  do {                                                 \
  |  |  230|    260|    if (!GetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (230:9): [True: 0, False: 260]
  |  |  ------------------
  |  |  231|      0|      LOG_ERROR("Truncated lossy bitstream.");         \
  |  |  ------------------
  |  |  |  |   36|      0|  do {                                         \
  |  |  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  232|      0|      return WEBP_INFO_TRUNCATED_DATA;                 \
  |  |  233|      0|    }                                                  \
  |  |  234|    260|  } while (0)
  |  |  ------------------
  |  |  |  Branch (234:12): [Folded, False: 260]
  |  |  ------------------
  ------------------
  254|    260|    GET_BITS(update_data, 1);
  ------------------
  |  |  229|    260|  do {                                                 \
  |  |  230|    260|    if (!GetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (230:9): [True: 0, False: 260]
  |  |  ------------------
  |  |  231|      0|      LOG_ERROR("Truncated lossy bitstream.");         \
  |  |  ------------------
  |  |  |  |   36|      0|  do {                                         \
  |  |  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  232|      0|      return WEBP_INFO_TRUNCATED_DATA;                 \
  |  |  233|      0|    }                                                  \
  |  |  234|    260|  } while (0)
  |  |  ------------------
  |  |  |  Branch (234:12): [Folded, False: 260]
  |  |  ------------------
  ------------------
  255|    260|    printf(
  256|    260|        "  Update map:       %d\n"
  257|    260|        "  Update data:      %d\n",
  258|    260|        update_map, update_data);
  259|    260|    if (update_data) {
  ------------------
  |  Branch (259:9): [True: 216, False: 44]
  ------------------
  260|    216|      int i, a_delta;
  261|    216|      int quantizer[4] = {0, 0, 0, 0};
  262|    216|      int filter_strength[4] = {0, 0, 0, 0};
  263|    216|      GET_BITS(a_delta, 1);
  ------------------
  |  |  229|    216|  do {                                                 \
  |  |  230|    216|    if (!GetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (230:9): [True: 0, False: 216]
  |  |  ------------------
  |  |  231|      0|      LOG_ERROR("Truncated lossy bitstream.");         \
  |  |  ------------------
  |  |  |  |   36|      0|  do {                                         \
  |  |  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  232|      0|      return WEBP_INFO_TRUNCATED_DATA;                 \
  |  |  233|      0|    }                                                  \
  |  |  234|    216|  } while (0)
  |  |  ------------------
  |  |  |  Branch (234:12): [Folded, False: 216]
  |  |  ------------------
  ------------------
  264|    216|      printf("  Absolute delta:   %d\n", a_delta);
  265|  1.07k|      for (i = 0; i < 4; ++i) {
  ------------------
  |  Branch (265:19): [True: 860, False: 211]
  ------------------
  266|    860|        int bit;
  267|    860|        GET_BITS(bit, 1);
  ------------------
  |  |  229|    860|  do {                                                 \
  |  |  230|    860|    if (!GetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (230:9): [True: 1, False: 859]
  |  |  ------------------
  |  |  231|      1|      LOG_ERROR("Truncated lossy bitstream.");         \
  |  |  ------------------
  |  |  |  |   36|      1|  do {                                         \
  |  |  |  |   37|      1|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 1]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      1|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 1]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  232|      1|      return WEBP_INFO_TRUNCATED_DATA;                 \
  |  |  233|      1|    }                                                  \
  |  |  234|    860|  } while (0)
  |  |  ------------------
  |  |  |  Branch (234:12): [Folded, False: 859]
  |  |  ------------------
  ------------------
  268|    859|        if (bit) GET_SIGNED_BITS(quantizer[i], 7);
  ------------------
  |  |  237|    605|  do {                                                       \
  |  |  238|    605|    if (!GetSignedBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (238:9): [True: 4, False: 601]
  |  |  ------------------
  |  |  239|      4|      LOG_ERROR("Truncated lossy bitstream.");               \
  |  |  ------------------
  |  |  |  |   36|      4|  do {                                         \
  |  |  |  |   37|      4|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 4]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      4|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 4]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  240|      4|      return WEBP_INFO_TRUNCATED_DATA;                       \
  |  |  241|      4|    }                                                        \
  |  |  242|    605|  } while (0)
  |  |  ------------------
  |  |  |  Branch (242:12): [Folded, False: 601]
  |  |  ------------------
  ------------------
  |  Branch (268:13): [True: 605, False: 254]
  ------------------
  269|    859|      }
  270|  1.03k|      for (i = 0; i < 4; ++i) {
  ------------------
  |  Branch (270:19): [True: 832, False: 202]
  ------------------
  271|    832|        int bit;
  272|    832|        GET_BITS(bit, 1);
  ------------------
  |  |  229|    832|  do {                                                 \
  |  |  230|    832|    if (!GetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (230:9): [True: 0, False: 832]
  |  |  ------------------
  |  |  231|      0|      LOG_ERROR("Truncated lossy bitstream.");         \
  |  |  ------------------
  |  |  |  |   36|      0|  do {                                         \
  |  |  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  232|      0|      return WEBP_INFO_TRUNCATED_DATA;                 \
  |  |  233|      0|    }                                                  \
  |  |  234|    832|  } while (0)
  |  |  ------------------
  |  |  |  Branch (234:12): [Folded, False: 832]
  |  |  ------------------
  ------------------
  273|    832|        if (bit) GET_SIGNED_BITS(filter_strength[i], 6);
  ------------------
  |  |  237|    592|  do {                                                       \
  |  |  238|    592|    if (!GetSignedBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (238:9): [True: 9, False: 583]
  |  |  ------------------
  |  |  239|      9|      LOG_ERROR("Truncated lossy bitstream.");               \
  |  |  ------------------
  |  |  |  |   36|      9|  do {                                         \
  |  |  |  |   37|      9|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 9]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      9|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 9]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  240|      9|      return WEBP_INFO_TRUNCATED_DATA;                       \
  |  |  241|      9|    }                                                        \
  |  |  242|    592|  } while (0)
  |  |  ------------------
  |  |  |  Branch (242:12): [Folded, False: 583]
  |  |  ------------------
  ------------------
  |  Branch (273:13): [True: 592, False: 240]
  ------------------
  274|    832|      }
  275|    202|      printf("  Quantizer:        %d %d %d %d\n", quantizer[0], quantizer[1],
  276|    202|             quantizer[2], quantizer[3]);
  277|    202|      printf("  Filter strength:  %d %d %d %d\n", filter_strength[0],
  278|    202|             filter_strength[1], filter_strength[2], filter_strength[3]);
  279|    202|    }
  280|    246|    if (update_map) {
  ------------------
  |  Branch (280:9): [True: 194, False: 52]
  ------------------
  281|    194|      int i;
  282|    194|      int prob_segment[3] = {255, 255, 255};
  283|    737|      for (i = 0; i < 3; ++i) {
  ------------------
  |  Branch (283:19): [True: 560, False: 177]
  ------------------
  284|    560|        int bit;
  285|    560|        GET_BITS(bit, 1);
  ------------------
  |  |  229|    560|  do {                                                 \
  |  |  230|    560|    if (!GetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (230:9): [True: 1, False: 559]
  |  |  ------------------
  |  |  231|      1|      LOG_ERROR("Truncated lossy bitstream.");         \
  |  |  ------------------
  |  |  |  |   36|      1|  do {                                         \
  |  |  |  |   37|      1|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 1]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      1|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 1]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  232|      1|      return WEBP_INFO_TRUNCATED_DATA;                 \
  |  |  233|      1|    }                                                  \
  |  |  234|    560|  } while (0)
  |  |  ------------------
  |  |  |  Branch (234:12): [Folded, False: 559]
  |  |  ------------------
  ------------------
  286|    559|        if (bit) GET_BITS(prob_segment[i], 8);
  ------------------
  |  |  229|    395|  do {                                                 \
  |  |  230|    395|    if (!GetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (230:9): [True: 16, False: 379]
  |  |  ------------------
  |  |  231|     16|      LOG_ERROR("Truncated lossy bitstream.");         \
  |  |  ------------------
  |  |  |  |   36|     16|  do {                                         \
  |  |  |  |   37|     16|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 16]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|     16|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 16]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  232|     16|      return WEBP_INFO_TRUNCATED_DATA;                 \
  |  |  233|     16|    }                                                  \
  |  |  234|    395|  } while (0)
  |  |  ------------------
  |  |  |  Branch (234:12): [Folded, False: 379]
  |  |  ------------------
  ------------------
  |  Branch (286:13): [True: 395, False: 164]
  ------------------
  287|    559|      }
  288|    177|      printf("  Prob segment:     %d %d %d\n", prob_segment[0], prob_segment[1],
  289|    177|             prob_segment[2]);
  290|    177|    }
  291|    246|  }
  292|    294|  return WEBP_INFO_OK;
  293|    325|}
webp_info_fuzzer.cc:_ZL22ParseLossyFilterHeaderPK8WebPInfoPKhmPm:
  298|    294|                                             uint64_t* const bit_pos) {
  299|    294|  int simple_filter, level, sharpness, use_lf_delta;
  300|    294|  GET_BITS(simple_filter, 1);
  ------------------
  |  |  229|    294|  do {                                                 \
  |  |  230|    294|    if (!GetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (230:9): [True: 3, False: 291]
  |  |  ------------------
  |  |  231|      3|      LOG_ERROR("Truncated lossy bitstream.");         \
  |  |  ------------------
  |  |  |  |   36|      3|  do {                                         \
  |  |  |  |   37|      3|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 3]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      3|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 3]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  232|      3|      return WEBP_INFO_TRUNCATED_DATA;                 \
  |  |  233|      3|    }                                                  \
  |  |  234|    294|  } while (0)
  |  |  ------------------
  |  |  |  Branch (234:12): [Folded, False: 291]
  |  |  ------------------
  ------------------
  301|    291|  GET_BITS(level, 6);
  ------------------
  |  |  229|    291|  do {                                                 \
  |  |  230|    291|    if (!GetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (230:9): [True: 8, False: 283]
  |  |  ------------------
  |  |  231|      8|      LOG_ERROR("Truncated lossy bitstream.");         \
  |  |  ------------------
  |  |  |  |   36|      8|  do {                                         \
  |  |  |  |   37|      8|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 8]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      8|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 8]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  232|      8|      return WEBP_INFO_TRUNCATED_DATA;                 \
  |  |  233|      8|    }                                                  \
  |  |  234|    291|  } while (0)
  |  |  ------------------
  |  |  |  Branch (234:12): [Folded, False: 283]
  |  |  ------------------
  ------------------
  302|    283|  GET_BITS(sharpness, 3);
  ------------------
  |  |  229|    283|  do {                                                 \
  |  |  230|    283|    if (!GetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (230:9): [True: 5, False: 278]
  |  |  ------------------
  |  |  231|      5|      LOG_ERROR("Truncated lossy bitstream.");         \
  |  |  ------------------
  |  |  |  |   36|      5|  do {                                         \
  |  |  |  |   37|      5|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 5]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      5|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 5]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  232|      5|      return WEBP_INFO_TRUNCATED_DATA;                 \
  |  |  233|      5|    }                                                  \
  |  |  234|    283|  } while (0)
  |  |  ------------------
  |  |  |  Branch (234:12): [Folded, False: 278]
  |  |  ------------------
  ------------------
  303|    278|  GET_BITS(use_lf_delta, 1);
  ------------------
  |  |  229|    278|  do {                                                 \
  |  |  230|    278|    if (!GetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (230:9): [True: 1, False: 277]
  |  |  ------------------
  |  |  231|      1|      LOG_ERROR("Truncated lossy bitstream.");         \
  |  |  ------------------
  |  |  |  |   36|      1|  do {                                         \
  |  |  |  |   37|      1|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 1]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      1|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 1]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  232|      1|      return WEBP_INFO_TRUNCATED_DATA;                 \
  |  |  233|      1|    }                                                  \
  |  |  234|    278|  } while (0)
  |  |  ------------------
  |  |  |  Branch (234:12): [Folded, False: 277]
  |  |  ------------------
  ------------------
  304|    277|  printf("  Simple filter:    %d\n", simple_filter);
  305|    277|  printf("  Level:            %d\n", level);
  306|    277|  printf("  Sharpness:        %d\n", sharpness);
  307|    277|  printf("  Use lf delta:     %d\n", use_lf_delta);
  308|    277|  if (use_lf_delta) {
  ------------------
  |  Branch (308:7): [True: 177, False: 100]
  ------------------
  309|    177|    int update;
  310|    177|    GET_BITS(update, 1);
  ------------------
  |  |  229|    177|  do {                                                 \
  |  |  230|    177|    if (!GetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (230:9): [True: 1, False: 176]
  |  |  ------------------
  |  |  231|      1|      LOG_ERROR("Truncated lossy bitstream.");         \
  |  |  ------------------
  |  |  |  |   36|      1|  do {                                         \
  |  |  |  |   37|      1|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 1]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      1|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 1]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  232|      1|      return WEBP_INFO_TRUNCATED_DATA;                 \
  |  |  233|      1|    }                                                  \
  |  |  234|    177|  } while (0)
  |  |  ------------------
  |  |  |  Branch (234:12): [Folded, False: 176]
  |  |  ------------------
  ------------------
  311|    176|    printf("  Update lf delta:  %d\n", update);
  312|    176|    if (update) {
  ------------------
  |  Branch (312:9): [True: 120, False: 56]
  ------------------
  313|    120|      int i;
  314|  1.02k|      for (i = 0; i < 4 + 4; ++i) {
  ------------------
  |  Branch (314:19): [True: 921, False: 107]
  ------------------
  315|    921|        int temp;
  316|    921|        GET_BITS(temp, 1);
  ------------------
  |  |  229|    921|  do {                                                 \
  |  |  230|    921|    if (!GetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (230:9): [True: 4, False: 917]
  |  |  ------------------
  |  |  231|      4|      LOG_ERROR("Truncated lossy bitstream.");         \
  |  |  ------------------
  |  |  |  |   36|      4|  do {                                         \
  |  |  |  |   37|      4|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 4]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      4|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 4]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  232|      4|      return WEBP_INFO_TRUNCATED_DATA;                 \
  |  |  233|      4|    }                                                  \
  |  |  234|    921|  } while (0)
  |  |  ------------------
  |  |  |  Branch (234:12): [Folded, False: 917]
  |  |  ------------------
  ------------------
  317|    917|        if (temp) GET_BITS(temp, 7);
  ------------------
  |  |  229|    652|  do {                                                 \
  |  |  230|    652|    if (!GetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (230:9): [True: 9, False: 643]
  |  |  ------------------
  |  |  231|      9|      LOG_ERROR("Truncated lossy bitstream.");         \
  |  |  ------------------
  |  |  |  |   36|      9|  do {                                         \
  |  |  |  |   37|      9|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 9]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      9|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 9]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  232|      9|      return WEBP_INFO_TRUNCATED_DATA;                 \
  |  |  233|      9|    }                                                  \
  |  |  234|    652|  } while (0)
  |  |  ------------------
  |  |  |  Branch (234:12): [Folded, False: 643]
  |  |  ------------------
  ------------------
  |  Branch (317:13): [True: 652, False: 265]
  ------------------
  318|    917|      }
  319|    120|    }
  320|    176|  }
  321|    263|  return WEBP_INFO_OK;
  322|    277|}
webp_info_fuzzer.cc:_ZL13GetSignedBitsPKhmmPiPm:
  220|  1.49k|                         int* val, uint64_t* const bit_pos) {
  221|  1.49k|  int sign;
  222|  1.49k|  if (!GetBits(data, data_size, nb, val, bit_pos)) return 0;
  ------------------
  |  Branch (222:7): [True: 22, False: 1.47k]
  ------------------
  223|  1.47k|  if (!GetBits(data, data_size, 1, &sign, bit_pos)) return 0;
  ------------------
  |  Branch (223:7): [True: 2, False: 1.47k]
  ------------------
  224|  1.47k|  if (sign) *val = -(*val);
  ------------------
  |  Branch (224:7): [True: 825, False: 645]
  ------------------
  225|  1.47k|  return 1;
  226|  1.47k|}
webp_info_fuzzer.cc:_ZL19ParseLosslessHeaderPK9ChunkDataP8WebPInfo:
  498|     79|                                          WebPInfo* const webp_info) {
  499|     79|  const uint8_t* data = chunk_data->payload;
  500|     79|  size_t data_size = chunk_data->size - CHUNK_HEADER_SIZE;
  ------------------
  |  |   82|     79|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  501|     79|  uint64_t bit_position = 0;
  502|     79|  uint64_t* const bit_pos = &bit_position;
  503|     79|  WebPInfoStatus status;
  504|     79|  printf("  Parsing lossless bitstream...\n");
  505|     79|  if (data_size < VP8L_FRAME_HEADER_SIZE) {
  ------------------
  |  |   33|     79|#define VP8L_FRAME_HEADER_SIZE 5  // Size of the VP8L frame header.
  ------------------
  |  Branch (505:7): [True: 0, False: 79]
  ------------------
  506|      0|    LOG_ERROR("Truncated lossless bitstream.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  507|      0|    return WEBP_INFO_TRUNCATED_DATA;
  508|      0|  }
  509|     79|  if (data[0] != VP8L_MAGIC_BYTE) {
  ------------------
  |  |   28|     79|#define VP8L_MAGIC_BYTE 0x2f   // VP8L signature byte.
  ------------------
  |  Branch (509:7): [True: 0, False: 79]
  ------------------
  510|      0|    LOG_ERROR("Invalid lossless bitstream signature.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  511|      0|    return WEBP_INFO_BITSTREAM_ERROR;
  512|      0|  }
  513|     79|  data += 1;
  514|     79|  data_size -= 1;
  515|     79|  {
  516|     79|    int width, height, has_alpha, version;
  517|     79|    LL_GET_BITS(width, 14);
  ------------------
  |  |  460|     79|  do {                                                   \
  |  |  461|     79|    if (!LLGetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (461:9): [True: 0, False: 79]
  |  |  ------------------
  |  |  462|      0|      LOG_ERROR("Truncated lossless bitstream.");        \
  |  |  ------------------
  |  |  |  |   36|      0|  do {                                         \
  |  |  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  463|      0|      return WEBP_INFO_TRUNCATED_DATA;                   \
  |  |  464|      0|    }                                                    \
  |  |  465|     79|  } while (0)
  |  |  ------------------
  |  |  |  Branch (465:12): [Folded, False: 79]
  |  |  ------------------
  ------------------
  518|     79|    LL_GET_BITS(height, 14);
  ------------------
  |  |  460|     79|  do {                                                   \
  |  |  461|     79|    if (!LLGetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (461:9): [True: 0, False: 79]
  |  |  ------------------
  |  |  462|      0|      LOG_ERROR("Truncated lossless bitstream.");        \
  |  |  ------------------
  |  |  |  |   36|      0|  do {                                         \
  |  |  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  463|      0|      return WEBP_INFO_TRUNCATED_DATA;                   \
  |  |  464|      0|    }                                                    \
  |  |  465|     79|  } while (0)
  |  |  ------------------
  |  |  |  Branch (465:12): [Folded, False: 79]
  |  |  ------------------
  ------------------
  519|     79|    LL_GET_BITS(has_alpha, 1);
  ------------------
  |  |  460|     79|  do {                                                   \
  |  |  461|     79|    if (!LLGetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (461:9): [True: 0, False: 79]
  |  |  ------------------
  |  |  462|      0|      LOG_ERROR("Truncated lossless bitstream.");        \
  |  |  ------------------
  |  |  |  |   36|      0|  do {                                         \
  |  |  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  463|      0|      return WEBP_INFO_TRUNCATED_DATA;                   \
  |  |  464|      0|    }                                                    \
  |  |  465|     79|  } while (0)
  |  |  ------------------
  |  |  |  Branch (465:12): [Folded, False: 79]
  |  |  ------------------
  ------------------
  520|     79|    LL_GET_BITS(version, 3);
  ------------------
  |  |  460|     79|  do {                                                   \
  |  |  461|     79|    if (!LLGetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (461:9): [True: 0, False: 79]
  |  |  ------------------
  |  |  462|      0|      LOG_ERROR("Truncated lossless bitstream.");        \
  |  |  ------------------
  |  |  |  |   36|      0|  do {                                         \
  |  |  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  463|      0|      return WEBP_INFO_TRUNCATED_DATA;                   \
  |  |  464|      0|    }                                                    \
  |  |  465|     79|  } while (0)
  |  |  ------------------
  |  |  |  Branch (465:12): [Folded, False: 79]
  |  |  ------------------
  ------------------
  521|     79|    width += 1;
  522|     79|    height += 1;
  523|     79|    printf("  Width:            %d\n", width);
  524|     79|    printf("  Height:           %d\n", height);
  525|     79|    printf("  Alpha:            %d\n", has_alpha);
  526|     79|    printf("  Version:          %d\n", version);
  527|     79|  }
  528|      0|  status = ParseLosslessTransform(webp_info, data, data_size, bit_pos);
  529|     79|  if (status != WEBP_INFO_OK) return status;
  ------------------
  |  Branch (529:7): [True: 5, False: 74]
  ------------------
  530|     74|  return WEBP_INFO_OK;
  531|     79|}
webp_info_fuzzer.cc:_ZL9LLGetBitsPKhmmPiPm:
  443|    530|                     int* val, uint64_t* const bit_pos) {
  444|    530|  uint32_t i = 0;
  445|    530|  *val = 0;
  446|  3.58k|  while (i < nb) {
  ------------------
  |  Branch (446:10): [True: 3.05k, False: 525]
  ------------------
  447|  3.05k|    const uint64_t p = (*bit_pos)++;
  448|  3.05k|    if ((p >> 3) >= data_size) {
  ------------------
  |  Branch (448:9): [True: 5, False: 3.05k]
  ------------------
  449|      5|      return 0;
  450|  3.05k|    } else {
  451|  3.05k|      const int bit = !!(data[p >> 3] & (1 << ((p & 7))));
  452|  3.05k|      *val = *val | (bit << i);
  453|  3.05k|      ++i;
  454|  3.05k|    }
  455|  3.05k|  }
  456|    525|  return 1;
  457|    530|}
webp_info_fuzzer.cc:_ZL22ParseLosslessTransformP8WebPInfoPKhmPm:
  470|     79|                                             uint64_t* const bit_pos) {
  471|     79|  int use_transform, block_size, n_colors;
  472|     79|  LL_GET_BITS(use_transform, 1);
  ------------------
  |  |  460|     79|  do {                                                   \
  |  |  461|     79|    if (!LLGetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (461:9): [True: 0, False: 79]
  |  |  ------------------
  |  |  462|      0|      LOG_ERROR("Truncated lossless bitstream.");        \
  |  |  ------------------
  |  |  |  |   36|      0|  do {                                         \
  |  |  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  463|      0|      return WEBP_INFO_TRUNCATED_DATA;                   \
  |  |  464|      0|    }                                                    \
  |  |  465|     79|  } while (0)
  |  |  ------------------
  |  |  |  Branch (465:12): [Folded, False: 79]
  |  |  ------------------
  ------------------
  473|     79|  printf("  Use transform:    %s\n", use_transform ? "Yes" : "No");
  ------------------
  |  Branch (473:38): [True: 70, False: 9]
  ------------------
  474|     79|  if (use_transform) {
  ------------------
  |  Branch (474:7): [True: 70, False: 9]
  ------------------
  475|     70|    int type;
  476|     70|    LL_GET_BITS(type, 2);
  ------------------
  |  |  460|     70|  do {                                                   \
  |  |  461|     70|    if (!LLGetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (461:9): [True: 0, False: 70]
  |  |  ------------------
  |  |  462|      0|      LOG_ERROR("Truncated lossless bitstream.");        \
  |  |  ------------------
  |  |  |  |   36|      0|  do {                                         \
  |  |  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  463|      0|      return WEBP_INFO_TRUNCATED_DATA;                   \
  |  |  464|      0|    }                                                    \
  |  |  465|     70|  } while (0)
  |  |  ------------------
  |  |  |  Branch (465:12): [Folded, False: 70]
  |  |  ------------------
  ------------------
  477|     70|    printf("  1st transform:    %s (%d)\n", kLosslessTransforms[type], type);
  478|     70|    switch (type) {
  479|     14|      case PREDICTOR_TRANSFORM:
  ------------------
  |  Branch (479:7): [True: 14, False: 56]
  ------------------
  480|     40|      case CROSS_COLOR_TRANSFORM:
  ------------------
  |  Branch (480:7): [True: 26, False: 44]
  ------------------
  481|     40|        LL_GET_BITS(block_size, 3);
  ------------------
  |  |  460|     40|  do {                                                   \
  |  |  461|     40|    if (!LLGetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (461:9): [True: 0, False: 40]
  |  |  ------------------
  |  |  462|      0|      LOG_ERROR("Truncated lossless bitstream.");        \
  |  |  ------------------
  |  |  |  |   36|      0|  do {                                         \
  |  |  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  463|      0|      return WEBP_INFO_TRUNCATED_DATA;                   \
  |  |  464|      0|    }                                                    \
  |  |  465|     40|  } while (0)
  |  |  ------------------
  |  |  |  Branch (465:12): [Folded, False: 40]
  |  |  ------------------
  ------------------
  482|     40|        block_size = 1 << (block_size + 2);
  483|     40|        printf("  Tran. block size: %d\n", block_size);
  484|     40|        break;
  485|     25|      case COLOR_INDEXING_TRANSFORM:
  ------------------
  |  Branch (485:7): [True: 25, False: 45]
  ------------------
  486|     25|        LL_GET_BITS(n_colors, 8);
  ------------------
  |  |  460|     25|  do {                                                   \
  |  |  461|     25|    if (!LLGetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (461:9): [True: 5, False: 20]
  |  |  ------------------
  |  |  462|      5|      LOG_ERROR("Truncated lossless bitstream.");        \
  |  |  ------------------
  |  |  |  |   36|      5|  do {                                         \
  |  |  |  |   37|      5|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 5]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      5|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 5]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  463|      5|      return WEBP_INFO_TRUNCATED_DATA;                   \
  |  |  464|      5|    }                                                    \
  |  |  465|     25|  } while (0)
  |  |  ------------------
  |  |  |  Branch (465:12): [Folded, False: 20]
  |  |  ------------------
  ------------------
  487|     20|        n_colors += 1;
  488|     20|        printf("  No. of colors:    %d\n", n_colors);
  489|     20|        break;
  490|      5|      default:
  ------------------
  |  Branch (490:7): [True: 5, False: 65]
  ------------------
  491|      5|        break;
  492|     70|    }
  493|     70|  }
  494|     74|  return WEBP_INFO_OK;
  495|     79|}
webp_info_fuzzer.cc:_ZL16ProcessVP8XChunkPK9ChunkDataP8WebPInfo:
  664|    105|                                       WebPInfo* const webp_info) {
  665|    105|  const uint8_t* data = chunk_data->payload;
  666|    105|  if (webp_info->chunk_counts[CHUNK_VP8] ||
  ------------------
  |  Branch (666:7): [True: 0, False: 105]
  ------------------
  667|    105|      webp_info->chunk_counts[CHUNK_VP8L] ||
  ------------------
  |  Branch (667:7): [True: 0, False: 105]
  ------------------
  668|    105|      webp_info->chunk_counts[CHUNK_VP8X]) {
  ------------------
  |  Branch (668:7): [True: 0, False: 105]
  ------------------
  669|      0|    LOG_ERROR("Already seen a VP8/VP8L/VP8X chunk when parsing VP8X chunk.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  670|      0|    return WEBP_INFO_PARSE_ERROR;
  671|      0|  }
  672|    105|  if (chunk_data->size != VP8X_CHUNK_SIZE + CHUNK_HEADER_SIZE) {
  ------------------
  |  |   86|    105|#define VP8X_CHUNK_SIZE 10   // Size of a VP8X chunk.
  ------------------
                if (chunk_data->size != VP8X_CHUNK_SIZE + CHUNK_HEADER_SIZE) {
  ------------------
  |  |   82|    105|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  |  Branch (672:7): [True: 11, False: 94]
  ------------------
  673|     11|    LOG_ERROR("Corrupted VP8X chunk.");
  ------------------
  |  |   36|     11|  do {                                         \
  |  |   37|     11|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 11]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|     11|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 11]
  |  |  ------------------
  ------------------
  674|     11|    return WEBP_INFO_PARSE_ERROR;
  675|     11|  }
  676|     94|  ++webp_info->chunk_counts[CHUNK_VP8X];
  677|     94|  webp_info->feature_flags = *data;
  678|     94|  data += 4;
  679|     94|  webp_info->canvas_width = 1 + ReadLE24(&data);
  680|     94|  webp_info->canvas_height = 1 + ReadLE24(&data);
  681|     94|  if (!webp_info->quiet) {
  ------------------
  |  Branch (681:7): [True: 0, False: 94]
  ------------------
  682|      0|    printf("  ICCP: %d\n  Alpha: %d\n  EXIF: %d\n  XMP: %d\n  Animation: %d\n",
  683|      0|           (webp_info->feature_flags & ICCP_FLAG) != 0,
  684|      0|           (webp_info->feature_flags & ALPHA_FLAG) != 0,
  685|      0|           (webp_info->feature_flags & EXIF_FLAG) != 0,
  686|      0|           (webp_info->feature_flags & XMP_FLAG) != 0,
  687|      0|           (webp_info->feature_flags & ANIMATION_FLAG) != 0);
  688|      0|    printf("  Canvas size %d x %d\n", webp_info->canvas_width,
  689|      0|           webp_info->canvas_height);
  690|      0|  }
  691|     94|  if (webp_info->canvas_width > MAX_CANVAS_SIZE) {
  ------------------
  |  |   88|     94|#define MAX_CANVAS_SIZE (1 << 24)      // 24-bit max for VP8X width/height.
  ------------------
  |  Branch (691:7): [True: 0, False: 94]
  ------------------
  692|      0|    LOG_WARN("Canvas width is out of range in VP8X chunk.");
  ------------------
  |  |   43|      0|  do {                                           \
  |  |   44|      0|    if (webp_info->show_diagnosis) {             \
  |  |  ------------------
  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   45|      0|      fprintf(stderr, "Warning: %s\n", MESSAGE); \
  |  |   46|      0|    }                                            \
  |  |   47|      0|    ++webp_info->num_warnings;                   \
  |  |   48|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  693|      0|  }
  694|     94|  if (webp_info->canvas_height > MAX_CANVAS_SIZE) {
  ------------------
  |  |   88|     94|#define MAX_CANVAS_SIZE (1 << 24)      // 24-bit max for VP8X width/height.
  ------------------
  |  Branch (694:7): [True: 0, False: 94]
  ------------------
  695|      0|    LOG_WARN("Canvas height is out of range in VP8X chunk.");
  ------------------
  |  |   43|      0|  do {                                           \
  |  |   44|      0|    if (webp_info->show_diagnosis) {             \
  |  |  ------------------
  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   45|      0|      fprintf(stderr, "Warning: %s\n", MESSAGE); \
  |  |   46|      0|    }                                            \
  |  |   47|      0|    ++webp_info->num_warnings;                   \
  |  |   48|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  696|      0|  }
  697|     94|  if ((uint64_t)webp_info->canvas_width * webp_info->canvas_height >
  ------------------
  |  Branch (697:7): [True: 56, False: 38]
  ------------------
  698|     94|      MAX_IMAGE_AREA) {
  ------------------
  |  |   89|     94|#define MAX_IMAGE_AREA (1ULL << 32)    // 32-bit max for width x height.
  ------------------
  699|       |    LOG_WARN("Canvas area is out of range in VP8X chunk.");
  ------------------
  |  |   43|     56|  do {                                           \
  |  |   44|     56|    if (webp_info->show_diagnosis) {             \
  |  |  ------------------
  |  |  |  Branch (44:9): [True: 0, False: 56]
  |  |  ------------------
  |  |   45|      0|      fprintf(stderr, "Warning: %s\n", MESSAGE); \
  |  |   46|      0|    }                                            \
  |  |   47|     56|    ++webp_info->num_warnings;                   \
  |  |   48|     56|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded, False: 56]
  |  |  ------------------
  ------------------
  700|     56|  }
  701|     94|  return WEBP_INFO_OK;
  702|    105|}
webp_info_fuzzer.cc:_ZL8ReadLE24PPKh:
  152|    188|static int ReadLE24(const uint8_t** data) {
  153|    188|  const int val = GetLE24(*data);
  154|    188|  *data += 3;
  155|    188|  return val;
  156|    188|}
webp_info_fuzzer.cc:_ZL7GetLE24PKh:
  138|    188|static int GetLE24(const uint8_t* const data) {
  139|    188|  return GetLE16(data) | (data[2] << 16);
  140|    188|}
webp_info_fuzzer.cc:_ZL16ProcessALPHChunkPK9ChunkDataP8WebPInfo:
  864|      1|                                       WebPInfo* const webp_info) {
  865|      1|  if (webp_info->is_processing_anim_frame) {
  ------------------
  |  Branch (865:7): [True: 0, False: 1]
  ------------------
  866|      0|    ++webp_info->anmf_subchunk_counts[2];
  867|      0|    if (webp_info->seen_alpha_subchunk) {
  ------------------
  |  Branch (867:9): [True: 0, False: 0]
  ------------------
  868|      0|      LOG_ERROR("Consecutive ALPH sub-chunks in an ANMF chunk.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  869|      0|      return WEBP_INFO_PARSE_ERROR;
  870|      0|    }
  871|      0|    webp_info->seen_alpha_subchunk = 1;
  872|       |
  873|      0|    if (webp_info->seen_image_subchunk) {
  ------------------
  |  Branch (873:9): [True: 0, False: 0]
  ------------------
  874|      0|      LOG_ERROR(
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  875|      0|          "ALPHA sub-chunk detected after VP8 sub-chunk "
  876|      0|          "in an ANMF chunk.");
  877|      0|      return WEBP_INFO_PARSE_ERROR;
  878|      0|    }
  879|      1|  } else {
  880|      1|    if (webp_info->chunk_counts[CHUNK_ANIM] ||
  ------------------
  |  Branch (880:9): [True: 0, False: 1]
  ------------------
  881|      1|        webp_info->chunk_counts[CHUNK_ANMF]) {
  ------------------
  |  Branch (881:9): [True: 0, False: 1]
  ------------------
  882|      0|      LOG_ERROR("ALPHA chunk and ANIM/ANMF chunk are both detected.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  883|      0|      return WEBP_INFO_PARSE_ERROR;
  884|      0|    }
  885|      1|    if (!webp_info->chunk_counts[CHUNK_VP8X]) {
  ------------------
  |  Branch (885:9): [True: 1, False: 0]
  ------------------
  886|      1|      LOG_ERROR("ALPHA chunk detected before VP8X chunk.");
  ------------------
  |  |   36|      1|  do {                                         \
  |  |   37|      1|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 1]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      1|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 1]
  |  |  ------------------
  ------------------
  887|      1|      return WEBP_INFO_PARSE_ERROR;
  888|      1|    }
  889|      0|    if (webp_info->chunk_counts[CHUNK_VP8]) {
  ------------------
  |  Branch (889:9): [True: 0, False: 0]
  ------------------
  890|      0|      LOG_ERROR("ALPHA chunk detected after VP8 chunk.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  891|      0|      return WEBP_INFO_PARSE_ERROR;
  892|      0|    }
  893|      0|    if (webp_info->chunk_counts[CHUNK_ALPHA]) {
  ------------------
  |  Branch (893:9): [True: 0, False: 0]
  ------------------
  894|      0|      LOG_ERROR("Multiple ALPHA chunks detected.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  895|      0|      return WEBP_INFO_PARSE_ERROR;
  896|      0|    }
  897|      0|    ++webp_info->chunk_counts[CHUNK_ALPHA];
  898|      0|  }
  899|      0|  webp_info->has_alpha = 1;
  900|      0|  if (webp_info->parse_bitstream) {
  ------------------
  |  Branch (900:7): [True: 0, False: 0]
  ------------------
  901|      0|    const WebPInfoStatus status = ParseAlphaHeader(chunk_data, webp_info);
  902|      0|    if (status != WEBP_INFO_OK) return status;
  ------------------
  |  Branch (902:9): [True: 0, False: 0]
  ------------------
  903|      0|  }
  904|      0|  return WEBP_INFO_OK;
  905|      0|}
webp_info_fuzzer.cc:_ZL16ProcessANIMChunkPK9ChunkDataP8WebPInfo:
  705|      1|                                       WebPInfo* const webp_info) {
  706|      1|  const uint8_t* data = chunk_data->payload;
  707|      1|  if (!webp_info->chunk_counts[CHUNK_VP8X]) {
  ------------------
  |  Branch (707:7): [True: 1, False: 0]
  ------------------
  708|      1|    LOG_ERROR("ANIM chunk detected before VP8X chunk.");
  ------------------
  |  |   36|      1|  do {                                         \
  |  |   37|      1|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 1]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      1|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 1]
  |  |  ------------------
  ------------------
  709|      1|    return WEBP_INFO_PARSE_ERROR;
  710|      1|  }
  711|      0|  if (chunk_data->size != ANIM_CHUNK_SIZE + CHUNK_HEADER_SIZE) {
  ------------------
  |  |   85|      0|#define ANIM_CHUNK_SIZE 6    // Size of an ANIM chunk.
  ------------------
                if (chunk_data->size != ANIM_CHUNK_SIZE + CHUNK_HEADER_SIZE) {
  ------------------
  |  |   82|      0|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  |  Branch (711:7): [True: 0, False: 0]
  ------------------
  712|      0|    LOG_ERROR("Corrupted ANIM chunk.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  713|      0|    return WEBP_INFO_PARSE_ERROR;
  714|      0|  }
  715|      0|  webp_info->bgcolor = ReadLE32(&data);
  716|      0|  webp_info->loop_count = ReadLE16(&data);
  717|      0|  ++webp_info->chunk_counts[CHUNK_ANIM];
  718|      0|  if (!webp_info->quiet) {
  ------------------
  |  Branch (718:7): [True: 0, False: 0]
  ------------------
  719|      0|    printf("  Background color:(ARGB) %02x %02x %02x %02x\n",
  720|      0|           (webp_info->bgcolor >> 24) & 0xff, (webp_info->bgcolor >> 16) & 0xff,
  721|      0|           (webp_info->bgcolor >> 8) & 0xff, webp_info->bgcolor & 0xff);
  722|      0|    printf("  Loop count      : %d\n", webp_info->loop_count);
  723|      0|  }
  724|      0|  if (webp_info->loop_count > MAX_LOOP_COUNT) {
  ------------------
  |  |   90|      0|#define MAX_LOOP_COUNT (1 << 16)       // maximum value for loop-count
  ------------------
  |  Branch (724:7): [True: 0, False: 0]
  ------------------
  725|       |    LOG_WARN("Loop count is out of range in ANIM chunk.");
  ------------------
  |  |   43|      0|  do {                                           \
  |  |   44|      0|    if (webp_info->show_diagnosis) {             \
  |  |  ------------------
  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   45|      0|      fprintf(stderr, "Warning: %s\n", MESSAGE); \
  |  |   46|      0|    }                                            \
  |  |   47|      0|    ++webp_info->num_warnings;                   \
  |  |   48|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  726|      0|  }
  727|      0|  return WEBP_INFO_OK;
  728|      0|}
webp_info_fuzzer.cc:_ZL16ProcessANMFChunkPK9ChunkDataP8WebPInfo:
  731|      1|                                       WebPInfo* const webp_info) {
  732|      1|  const uint8_t* data = chunk_data->payload;
  733|      1|  int offset_x, offset_y, width, height, duration, blend, dispose, temp;
  734|      1|  if (webp_info->is_processing_anim_frame) {
  ------------------
  |  Branch (734:7): [True: 0, False: 1]
  ------------------
  735|      0|    LOG_ERROR("ANMF chunk detected within another ANMF chunk.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  736|      0|    return WEBP_INFO_PARSE_ERROR;
  737|      0|  }
  738|      1|  if (!webp_info->chunk_counts[CHUNK_ANIM]) {
  ------------------
  |  Branch (738:7): [True: 1, False: 0]
  ------------------
  739|      1|    LOG_ERROR("ANMF chunk detected before ANIM chunk.");
  ------------------
  |  |   36|      1|  do {                                         \
  |  |   37|      1|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 1]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      1|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 1]
  |  |  ------------------
  ------------------
  740|      1|    return WEBP_INFO_PARSE_ERROR;
  741|      1|  }
  742|      0|  if (chunk_data->size <= CHUNK_HEADER_SIZE + ANMF_CHUNK_SIZE) {
  ------------------
  |  |   82|      0|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
                if (chunk_data->size <= CHUNK_HEADER_SIZE + ANMF_CHUNK_SIZE) {
  ------------------
  |  |   84|      0|#define ANMF_CHUNK_SIZE 16   // Size of an ANMF chunk.
  ------------------
  |  Branch (742:7): [True: 0, False: 0]
  ------------------
  743|      0|    LOG_ERROR("Truncated data detected when parsing ANMF chunk.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  744|      0|    return WEBP_INFO_TRUNCATED_DATA;
  745|      0|  }
  746|      0|  offset_x = 2 * ReadLE24(&data);
  747|      0|  offset_y = 2 * ReadLE24(&data);
  748|      0|  width = 1 + ReadLE24(&data);
  749|      0|  height = 1 + ReadLE24(&data);
  750|      0|  duration = ReadLE24(&data);
  751|      0|  temp = *data;
  752|      0|  dispose = temp & 1;
  753|      0|  blend = (temp >> 1) & 1;
  754|      0|  ++webp_info->chunk_counts[CHUNK_ANMF];
  755|      0|  if (!webp_info->quiet) {
  ------------------
  |  Branch (755:7): [True: 0, False: 0]
  ------------------
  756|      0|    printf(
  757|      0|        "  Offset_X: %d\n  Offset_Y: %d\n  Width: %d\n  Height: %d\n"
  758|      0|        "  Duration: %d\n  Dispose: %d\n  Blend: %d\n",
  759|      0|        offset_x, offset_y, width, height, duration, dispose, blend);
  760|      0|  }
  761|      0|  if (duration > MAX_DURATION) {
  ------------------
  |  |   91|      0|#define MAX_DURATION (1 << 24)         // maximum duration
  ------------------
  |  Branch (761:7): [True: 0, False: 0]
  ------------------
  762|      0|    LOG_ERROR("Invalid duration parameter in ANMF chunk.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  763|      0|    return WEBP_INFO_INVALID_PARAM;
  764|      0|  }
  765|      0|  if (offset_x > MAX_POSITION_OFFSET || offset_y > MAX_POSITION_OFFSET) {
  ------------------
  |  |   92|      0|#define MAX_POSITION_OFFSET (1 << 24)  // maximum frame x/y offset
  ------------------
                if (offset_x > MAX_POSITION_OFFSET || offset_y > MAX_POSITION_OFFSET) {
  ------------------
  |  |   92|      0|#define MAX_POSITION_OFFSET (1 << 24)  // maximum frame x/y offset
  ------------------
  |  Branch (765:7): [True: 0, False: 0]
  |  Branch (765:41): [True: 0, False: 0]
  ------------------
  766|      0|    LOG_ERROR("Invalid offset parameters in ANMF chunk.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  767|      0|    return WEBP_INFO_INVALID_PARAM;
  768|      0|  }
  769|      0|  if ((uint64_t)offset_x + width > (uint64_t)webp_info->canvas_width ||
  ------------------
  |  Branch (769:7): [True: 0, False: 0]
  ------------------
  770|      0|      (uint64_t)offset_y + height > (uint64_t)webp_info->canvas_height) {
  ------------------
  |  Branch (770:7): [True: 0, False: 0]
  ------------------
  771|      0|    LOG_ERROR("Frame exceeds canvas in ANMF chunk.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  772|      0|    return WEBP_INFO_INVALID_PARAM;
  773|      0|  }
  774|      0|  webp_info->is_processing_anim_frame = 1;
  775|      0|  webp_info->seen_alpha_subchunk = 0;
  776|      0|  webp_info->seen_image_subchunk = 0;
  777|      0|  webp_info->frame_width = width;
  778|      0|  webp_info->frame_height = height;
  779|      0|  webp_info->anim_frame_data_size =
  780|      0|      chunk_data->size - CHUNK_HEADER_SIZE - ANMF_CHUNK_SIZE;
  ------------------
  |  |   82|      0|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
                    chunk_data->size - CHUNK_HEADER_SIZE - ANMF_CHUNK_SIZE;
  ------------------
  |  |   84|      0|#define ANMF_CHUNK_SIZE 16   // Size of an ANMF chunk.
  ------------------
  781|      0|  return WEBP_INFO_OK;
  782|      0|}
webp_info_fuzzer.cc:_ZL16ProcessICCPChunkPK9ChunkDataP8WebPInfo:
  908|      2|                                       WebPInfo* const webp_info) {
  909|      2|  (void)chunk_data;
  910|      2|  if (!webp_info->chunk_counts[CHUNK_VP8X]) {
  ------------------
  |  Branch (910:7): [True: 2, False: 0]
  ------------------
  911|      2|    LOG_ERROR("ICCP chunk detected before VP8X chunk.");
  ------------------
  |  |   36|      2|  do {                                         \
  |  |   37|      2|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 2]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      2|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 2]
  |  |  ------------------
  ------------------
  912|      2|    return WEBP_INFO_PARSE_ERROR;
  913|      2|  }
  914|      0|  if (webp_info->chunk_counts[CHUNK_VP8] ||
  ------------------
  |  Branch (914:7): [True: 0, False: 0]
  ------------------
  915|      0|      webp_info->chunk_counts[CHUNK_VP8L] ||
  ------------------
  |  Branch (915:7): [True: 0, False: 0]
  ------------------
  916|      0|      webp_info->chunk_counts[CHUNK_ANIM]) {
  ------------------
  |  Branch (916:7): [True: 0, False: 0]
  ------------------
  917|      0|    LOG_ERROR("ICCP chunk detected after image data.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  918|      0|    return WEBP_INFO_PARSE_ERROR;
  919|      0|  }
  920|      0|  ++webp_info->chunk_counts[CHUNK_ICCP];
  921|      0|  return WEBP_INFO_OK;
  922|      0|}
webp_info_fuzzer.cc:_ZL8ValidateP8WebPInfo:
  992|    459|static WebPInfoStatus Validate(WebPInfo* const webp_info) {
  993|    459|  if (webp_info->num_frames < 1) {
  ------------------
  |  Branch (993:7): [True: 344, False: 115]
  ------------------
  994|    344|    LOG_ERROR("No image/frame detected.");
  ------------------
  |  |   36|    344|  do {                                         \
  |  |   37|    344|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 344]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|    344|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 344]
  |  |  ------------------
  ------------------
  995|    344|    return WEBP_INFO_MISSING_DATA;
  996|    344|  }
  997|    115|  if (webp_info->chunk_counts[CHUNK_VP8X]) {
  ------------------
  |  Branch (997:7): [True: 0, False: 115]
  ------------------
  998|      0|    const int iccp = !!(webp_info->feature_flags & ICCP_FLAG);
  999|      0|    const int exif = !!(webp_info->feature_flags & EXIF_FLAG);
 1000|      0|    const int xmp = !!(webp_info->feature_flags & XMP_FLAG);
 1001|      0|    const int animation = !!(webp_info->feature_flags & ANIMATION_FLAG);
 1002|      0|    const int alpha = !!(webp_info->feature_flags & ALPHA_FLAG);
 1003|      0|    if (!alpha && webp_info->has_alpha) {
  ------------------
  |  Branch (1003:9): [True: 0, False: 0]
  |  Branch (1003:19): [True: 0, False: 0]
  ------------------
 1004|      0|      LOG_ERROR("Unexpected alpha data detected.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1005|      0|      return WEBP_INFO_PARSE_ERROR;
 1006|      0|    }
 1007|      0|    if (alpha && !webp_info->has_alpha) {
  ------------------
  |  Branch (1007:9): [True: 0, False: 0]
  |  Branch (1007:18): [True: 0, False: 0]
  ------------------
 1008|      0|      LOG_WARN("Alpha flag is set with no alpha data present.");
  ------------------
  |  |   43|      0|  do {                                           \
  |  |   44|      0|    if (webp_info->show_diagnosis) {             \
  |  |  ------------------
  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   45|      0|      fprintf(stderr, "Warning: %s\n", MESSAGE); \
  |  |   46|      0|    }                                            \
  |  |   47|      0|    ++webp_info->num_warnings;                   \
  |  |   48|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1009|      0|    }
 1010|      0|    if (iccp && !webp_info->chunk_counts[CHUNK_ICCP]) {
  ------------------
  |  Branch (1010:9): [True: 0, False: 0]
  |  Branch (1010:17): [True: 0, False: 0]
  ------------------
 1011|      0|      LOG_ERROR("Missing ICCP chunk.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1012|      0|      return WEBP_INFO_MISSING_DATA;
 1013|      0|    }
 1014|      0|    if (exif && !webp_info->chunk_counts[CHUNK_EXIF]) {
  ------------------
  |  Branch (1014:9): [True: 0, False: 0]
  |  Branch (1014:17): [True: 0, False: 0]
  ------------------
 1015|      0|      LOG_ERROR("Missing EXIF chunk.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1016|      0|      return WEBP_INFO_MISSING_DATA;
 1017|      0|    }
 1018|      0|    if (xmp && !webp_info->chunk_counts[CHUNK_XMP]) {
  ------------------
  |  Branch (1018:9): [True: 0, False: 0]
  |  Branch (1018:16): [True: 0, False: 0]
  ------------------
 1019|      0|      LOG_ERROR("Missing XMP chunk.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1020|      0|      return WEBP_INFO_MISSING_DATA;
 1021|      0|    }
 1022|      0|    if (!iccp && webp_info->chunk_counts[CHUNK_ICCP]) {
  ------------------
  |  Branch (1022:9): [True: 0, False: 0]
  |  Branch (1022:18): [True: 0, False: 0]
  ------------------
 1023|      0|      LOG_ERROR("Unexpected ICCP chunk detected.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1024|      0|      return WEBP_INFO_PARSE_ERROR;
 1025|      0|    }
 1026|      0|    if (!exif && webp_info->chunk_counts[CHUNK_EXIF]) {
  ------------------
  |  Branch (1026:9): [True: 0, False: 0]
  |  Branch (1026:18): [True: 0, False: 0]
  ------------------
 1027|      0|      LOG_ERROR("Unexpected EXIF chunk detected.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1028|      0|      return WEBP_INFO_PARSE_ERROR;
 1029|      0|    }
 1030|      0|    if (!xmp && webp_info->chunk_counts[CHUNK_XMP]) {
  ------------------
  |  Branch (1030:9): [True: 0, False: 0]
  |  Branch (1030:17): [True: 0, False: 0]
  ------------------
 1031|      0|      LOG_ERROR("Unexpected XMP chunk detected.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1032|      0|      return WEBP_INFO_PARSE_ERROR;
 1033|      0|    }
 1034|       |    // Incomplete animation frame.
 1035|      0|    if (webp_info->is_processing_anim_frame) return WEBP_INFO_MISSING_DATA;
  ------------------
  |  Branch (1035:9): [True: 0, False: 0]
  ------------------
 1036|      0|    if (!animation && webp_info->num_frames > 1) {
  ------------------
  |  Branch (1036:9): [True: 0, False: 0]
  |  Branch (1036:23): [True: 0, False: 0]
  ------------------
 1037|      0|      LOG_ERROR("More than 1 frame detected in non-animation file.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1038|      0|      return WEBP_INFO_PARSE_ERROR;
 1039|      0|    }
 1040|      0|    if (animation && (!webp_info->chunk_counts[CHUNK_ANIM] ||
  ------------------
  |  Branch (1040:9): [True: 0, False: 0]
  |  Branch (1040:23): [True: 0, False: 0]
  ------------------
 1041|      0|                      !webp_info->chunk_counts[CHUNK_ANMF])) {
  ------------------
  |  Branch (1041:23): [True: 0, False: 0]
  ------------------
 1042|      0|      LOG_ERROR("No ANIM/ANMF chunk detected in animation file.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1043|      0|      return WEBP_INFO_PARSE_ERROR;
 1044|      0|    }
 1045|      0|  }
 1046|    115|  return WEBP_INFO_OK;
 1047|    115|}

VP8CheckSignature:
  117|    388|                      size_t data_size) {
  118|    388|  return (data_size >= 3 && data[0] == 0x9d && data[1] == 0x01 &&
  ------------------
  |  Branch (118:11): [True: 388, False: 0]
  |  Branch (118:29): [True: 376, False: 12]
  |  Branch (118:48): [True: 367, False: 9]
  ------------------
  119|    367|          data[2] == 0x2a);
  ------------------
  |  Branch (119:11): [True: 356, False: 11]
  ------------------
  120|    388|}
VP8GetInfo:
  123|    388|               size_t chunk_size, int* const width, int* const height) {
  124|    388|  if (data == NULL || data_size < VP8_FRAME_HEADER_SIZE) {
  ------------------
  |  |   24|    388|#define VP8_FRAME_HEADER_SIZE 10  // Size of the frame header within VP8 data.
  ------------------
  |  Branch (124:7): [True: 0, False: 388]
  |  Branch (124:23): [True: 0, False: 388]
  ------------------
  125|      0|    return 0;  // not enough data
  126|      0|  }
  127|       |  // check signature
  128|    388|  if (!VP8CheckSignature(data + 3, data_size - 3)) {
  ------------------
  |  Branch (128:7): [True: 32, False: 356]
  ------------------
  129|     32|    return 0;  // Wrong signature.
  130|    356|  } else {
  131|    356|    const uint32_t bits = data[0] | (data[1] << 8) | (data[2] << 16);
  132|    356|    const int key_frame = !(bits & 1);
  133|    356|    const int w = ((data[7] << 8) | data[6]) & 0x3fff;
  134|    356|    const int h = ((data[9] << 8) | data[8]) & 0x3fff;
  135|       |
  136|    356|    if (!key_frame) {  // Not a keyframe.
  ------------------
  |  Branch (136:9): [True: 1, False: 355]
  ------------------
  137|      1|      return 0;
  138|      1|    }
  139|       |
  140|    355|    if (((bits >> 1) & 7) > 3) {
  ------------------
  |  Branch (140:9): [True: 1, False: 354]
  ------------------
  141|      1|      return 0;  // unknown profile
  142|      1|    }
  143|    354|    if (!((bits >> 4) & 1)) {
  ------------------
  |  Branch (143:9): [True: 1, False: 353]
  ------------------
  144|      1|      return 0;  // first frame is invisible!
  145|      1|    }
  146|    353|    if (((bits >> 5)) >= chunk_size) {  // partition_length
  ------------------
  |  Branch (146:9): [True: 14, False: 339]
  ------------------
  147|     14|      return 0;                         // inconsistent size information.
  148|     14|    }
  149|    339|    if (w == 0 || h == 0) {
  ------------------
  |  Branch (149:9): [True: 1, False: 338]
  |  Branch (149:19): [True: 2, False: 336]
  ------------------
  150|      3|      return 0;  // We don't support a zero width or height.
  151|      3|    }
  152|       |
  153|    336|    if (width) {
  ------------------
  |  Branch (153:9): [True: 336, False: 0]
  ------------------
  154|    336|      *width = w;
  155|    336|    }
  156|    336|    if (height) {
  ------------------
  |  Branch (156:9): [True: 336, False: 0]
  ------------------
  157|    336|      *height = h;
  158|    336|    }
  159|       |
  160|    336|    return 1;
  161|    339|  }
  162|    388|}

VP8LCheckSignature:
  107|     87|                       size_t size) {
  108|     87|  return (size >= VP8L_FRAME_HEADER_SIZE && data[0] == VP8L_MAGIC_BYTE &&
  ------------------
  |  |   33|    174|#define VP8L_FRAME_HEADER_SIZE 5  // Size of the VP8L frame header.
  ------------------
                return (size >= VP8L_FRAME_HEADER_SIZE && data[0] == VP8L_MAGIC_BYTE &&
  ------------------
  |  |   28|    174|#define VP8L_MAGIC_BYTE 0x2f   // VP8L signature byte.
  ------------------
  |  Branch (108:11): [True: 87, False: 0]
  |  Branch (108:45): [True: 82, False: 5]
  ------------------
  109|     82|          (data[4] >> 5) == 0);  // version
  ------------------
  |  Branch (109:11): [True: 79, False: 3]
  ------------------
  110|     87|}
VP8LGetInfo:
  125|     87|                int* const has_alpha) {
  126|     87|  if (data == NULL || data_size < VP8L_FRAME_HEADER_SIZE) {
  ------------------
  |  |   33|     87|#define VP8L_FRAME_HEADER_SIZE 5  // Size of the VP8L frame header.
  ------------------
  |  Branch (126:7): [True: 0, False: 87]
  |  Branch (126:23): [True: 0, False: 87]
  ------------------
  127|      0|    return 0;  // not enough data
  128|     87|  } else if (!VP8LCheckSignature(data, data_size)) {
  ------------------
  |  Branch (128:14): [True: 8, False: 79]
  ------------------
  129|      8|    return 0;  // bad signature
  130|     79|  } else {
  131|     79|    int w, h, a;
  132|     79|    VP8LBitReader br;
  133|     79|    VP8LInitBitReader(&br, data, data_size);
  134|     79|    if (!ReadImageInfo(&br, &w, &h, &a)) {
  ------------------
  |  Branch (134:9): [True: 0, False: 79]
  ------------------
  135|      0|      return 0;
  136|      0|    }
  137|     79|    if (width != NULL) *width = w;
  ------------------
  |  Branch (137:9): [True: 79, False: 0]
  ------------------
  138|     79|    if (height != NULL) *height = h;
  ------------------
  |  Branch (138:9): [True: 79, False: 0]
  ------------------
  139|     79|    if (has_alpha != NULL) *has_alpha = a;
  ------------------
  |  Branch (139:9): [True: 79, False: 0]
  ------------------
  140|     79|    return 1;
  141|     79|  }
  142|     87|}
vp8l_dec.c:ReadImageInfo:
  114|     79|                                        int* const has_alpha) {
  115|     79|  if (VP8LReadBits(br, 8) != VP8L_MAGIC_BYTE) return 0;
  ------------------
  |  |   28|     79|#define VP8L_MAGIC_BYTE 0x2f   // VP8L signature byte.
  ------------------
  |  Branch (115:7): [True: 0, False: 79]
  ------------------
  116|     79|  *width = VP8LReadBits(br, VP8L_IMAGE_SIZE_BITS) + 1;
  ------------------
  |  |   30|     79|  14                         // Number of bits used to store width and height.
  ------------------
  117|     79|  *height = VP8LReadBits(br, VP8L_IMAGE_SIZE_BITS) + 1;
  ------------------
  |  |   30|     79|  14                         // Number of bits used to store width and height.
  ------------------
  118|     79|  *has_alpha = VP8LReadBits(br, 1);
  119|     79|  if (VP8LReadBits(br, VP8L_VERSION_BITS) != 0) return 0;
  ------------------
  |  |   31|     79|#define VP8L_VERSION_BITS 3  // 3 bits reserved for version.
  ------------------
  |  Branch (119:7): [True: 0, False: 79]
  ------------------
  120|     79|  return !br->eos;
  121|     79|}

WebPGetFeaturesInternal:
  851|    482|                                      int version) {
  852|    482|  if (WEBP_ABI_IS_INCOMPATIBLE(version, WEBP_DECODER_ABI_VERSION)) {
  ------------------
  |  |   84|    482|#define WEBP_ABI_IS_INCOMPATIBLE(a, b) (((a) >> 8) != ((b) >> 8))
  |  |  ------------------
  |  |  |  Branch (84:40): [True: 0, False: 482]
  |  |  ------------------
  ------------------
  853|      0|    return VP8_STATUS_INVALID_PARAM;  // version mismatch
  854|      0|  }
  855|    482|  if (features == NULL) {
  ------------------
  |  Branch (855:7): [True: 0, False: 482]
  ------------------
  856|      0|    return VP8_STATUS_INVALID_PARAM;
  857|      0|  }
  858|    482|  return GetFeatures(data, data_size, features);
  859|    482|}
webp_dec.c:ParseHeadersInternal:
  299|    482|    WebPHeaderStructure* const headers) {
  300|    482|  size_t data_size = data_size_param;
  301|    482|  const uint8_t* WEBP_COUNTED_BY(data_size) data = data_param;
  302|    482|  int canvas_width = 0;
  303|    482|  int canvas_height = 0;
  304|    482|  int image_width = 0;
  305|    482|  int image_height = 0;
  306|    482|  int found_riff = 0;
  307|    482|  int found_vp8x = 0;
  308|    482|  int animation_present = 0;
  309|    482|  const int have_all_data = (headers != NULL) ? headers->have_all_data : 0;
  ------------------
  |  Branch (309:29): [True: 0, False: 482]
  ------------------
  310|       |
  311|    482|  VP8StatusCode status;
  312|    482|  WebPHeaderStructure hdrs;
  313|       |
  314|    482|  if (data == NULL || data_size < RIFF_HEADER_SIZE) {
  ------------------
  |  |   83|    482|#define RIFF_HEADER_SIZE 12  // Size of the RIFF header ("RIFFnnnnWEBP").
  ------------------
  |  Branch (314:7): [True: 0, False: 482]
  |  Branch (314:23): [True: 3, False: 479]
  ------------------
  315|      3|    return VP8_STATUS_NOT_ENOUGH_DATA;
  316|      3|  }
  317|    479|  WEBP_UNSAFE_MEMSET(&hdrs, 0, sizeof(hdrs));
  ------------------
  |  |  175|    479|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  318|    479|  hdrs.data = data;
  319|    479|  hdrs.data_size = data_size;
  320|       |
  321|       |  // Skip over RIFF header.
  322|    479|  status = ParseRIFF(&data, &data_size, have_all_data, &hdrs.riff_size);
  323|    479|  if (status != VP8_STATUS_OK) {
  ------------------
  |  Branch (323:7): [True: 0, False: 479]
  ------------------
  324|      0|    return status;  // Wrong RIFF header / insufficient data.
  325|      0|  }
  326|    479|  found_riff = (hdrs.riff_size > 0);
  327|       |
  328|       |  // Skip over VP8X.
  329|    479|  {
  330|    479|    uint32_t flags = 0;
  331|    479|    status = ParseVP8X(&data, &data_size, &found_vp8x, &canvas_width,
  332|    479|                       &canvas_height, &flags);
  333|    479|    if (status != VP8_STATUS_OK) {
  ------------------
  |  Branch (333:9): [True: 0, False: 479]
  ------------------
  334|      0|      return status;  // Wrong VP8X / insufficient data.
  335|      0|    }
  336|    479|    animation_present = !!(flags & ANIMATION_FLAG);
  337|    479|    if (!found_riff && found_vp8x) {
  ------------------
  |  Branch (337:9): [True: 479, False: 0]
  |  Branch (337:24): [True: 0, False: 479]
  ------------------
  338|       |      // Note: This restriction may be removed in the future, if it becomes
  339|       |      // necessary to send VP8X chunk to the decoder.
  340|      0|      return VP8_STATUS_BITSTREAM_ERROR;
  341|      0|    }
  342|    479|    if (has_alpha != NULL) *has_alpha = !!(flags & ALPHA_FLAG);
  ------------------
  |  Branch (342:9): [True: 479, False: 0]
  ------------------
  343|    479|    if (has_animation != NULL) *has_animation = animation_present;
  ------------------
  |  Branch (343:9): [True: 479, False: 0]
  ------------------
  344|    479|    if (format != NULL) *format = 0;  // default = undefined
  ------------------
  |  Branch (344:9): [True: 479, False: 0]
  ------------------
  345|       |
  346|    479|    image_width = canvas_width;
  347|    479|    image_height = canvas_height;
  348|    479|    if (found_vp8x && animation_present && headers == NULL) {
  ------------------
  |  Branch (348:9): [True: 0, False: 479]
  |  Branch (348:23): [True: 0, False: 0]
  |  Branch (348:44): [True: 0, False: 0]
  ------------------
  349|      0|      status = VP8_STATUS_OK;
  350|      0|      goto ReturnWidthHeight;  // Just return features from VP8X header.
  351|      0|    }
  352|    479|  }
  353|       |
  354|    479|  if (data_size < TAG_SIZE) {
  ------------------
  |  |   80|    479|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  |  Branch (354:7): [True: 0, False: 479]
  ------------------
  355|      0|    status = VP8_STATUS_NOT_ENOUGH_DATA;
  356|      0|    goto ReturnWidthHeight;
  357|      0|  }
  358|       |
  359|       |  // Skip over optional chunks if data started with "RIFF + VP8X" or "ALPH".
  360|    479|  if ((found_riff && found_vp8x) ||
  ------------------
  |  Branch (360:8): [True: 0, False: 479]
  |  Branch (360:22): [True: 0, False: 0]
  ------------------
  361|    479|      (!found_riff && !found_vp8x && !memcmp(data, "ALPH", TAG_SIZE))) {
  ------------------
  |  |   80|    479|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  |  Branch (361:8): [True: 479, False: 0]
  |  Branch (361:23): [True: 479, False: 0]
  |  Branch (361:38): [True: 0, False: 479]
  ------------------
  362|      0|    size_t local_alpha_data_size = 0;
  363|      0|    const uint8_t* WEBP_COUNTED_BY(local_alpha_data_size) local_alpha_data =
  364|      0|        NULL;
  365|      0|    status = ParseOptionalChunks(&data, &data_size, hdrs.riff_size,
  366|      0|                                 &local_alpha_data, &local_alpha_data_size);
  367|      0|    if (status != VP8_STATUS_OK) {
  ------------------
  |  Branch (367:9): [True: 0, False: 0]
  ------------------
  368|      0|      goto ReturnWidthHeight;  // Invalid chunk size / insufficient data.
  369|      0|    }
  370|      0|    hdrs.alpha_data = local_alpha_data;
  371|      0|    hdrs.alpha_data_size = local_alpha_data_size;
  372|      0|  }
  373|       |
  374|       |  // Skip over VP8/VP8L header.
  375|    479|  status = ParseVP8Header(&data, &data_size, have_all_data, hdrs.riff_size,
  376|    479|                          &hdrs.compressed_size, &hdrs.is_lossless);
  377|    479|  if (status != VP8_STATUS_OK) {
  ------------------
  |  Branch (377:7): [True: 0, False: 479]
  ------------------
  378|      0|    goto ReturnWidthHeight;  // Wrong VP8/VP8L chunk-header / insufficient data.
  379|      0|  }
  380|    479|  if (hdrs.compressed_size > MAX_CHUNK_PAYLOAD) {
  ------------------
  |  |   96|    479|#define MAX_CHUNK_PAYLOAD (~0U - CHUNK_HEADER_SIZE - 1)
  |  |  ------------------
  |  |  |  |   82|    479|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  |  |  ------------------
  ------------------
  |  Branch (380:7): [True: 0, False: 479]
  ------------------
  381|      0|    return VP8_STATUS_BITSTREAM_ERROR;
  382|      0|  }
  383|       |
  384|    479|  if (format != NULL && !animation_present) {
  ------------------
  |  Branch (384:7): [True: 479, False: 0]
  |  Branch (384:25): [True: 479, False: 0]
  ------------------
  385|    479|    *format = hdrs.is_lossless ? 2 : 1;
  ------------------
  |  Branch (385:15): [True: 88, False: 391]
  ------------------
  386|    479|  }
  387|       |
  388|    479|  if (!hdrs.is_lossless) {
  ------------------
  |  Branch (388:7): [True: 391, False: 88]
  ------------------
  389|    391|    if (data_size < VP8_FRAME_HEADER_SIZE) {
  ------------------
  |  |   24|    391|#define VP8_FRAME_HEADER_SIZE 10  // Size of the frame header within VP8 data.
  ------------------
  |  Branch (389:9): [True: 3, False: 388]
  ------------------
  390|      3|      status = VP8_STATUS_NOT_ENOUGH_DATA;
  391|      3|      goto ReturnWidthHeight;
  392|      3|    }
  393|       |    // Validates raw VP8 data.
  394|    388|    if (!VP8GetInfo(data, data_size, (uint32_t)hdrs.compressed_size,
  ------------------
  |  Branch (394:9): [True: 52, False: 336]
  ------------------
  395|    388|                    &image_width, &image_height)) {
  396|     52|      return VP8_STATUS_BITSTREAM_ERROR;
  397|     52|    }
  398|    388|  } else {
  399|     88|    if (data_size < VP8L_FRAME_HEADER_SIZE) {
  ------------------
  |  |   33|     88|#define VP8L_FRAME_HEADER_SIZE 5  // Size of the VP8L frame header.
  ------------------
  |  Branch (399:9): [True: 1, False: 87]
  ------------------
  400|      1|      status = VP8_STATUS_NOT_ENOUGH_DATA;
  401|      1|      goto ReturnWidthHeight;
  402|      1|    }
  403|       |    // Validates raw VP8L data.
  404|     87|    if (!VP8LGetInfo(data, data_size, &image_width, &image_height, has_alpha)) {
  ------------------
  |  Branch (404:9): [True: 8, False: 79]
  ------------------
  405|      8|      return VP8_STATUS_BITSTREAM_ERROR;
  406|      8|    }
  407|     87|  }
  408|       |  // Validates image size coherency.
  409|    415|  if (found_vp8x) {
  ------------------
  |  Branch (409:7): [True: 0, False: 415]
  ------------------
  410|      0|    if (canvas_width != image_width || canvas_height != image_height) {
  ------------------
  |  Branch (410:9): [True: 0, False: 0]
  |  Branch (410:40): [True: 0, False: 0]
  ------------------
  411|      0|      return VP8_STATUS_BITSTREAM_ERROR;
  412|      0|    }
  413|      0|  }
  414|    415|  if (headers != NULL) {
  ------------------
  |  Branch (414:7): [True: 0, False: 415]
  ------------------
  415|      0|    *headers = hdrs;
  416|      0|    headers->offset = data - headers->data;
  417|      0|    assert((uint64_t)(data - headers->data) < MAX_CHUNK_PAYLOAD);
  418|      0|    assert(headers->offset == headers->data_size - data_size);
  419|      0|  }
  420|    419|ReturnWidthHeight:
  421|    419|  if (status == VP8_STATUS_OK ||
  ------------------
  |  Branch (421:7): [True: 415, False: 4]
  ------------------
  422|    415|      (status == VP8_STATUS_NOT_ENOUGH_DATA && found_vp8x && headers == NULL)) {
  ------------------
  |  Branch (422:8): [True: 4, False: 0]
  |  Branch (422:48): [True: 0, False: 4]
  |  Branch (422:62): [True: 0, False: 0]
  ------------------
  423|    415|    if (has_alpha != NULL) {
  ------------------
  |  Branch (423:9): [True: 415, False: 0]
  ------------------
  424|       |      // If the data did not contain a VP8X/VP8L chunk the only definitive way
  425|       |      // to set this is by looking for alpha data (from an ALPH chunk).
  426|    415|      *has_alpha |= (hdrs.alpha_data != NULL);
  427|    415|    }
  428|    415|    if (width != NULL) *width = image_width;
  ------------------
  |  Branch (428:9): [True: 415, False: 0]
  ------------------
  429|    415|    if (height != NULL) *height = image_height;
  ------------------
  |  Branch (429:9): [True: 415, False: 0]
  ------------------
  430|    415|    return VP8_STATUS_OK;
  431|    415|  } else {
  432|      4|    return status;
  433|      4|  }
  434|    419|}
webp_dec.c:ParseRIFF:
   68|    479|                               size_t* WEBP_SINGLE const riff_size) {
   69|    479|  assert(data != NULL);
   70|    479|  assert(data_size != NULL);
   71|    479|  assert(riff_size != NULL);
   72|       |
   73|    479|  *riff_size = 0;  // Default: no RIFF present.
   74|    479|  if (*data_size >= RIFF_HEADER_SIZE && !memcmp(*data, "RIFF", TAG_SIZE)) {
  ------------------
  |  |   83|    958|#define RIFF_HEADER_SIZE 12  // Size of the RIFF header ("RIFFnnnnWEBP").
  ------------------
                if (*data_size >= RIFF_HEADER_SIZE && !memcmp(*data, "RIFF", TAG_SIZE)) {
  ------------------
  |  |   80|    479|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  |  Branch (74:7): [True: 479, False: 0]
  |  Branch (74:41): [True: 0, False: 479]
  ------------------
   75|      0|    if (memcmp(*data + 8, "WEBP", TAG_SIZE)) {
  ------------------
  |  |   80|      0|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  |  Branch (75:9): [True: 0, False: 0]
  ------------------
   76|      0|      return VP8_STATUS_BITSTREAM_ERROR;  // Wrong image file signature.
   77|      0|    } else {
   78|      0|      const uint32_t size = GetLE32(*data + TAG_SIZE);
  ------------------
  |  |   80|      0|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
   79|       |      // Check that we have at least one chunk (i.e "WEBP" + "VP8?nnnn").
   80|      0|      if (size < TAG_SIZE + CHUNK_HEADER_SIZE) {
  ------------------
  |  |   80|      0|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
                    if (size < TAG_SIZE + CHUNK_HEADER_SIZE) {
  ------------------
  |  |   82|      0|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  |  Branch (80:11): [True: 0, False: 0]
  ------------------
   81|      0|        return VP8_STATUS_BITSTREAM_ERROR;
   82|      0|      }
   83|      0|      if (size > MAX_CHUNK_PAYLOAD) {
  ------------------
  |  |   96|      0|#define MAX_CHUNK_PAYLOAD (~0U - CHUNK_HEADER_SIZE - 1)
  |  |  ------------------
  |  |  |  |   82|      0|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  |  |  ------------------
  ------------------
  |  Branch (83:11): [True: 0, False: 0]
  ------------------
   84|      0|        return VP8_STATUS_BITSTREAM_ERROR;
   85|      0|      }
   86|      0|      if (have_all_data && (size > *data_size - CHUNK_HEADER_SIZE)) {
  ------------------
  |  |   82|      0|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  |  Branch (86:11): [True: 0, False: 0]
  |  Branch (86:28): [True: 0, False: 0]
  ------------------
   87|      0|        return VP8_STATUS_NOT_ENOUGH_DATA;  // Truncated bitstream.
   88|      0|      }
   89|       |      // We have a RIFF container. Skip it.
   90|      0|      *riff_size = size;
   91|      0|      *data_size -= RIFF_HEADER_SIZE;
  ------------------
  |  |   83|      0|#define RIFF_HEADER_SIZE 12  // Size of the RIFF header ("RIFFnnnnWEBP").
  ------------------
   92|      0|      *data += RIFF_HEADER_SIZE;
  ------------------
  |  |   83|      0|#define RIFF_HEADER_SIZE 12  // Size of the RIFF header ("RIFFnnnnWEBP").
  ------------------
   93|      0|    }
   94|      0|  }
   95|    479|  return VP8_STATUS_OK;
   96|    479|}
webp_dec.c:ParseVP8X:
  111|    479|                               uint32_t* WEBP_SINGLE const flags_ptr) {
  112|    479|  const uint32_t vp8x_size = CHUNK_HEADER_SIZE + VP8X_CHUNK_SIZE;
  ------------------
  |  |   82|    479|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
                const uint32_t vp8x_size = CHUNK_HEADER_SIZE + VP8X_CHUNK_SIZE;
  ------------------
  |  |   86|    479|#define VP8X_CHUNK_SIZE 10   // Size of a VP8X chunk.
  ------------------
  113|    479|  assert(data != NULL);
  114|    479|  assert(data_size != NULL);
  115|    479|  assert(found_vp8x != NULL);
  116|       |
  117|    479|  *found_vp8x = 0;
  118|       |
  119|    479|  if (*data_size < CHUNK_HEADER_SIZE) {
  ------------------
  |  |   82|    479|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  |  Branch (119:7): [True: 0, False: 479]
  ------------------
  120|      0|    return VP8_STATUS_NOT_ENOUGH_DATA;  // Insufficient data.
  121|      0|  }
  122|       |
  123|    479|  if (!memcmp(*data, "VP8X", TAG_SIZE)) {
  ------------------
  |  |   80|    479|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  |  Branch (123:7): [True: 0, False: 479]
  ------------------
  124|      0|    int width, height;
  125|      0|    uint32_t flags;
  126|      0|    const uint32_t chunk_size = GetLE32(*data + TAG_SIZE);
  ------------------
  |  |   80|      0|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  127|      0|    if (chunk_size != VP8X_CHUNK_SIZE) {
  ------------------
  |  |   86|      0|#define VP8X_CHUNK_SIZE 10   // Size of a VP8X chunk.
  ------------------
  |  Branch (127:9): [True: 0, False: 0]
  ------------------
  128|      0|      return VP8_STATUS_BITSTREAM_ERROR;  // Wrong chunk size.
  129|      0|    }
  130|       |
  131|       |    // Verify if enough data is available to validate the VP8X chunk.
  132|      0|    if (*data_size < vp8x_size) {
  ------------------
  |  Branch (132:9): [True: 0, False: 0]
  ------------------
  133|      0|      return VP8_STATUS_NOT_ENOUGH_DATA;  // Insufficient data.
  134|      0|    }
  135|      0|    flags = GetLE32(*data + 8);
  136|      0|    width = 1 + GetLE24(*data + 12);
  137|      0|    height = 1 + GetLE24(*data + 15);
  138|      0|    if (width * (uint64_t)height >= MAX_IMAGE_AREA) {
  ------------------
  |  |   89|      0|#define MAX_IMAGE_AREA (1ULL << 32)    // 32-bit max for width x height.
  ------------------
  |  Branch (138:9): [True: 0, False: 0]
  ------------------
  139|      0|      return VP8_STATUS_BITSTREAM_ERROR;  // image is too large
  140|      0|    }
  141|       |
  142|      0|    if (flags_ptr != NULL) *flags_ptr = flags;
  ------------------
  |  Branch (142:9): [True: 0, False: 0]
  ------------------
  143|      0|    if (width_ptr != NULL) *width_ptr = width;
  ------------------
  |  Branch (143:9): [True: 0, False: 0]
  ------------------
  144|      0|    if (height_ptr != NULL) *height_ptr = height;
  ------------------
  |  Branch (144:9): [True: 0, False: 0]
  ------------------
  145|       |    // Skip over VP8X header bytes.
  146|      0|    *data_size -= vp8x_size;
  147|      0|    *data += vp8x_size;
  148|      0|    *found_vp8x = 1;
  149|      0|  }
  150|    479|  return VP8_STATUS_OK;
  151|    479|}
webp_dec.c:ParseVP8Header:
  240|    479|                                    int* WEBP_SINGLE const is_lossless) {
  241|    479|  const size_t local_data_size = *data_size;
  242|    479|  const uint8_t* WEBP_COUNTED_BY(local_data_size) const data = *data_ptr;
  243|    479|  const int is_vp8 = !memcmp(data, "VP8 ", TAG_SIZE);
  ------------------
  |  |   80|    479|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  244|    479|  const int is_vp8l = !memcmp(data, "VP8L", TAG_SIZE);
  ------------------
  |  |   80|    479|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  245|    479|  const uint32_t minimal_size =
  246|    479|      TAG_SIZE + CHUNK_HEADER_SIZE;  // "WEBP" + "VP8 nnnn" OR
  ------------------
  |  |   80|    479|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
                    TAG_SIZE + CHUNK_HEADER_SIZE;  // "WEBP" + "VP8 nnnn" OR
  ------------------
  |  |   82|    479|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  247|       |                                     // "WEBP" + "VP8Lnnnn"
  248|    479|  (void)local_data_size;
  249|    479|  assert(data != NULL);
  250|    479|  assert(data_size != NULL);
  251|    479|  assert(chunk_size != NULL);
  252|    479|  assert(is_lossless != NULL);
  253|    479|  assert(local_data_size >= TAG_SIZE);  // what the two memcmp() above need
  254|       |
  255|    479|  if (*data_size < CHUNK_HEADER_SIZE) {
  ------------------
  |  |   82|    479|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  |  Branch (255:7): [True: 0, False: 479]
  ------------------
  256|      0|    return VP8_STATUS_NOT_ENOUGH_DATA;  // Insufficient data.
  257|      0|  }
  258|       |
  259|    479|  if (is_vp8 || is_vp8l) {
  ------------------
  |  Branch (259:7): [True: 391, False: 88]
  |  Branch (259:17): [True: 88, False: 0]
  ------------------
  260|       |    // Bitstream contains VP8/VP8L header.
  261|    479|    const uint32_t size = GetLE32(data + TAG_SIZE);
  ------------------
  |  |   80|    479|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  262|    479|    if ((riff_size >= minimal_size) && (size > riff_size - minimal_size)) {
  ------------------
  |  Branch (262:9): [True: 0, False: 479]
  |  Branch (262:40): [True: 0, False: 0]
  ------------------
  263|      0|      return VP8_STATUS_BITSTREAM_ERROR;  // Inconsistent size information.
  264|      0|    }
  265|    479|    if (have_all_data && (size > *data_size - CHUNK_HEADER_SIZE)) {
  ------------------
  |  |   82|      0|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  |  Branch (265:9): [True: 0, False: 479]
  |  Branch (265:26): [True: 0, False: 0]
  ------------------
  266|      0|      return VP8_STATUS_NOT_ENOUGH_DATA;  // Truncated bitstream.
  267|      0|    }
  268|       |    // Skip over CHUNK_HEADER_SIZE bytes from VP8/VP8L Header.
  269|    479|    *chunk_size = size;
  270|    479|    *data_size -= CHUNK_HEADER_SIZE;
  ------------------
  |  |   82|    479|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  271|    479|    *data_ptr += CHUNK_HEADER_SIZE;
  ------------------
  |  |   82|    479|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  272|    479|    *is_lossless = is_vp8l;
  273|    479|  } else {
  274|       |    // Raw VP8/VP8L bitstream (no header).
  275|      0|    *is_lossless = VP8LCheckSignature(data, *data_size);
  276|      0|    *chunk_size = *data_size;
  277|      0|  }
  278|       |
  279|    479|  return VP8_STATUS_OK;
  280|    479|}
webp_dec.c:GetFeatures:
  736|    482|                                 WebPBitstreamFeatures* const features) {
  737|    482|  if (features == NULL || data == NULL) {
  ------------------
  |  Branch (737:7): [True: 0, False: 482]
  |  Branch (737:27): [True: 0, False: 482]
  ------------------
  738|      0|    return VP8_STATUS_INVALID_PARAM;
  739|      0|  }
  740|    482|  DefaultFeatures(features);
  741|       |
  742|       |  // Only parse enough of the data to retrieve the features.
  743|    482|  return ParseHeadersInternal(
  744|    482|      data, data_size, &features->width, &features->height,
  745|       |      &features->has_alpha, &features->has_animation, &features->format, NULL);
  746|    482|}
webp_dec.c:DefaultFeatures:
  728|    482|static void DefaultFeatures(WebPBitstreamFeatures* const features) {
  729|    482|  assert(features != NULL);
  730|    482|  WEBP_UNSAFE_MEMSET(features, 0, sizeof(*features));
  ------------------
  |  |  175|    482|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  731|    482|}

VP8LInitBitReader:
  138|     79|                       size_t length) {
  139|     79|  size_t i;
  140|     79|  vp8l_val_t value = 0;
  141|     79|  assert(br != NULL);
  142|     79|  assert(start != NULL);
  143|     79|  assert(length < 0xfffffff8u);  // can't happen with a RIFF chunk.
  144|       |
  145|     79|  br->buf = start;
  146|     79|  br->len = length;
  147|     79|  br->bit_pos = 0;
  148|     79|  br->eos = 0;
  149|       |
  150|     79|  if (length > sizeof(br->val)) {
  ------------------
  |  Branch (150:7): [True: 55, False: 24]
  ------------------
  151|     55|    length = sizeof(br->val);
  152|     55|  }
  153|    667|  for (i = 0; i < length; ++i) {
  ------------------
  |  Branch (153:15): [True: 588, False: 79]
  ------------------
  154|    588|    value |= (vp8l_val_t)start[i] << (8 * i);
  155|    588|  }
  156|     79|  br->val = value;
  157|     79|  br->pos = length;
  158|     79|}
VP8LReadBits:
  205|    395|uint32_t VP8LReadBits(VP8LBitReader* const br, int n_bits) {
  206|    395|  assert(n_bits >= 0);
  207|       |  // Flag an error if end_of_stream or n_bits is more than allowed limit.
  208|    395|  if (!br->eos && n_bits <= VP8L_MAX_NUM_BIT_READ) {
  ------------------
  |  |  144|    395|#define VP8L_MAX_NUM_BIT_READ 24
  ------------------
  |  Branch (208:7): [True: 395, False: 0]
  |  Branch (208:19): [True: 395, False: 0]
  ------------------
  209|    395|    const uint32_t val = VP8LPrefetchBits(br) & kBitMask[n_bits];
  210|    395|    const int new_bits = br->bit_pos + n_bits;
  211|    395|    br->bit_pos = new_bits;
  212|    395|    ShiftBytes(br);
  213|    395|    return val;
  214|    395|  } else {
  215|      0|    VP8LSetEndOfStream(br);
  216|      0|    return 0;
  217|      0|  }
  218|    395|}
bit_reader_utils.c:ShiftBytes:
  178|    395|static void ShiftBytes(VP8LBitReader* const br) {
  179|    659|  while (br->bit_pos >= 8 && br->pos < br->len) {
  ------------------
  |  Branch (179:10): [True: 395, False: 264]
  |  Branch (179:30): [True: 264, False: 131]
  ------------------
  180|    264|    br->val >>= 8;
  181|    264|    br->val |= ((vp8l_val_t)br->buf[br->pos]) << (VP8L_LBITS - 8);
  ------------------
  |  |  146|    264|#define VP8L_LBITS 64  // Number of bits prefetched (= bit-size of vp8l_val_t).
  ------------------
  182|    264|    ++br->pos;
  183|    264|    br->bit_pos -= 8;
  184|    264|  }
  185|    395|  if (VP8LIsEndOfStream(br)) {
  ------------------
  |  Branch (185:7): [True: 0, False: 395]
  ------------------
  186|      0|    VP8LSetEndOfStream(br);
  187|      0|  }
  188|    395|}

bit_reader_utils.c:VP8LIsEndOfStream:
  182|    395|static WEBP_INLINE int VP8LIsEndOfStream(const VP8LBitReader* const br) {
  183|    395|  assert(br->pos <= br->len);
  184|    395|  return br->eos || ((br->pos == br->len) && (br->bit_pos > VP8L_LBITS));
  ------------------
  |  |  146|    138|#define VP8L_LBITS 64  // Number of bits prefetched (= bit-size of vp8l_val_t).
  ------------------
  |  Branch (184:10): [True: 0, False: 395]
  |  Branch (184:22): [True: 138, False: 257]
  |  Branch (184:46): [True: 0, False: 138]
  ------------------
  185|    395|}
bit_reader_utils.c:VP8LPrefetchBits:
  176|    395|static WEBP_INLINE uint32_t VP8LPrefetchBits(VP8LBitReader* const br) {
  177|    395|  return (uint32_t)(br->val >> (br->bit_pos & (VP8L_LBITS - 1)));
  ------------------
  |  |  146|    395|#define VP8L_LBITS 64  // Number of bits prefetched (= bit-size of vp8l_val_t).
  ------------------
  178|    395|}

webp_dec.c:GetLE32:
  116|    479|                                        data) {
  117|    479|  return GetLE16(data) | ((uint32_t)GetLE16(data + 2) << 16);
  118|    479|}
webp_dec.c:GetLE16:
  107|    958|static WEBP_INLINE int GetLE16(const uint8_t* const WEBP_COUNTED_BY(2) data) {
  108|    958|  return (int)(data[0] << 0) | (data[1] << 8);
  109|    958|}

webp_info_fuzzer.cc:_ZL15WebPGetFeaturesPKhmP21WebPBitstreamFeatures:
  476|    482|                size_t data_size, WebPBitstreamFeatures* features) {
  477|    482|  return WebPGetFeaturesInternal(data, data_size, features,
  478|    482|                                 WEBP_DECODER_ABI_VERSION);
  ------------------
  |  |   27|    482|#define WEBP_DECODER_ABI_VERSION 0x0210  // MAJOR(8b) + MINOR(8b)
  ------------------
  479|    482|}

nalloc_init:
  109|  1.13k|void nalloc_init(const char* prog) {
  110|  1.13k|  if (nalloc_initialized) {
  ------------------
  |  Branch (110:7): [True: 1.13k, False: 1]
  ------------------
  111|  1.13k|    return;
  112|  1.13k|  }
  113|      1|  nalloc_initialized = true;
  114|      1|  char* bitmask = getenv("NALLOC_FREQ");
  115|      1|  if (bitmask) {
  ------------------
  |  Branch (115:7): [True: 0, False: 1]
  ------------------
  116|      0|    int shift = atoi(bitmask);
  117|      0|    if (shift > 0 && shift < 31) {
  ------------------
  |  Branch (117:9): [True: 0, False: 0]
  |  Branch (117:22): [True: 0, False: 0]
  ------------------
  118|      0|      nalloc_bitmask = 1 << shift;
  119|      0|      nalloc_random_bitmask = false;
  120|      0|    } else if (shift == 0) {
  ------------------
  |  Branch (120:16): [True: 0, False: 0]
  ------------------
  121|      0|      nalloc_random_bitmask = false;
  122|      0|      nalloc_bitmask = 0;
  123|      0|    }
  124|      1|  } else if (prog == NULL || strstr(prog, "nalloc") == NULL) {
  ------------------
  |  Branch (124:14): [True: 1, False: 0]
  |  Branch (124:30): [True: 0, False: 0]
  ------------------
  125|      1|    nalloc_random_bitmask = false;
  126|      1|    nalloc_bitmask = 0;
  127|      1|    return;
  128|      1|  }
  129|       |
  130|      0|  char* magic = getenv("NALLOC_MAGIC");
  131|      0|  if (magic) {
  ------------------
  |  Branch (131:7): [True: 0, False: 0]
  ------------------
  132|      0|    nalloc_magic = (uint32_t)strtol(magic, NULL, 0);
  133|      0|  }
  134|       |
  135|      0|  char* verbose = getenv("NALLOC_VERBOSE");
  136|      0|  if (verbose) {
  ------------------
  |  Branch (136:7): [True: 0, False: 0]
  ------------------
  137|      0|    nalloc_verbose = true;
  138|      0|  }
  139|      0|}
calloc:
  295|      4|void* calloc(size_t nmemb, size_t size) {
  296|      4|  if (nalloc_fail(size, "calloc")) {
  ------------------
  |  Branch (296:7): [True: 0, False: 4]
  ------------------
  297|      0|    errno = ENOMEM;
  298|      0|    return NULL;
  299|      0|  }
  300|      4|  return nalloc_calloc(nmemb, size);
  ------------------
  |  |  252|      4|#define nalloc_calloc(s, n) __libc_calloc(s, n)
  ------------------
  301|      4|}
malloc:
  303|   127k|void* malloc(size_t size) {
  304|   127k|  if (nalloc_fail(size, "malloc")) {
  ------------------
  |  Branch (304:7): [True: 0, False: 127k]
  ------------------
  305|      0|    errno = ENOMEM;
  306|      0|    return NULL;
  307|      0|  }
  308|   127k|  return nalloc_malloc(size);
  ------------------
  |  |  251|   127k|#define nalloc_malloc(s) __libc_malloc(s)
  ------------------
  309|   127k|}
realloc:
  311|      1|void* realloc(void* ptr, size_t size) {
  312|      1|  if (nalloc_fail(size, "realloc")) {
  ------------------
  |  Branch (312:7): [True: 0, False: 1]
  ------------------
  313|      0|    errno = ENOMEM;
  314|      0|    return NULL;
  315|      0|  }
  316|      1|  return nalloc_realloc(ptr, size);
  ------------------
  |  |  253|      1|#define nalloc_realloc(p, s) __libc_realloc(p, s)
  ------------------
  317|      1|}
webp_info_fuzzer.cc:_ZL11nalloc_failmPKc:
  187|   127k|static bool nalloc_fail(size_t size, const char* op) {
  188|       |  // do not fail before thread init
  189|   127k|  if (nalloc_runs == 0) {
  ------------------
  |  Branch (189:7): [True: 127k, False: 0]
  ------------------
  190|   127k|    return false;
  191|   127k|  }
  192|      0|  if (__sync_fetch_and_add(&nalloc_running, 1) != 1) {
  ------------------
  |  Branch (192:7): [True: 0, False: 0]
  ------------------
  193|       |    // do not fail allocations outside of fuzzer input
  194|       |    // and do not fail inside of this function
  195|      0|    __sync_fetch_and_sub(&nalloc_running, 1);
  196|      0|    return false;
  197|      0|  }
  198|      0|  nalloc_random_update((uint8_t)size);
  199|      0|  if (size >= 0x100) {
  ------------------
  |  Branch (199:7): [True: 0, False: 0]
  ------------------
  200|      0|    nalloc_random_update((uint8_t)(size >> 8));
  201|      0|    if (size >= 0x10000) {
  ------------------
  |  Branch (201:9): [True: 0, False: 0]
  ------------------
  202|      0|      nalloc_random_update((uint8_t)(size >> 16));
  203|       |      // bigger may already fail or oom
  204|      0|    }
  205|      0|  }
  206|      0|  if (((nalloc_random_state ^ nalloc_magic) & nalloc_bitmask) == 0) {
  ------------------
  |  Branch (206:7): [True: 0, False: 0]
  ------------------
  207|      0|    if (nalloc_backtrace_exclude(size, op)) {
  ------------------
  |  Branch (207:9): [True: 0, False: 0]
  ------------------
  208|      0|      __sync_fetch_and_sub(&nalloc_running, 1);
  209|      0|      return false;
  210|      0|    }
  211|      0|    __sync_fetch_and_sub(&nalloc_running, 1);
  212|      0|    return true;
  213|      0|  }
  214|      0|  __sync_fetch_and_sub(&nalloc_running, 1);
  215|      0|  return false;
  216|      0|}
webp_info_fuzzer.cc:_ZL12nalloc_startPKhm:
  149|  1.13k|static int nalloc_start(const uint8_t* data, size_t size) {
  150|  1.13k|  if (nalloc_random_bitmask) {
  ------------------
  |  Branch (150:7): [True: 0, False: 1.13k]
  ------------------
  151|      0|    if (nalloc_random_state & 0x10) {
  ------------------
  |  Branch (151:9): [True: 0, False: 0]
  ------------------
  152|      0|      nalloc_bitmask = 0xFFFFFFFF;
  153|      0|    } else {
  154|      0|      nalloc_bitmask = 1 << (5 + (nalloc_random_state & 0xF));
  155|      0|    }
  156|  1.13k|  } else if (nalloc_bitmask == 0) {
  ------------------
  |  Branch (156:14): [True: 1.13k, False: 0]
  ------------------
  157|       |    // nalloc disabled
  158|  1.13k|    return 0;
  159|  1.13k|  }
  160|      0|  nalloc_random_state = 0;
  161|      0|  for (size_t i = 0; i < size; i++) {
  ------------------
  |  Branch (161:22): [True: 0, False: 0]
  ------------------
  162|      0|    nalloc_random_update(data[i]);
  163|      0|  }
  164|      0|  if (__sync_fetch_and_add(&nalloc_running, 1)) {
  ------------------
  |  Branch (164:7): [True: 0, False: 0]
  ------------------
  165|      0|    __sync_fetch_and_sub(&nalloc_running, 1);
  166|      0|    return 0;
  167|      0|  }
  168|      0|  nalloc_runs++;
  169|      0|  return 1;
  170|      0|}
webp_info_fuzzer.cc:_ZL10nalloc_endv:
  173|  1.13k|static void nalloc_end() { __sync_fetch_and_sub(&nalloc_running, 1); }

_Z12WebPInfoTestNSt3__117basic_string_viewIcNS_11char_traitsIcEEEE:
   29|  1.13k|void WebPInfoTest(std::string_view data) {
   30|  1.13k|  nalloc_init(nullptr);
   31|  1.13k|  nalloc_start(reinterpret_cast<const uint8_t*>(data.data()), data.size());
   32|  1.13k|  WebPInfo webp_info;
   33|  1.13k|  WebPInfoInit(&webp_info);
   34|  1.13k|  webp_info.quiet = 1;
   35|  1.13k|  webp_info.show_summary = 0;
   36|  1.13k|  webp_info.show_diagnosis = 0;
   37|  1.13k|  webp_info.parse_bitstream = 1;
   38|  1.13k|  WebPData webp_data = {reinterpret_cast<const uint8_t*>(data.data()),
   39|  1.13k|                        data.size()};
   40|  1.13k|  AnalyzeWebP(&webp_info, &webp_data);
   41|  1.13k|  nalloc_end();
   42|  1.13k|}