_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|  20.2k|inline constexpr Dest bit_cast(const Source& source) {
  191|  20.2k|  return __builtin_bit_cast(Dest, source);
  192|  20.2k|}
_ZN4absl12lts_202605268bit_castIlmTnNSt3__19enable_ifIXaaaaeqstT_stT0_sr3std21is_trivially_copyableIS5_EE5valuesr3std21is_trivially_copyableIS4_EE5valueEiE4typeELi0EEES4_RKS5_:
  190|  10.1k|inline constexpr Dest bit_cast(const Source& source) {
  191|  10.1k|  return __builtin_bit_cast(Dest, source);
  192|  10.1k|}
_ZN4absl12lts_202605268bit_castIdmTnNSt3__19enable_ifIXaaaaeqstT_stT0_sr3std21is_trivially_copyableIS5_EE5valuesr3std21is_trivially_copyableIS4_EE5valueEiE4typeELi0EEES4_RKS5_:
  190|  17.5k|inline constexpr Dest bit_cast(const Source& source) {
  191|  17.5k|  return __builtin_bit_cast(Dest, source);
  192|  17.5k|}
_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.30k|  ~InlinedVector() {}
_ZN4absl12lts_2026052613InlinedVectorINS0_14SourceLocationELm1ENSt3__19allocatorIS2_EEEC2Ev:
  128|  3.30k|  InlinedVector() noexcept(noexcept(allocator_type())) : storage_() {}
_ZN4absl12lts_2026052613InlinedVectorINS0_14SourceLocationELm1ENSt3__19allocatorIS2_EEE9push_backERKS2_:
  753|  3.30k|  void push_back(const_reference v) { static_cast<void>(emplace_back(v)); }
_ZN4absl12lts_2026052613InlinedVectorINS0_14SourceLocationELm1ENSt3__19allocatorIS2_EEE12emplace_backIJRKS2_EEERS2_DpOT_:
  746|  3.30k|  reference emplace_back(Args&&... args) ABSL_ATTRIBUTE_LIFETIME_BOUND {
  747|  3.30k|    return storage_.EmplaceBack(std::forward<Args>(args)...);
  748|  3.30k|  }

_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|  6.60k|  constexpr T& get() & { return value; }
_ZNR4absl12lts_2026052618container_internal15CompressedTupleIJNSt3__19allocatorINS0_14SourceLocationEEEmEE3getILi1EEERNS1_25internal_compressed_tuple4ElemIS7_XT_EE4typeEv:
  244|  6.60k|  constexpr ElemT<I>& get() & {
  245|  6.60k|    return StorageT<I>::get();
  246|  6.60k|  }
_ZNKR4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageImLm1ENS2_10StorageTagIJNSt3__19allocatorINS0_14SourceLocationEEEmEEELb0EE3getEv:
   91|  9.90k|  constexpr const T& get() const& { return value; }
_ZNKR4absl12lts_2026052618container_internal15CompressedTupleIJNSt3__19allocatorINS0_14SourceLocationEEEmEE3getILi1EEERKNS1_25internal_compressed_tuple4ElemIS7_XT_EE4typeEv:
  249|  9.90k|  constexpr const ElemT<I>& get() const& {
  250|  9.90k|    return StorageT<I>::get();
  251|  9.90k|  }
_ZNR4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINSt3__19allocatorINS0_14SourceLocationEEELm0ENS2_10StorageTagIJS7_mEEELb1EE3getEv:
  105|  3.30k|  constexpr T& get() & { return *this; }
_ZNR4absl12lts_2026052618container_internal15CompressedTupleIJNSt3__19allocatorINS0_14SourceLocationEEEmEE3getILi0EEERNS1_25internal_compressed_tuple4ElemIS7_XT_EE4typeEv:
  244|  3.30k|  constexpr ElemT<I>& get() & {
  245|  3.30k|    return StorageT<I>::get();
  246|  3.30k|  }
_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.30k|      : CompressedTuple::CompressedTupleImpl(std::in_place,
  240|  3.30k|                                             std::forward<First>(first),
  241|  3.30k|                                             std::forward<Vs>(base)...) {}
_ZN4absl12lts_2026052618container_internal25internal_compressed_tuple19CompressedTupleImplINS1_15CompressedTupleIJNSt3__19allocatorINS0_14SourceLocationEEEmEEENS5_16integer_sequenceImJLm0ELm1EEEELb1EEC2IJS8_jEEENS5_10in_place_tEDpOT_:
  126|  6.60k|      : Storage<Ts, I, StorageTag<Ts...>>(std::in_place,
  127|  6.60k|                                          std::forward<Vs>(args))... {}
_ZN4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINSt3__19allocatorINS0_14SourceLocationEEELm0ENS2_10StorageTagIJS7_mEEELb1EEC2IS7_EENS4_10in_place_tEOT_:
  102|  3.30k|  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.30k|      : 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|  6.60k|  SizeType<A>& GetSizeAndIsAllocated() { return metadata_.template get<1>(); }
_ZN4absl12lts_2026052623inlined_vector_internal7StorageINS0_14SourceLocationELm1ENSt3__19allocatorIS3_EEE21DeallocateIfAllocatedEv:
  521|  3.30k|  void DeallocateIfAllocated() {
  522|  3.30k|    if (GetIsAllocated()) {
  ------------------
  |  Branch (522:9): [True: 0, False: 3.30k]
  ------------------
  523|      0|      MallocAdapter<A>::Deallocate(GetAllocator(), GetAllocatedData(),
  524|      0|                                   GetAllocatedCapacity());
  525|      0|    }
  526|  3.30k|  }
_ZNK4absl12lts_2026052623inlined_vector_internal7StorageINS0_14SourceLocationELm1ENSt3__19allocatorIS3_EEE14GetIsAllocatedEv:
  373|  6.60k|  bool GetIsAllocated() const { return GetSizeAndIsAllocated() & 1; }
_ZNK4absl12lts_2026052623inlined_vector_internal7StorageINS0_14SourceLocationELm1ENSt3__19allocatorIS3_EEE21GetSizeAndIsAllocatedEv:
  367|  9.90k|  const SizeType<A>& GetSizeAndIsAllocated() const {
  368|  9.90k|    return metadata_.template get<1>();
  369|  9.90k|  }
_ZN4absl12lts_2026052623inlined_vector_internal7StorageINS0_14SourceLocationELm1ENSt3__19allocatorIS3_EEE12GetAllocatorEv:
  420|  3.30k|  A& GetAllocator() { return metadata_.template get<0>(); }
_ZN4absl12lts_2026052623inlined_vector_internal7StorageINS0_14SourceLocationELm1ENSt3__19allocatorIS3_EEE14GetInlinedDataEv:
  397|  3.30k|  ABSL_ATTRIBUTE_NO_SANITIZE_CFI Pointer<A> GetInlinedData() {
  398|  3.30k|    return reinterpret_cast<Pointer<A>>(data_.inlined.inlined_data);
  399|  3.30k|  }
_ZNK4absl12lts_2026052623inlined_vector_internal7StorageINS0_14SourceLocationELm1ENSt3__19allocatorIS3_EEE7GetSizeEv:
  371|  3.30k|  SizeType<A> GetSize() const { return GetSizeAndIsAllocated() >> 1; }
_ZN4absl12lts_2026052623inlined_vector_internal7StorageINS0_14SourceLocationELm1ENSt3__19allocatorIS3_EEED2Ev:
  343|  3.30k|  ~Storage() {
  344|       |    // Fast path: if we are empty and not allocated, there's nothing to do.
  345|  3.30k|    if (GetSizeAndIsAllocated() == 0) {
  ------------------
  |  Branch (345:9): [True: 0, False: 3.30k]
  ------------------
  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.30k|    if (std::is_trivially_destructible<ValueType<A>>::value &&
  ------------------
  |  Branch (352:9): [True: 0, Folded]
  ------------------
  353|  3.30k|        std::is_same<A, std::allocator<ValueType<A>>>::value) {
  ------------------
  |  Branch (353:9): [True: 0, Folded]
  ------------------
  354|  3.30k|      DeallocateIfAllocated();
  355|  3.30k|      return;
  356|  3.30k|    }
  357|       |
  358|      0|    DestroyContents();
  359|      0|  }
_ZN4absl12lts_2026052623inlined_vector_internal7StorageINS0_14SourceLocationELm1ENSt3__19allocatorIS3_EEEC2Ev:
  338|  3.30k|  Storage() : metadata_(A(), /* size and is_allocated */ 0u) {}
_ZN4absl12lts_2026052623inlined_vector_internal7StorageINS0_14SourceLocationELm1ENSt3__19allocatorIS3_EEE11EmplaceBackIJRKS3_EEERS3_DpOT_:
  817|  3.30k|auto Storage<T, N, A>::EmplaceBack(Args&&... args) -> Reference<A> {
  818|  3.30k|  StorageView<A> storage_view = MakeStorageView();
  819|  3.30k|  const SizeType<A> n = storage_view.size;
  820|  3.30k|  if (ABSL_PREDICT_TRUE(n != storage_view.capacity)) {
  ------------------
  |  |  191|  3.30k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 3.30k, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 3.30k]
  |  |  |  Branch (191:57): [True: 3.30k, False: 0]
  |  |  ------------------
  ------------------
  821|       |    // Fast path; new element fits.
  822|  3.30k|    Pointer<A> last_ptr = storage_view.data + n;
  823|  3.30k|    AllocatorTraits<A>::construct(GetAllocator(), last_ptr,
  824|  3.30k|                                  std::forward<Args>(args)...);
  825|  3.30k|    AddSize(1);
  826|  3.30k|    return *last_ptr;
  827|  3.30k|  }
  828|       |  // TODO(b/173712035): Annotate with musttail attribute to prevent regression.
  829|      0|  return EmplaceBackSlow(std::forward<Args>(args)...);
  830|  3.30k|}
_ZN4absl12lts_2026052623inlined_vector_internal7StorageINS0_14SourceLocationELm1ENSt3__19allocatorIS3_EEE15MakeStorageViewEv:
  413|  3.30k|  StorageView<A> MakeStorageView() {
  414|  3.30k|    return GetIsAllocated() ? StorageView<A>{GetAllocatedData(), GetSize(),
  ------------------
  |  Branch (414:12): [True: 0, False: 3.30k]
  ------------------
  415|      0|                                             GetAllocatedCapacity()}
  416|  3.30k|                            : StorageView<A>{GetInlinedData(), GetSize(),
  417|  3.30k|                                             GetInlinedCapacity()};
  418|  3.30k|  }
_ZNK4absl12lts_2026052623inlined_vector_internal7StorageINS0_14SourceLocationELm1ENSt3__19allocatorIS3_EEE18GetInlinedCapacityEv:
  409|  3.30k|  SizeType<A> GetInlinedCapacity() const {
  410|  3.30k|    return static_cast<SizeType<A>>(kOptimalInlinedSize);
  411|  3.30k|  }
_ZN4absl12lts_2026052623inlined_vector_internal7StorageINS0_14SourceLocationELm1ENSt3__19allocatorIS3_EEE7AddSizeEm:
  475|  3.30k|  void AddSize(SizeType<A> count) {
  476|  3.30k|    GetSizeAndIsAllocated() += count << static_cast<SizeType<A>>(1);
  477|  3.30k|  }

_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|  5.05k|      : Impl(internal_any_invocable::ConversionConstruct(),
  198|  5.05k|             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|  5.05k|                                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|  5.05k|  *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|  5.05k|}
_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|  5.05k|  ~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|  5.05k|        : Core(TypedConversionConstruct<                                       \
  720|  5.05k|                   typename std::decay<F>::type inv_quals>(),                  \
  721|  5.05k|               std::forward<F>(f)) {}                                          \
runtime.cc:_ZN4absl12lts_2026052622internal_any_invocable8CoreImplILb0EvJEEC2IOZN8fuzztest8internal18FuzzTestFuzzerImpl11RunOneInputERKNS7_5InputEE3$_0SB_EENS1_24TypedConversionConstructIT_EEOT0_:
  417|  5.05k|  explicit CoreImpl(TypedConversionConstruct<QualDecayedTRef>, F&& f) {
  418|  5.05k|    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|  5.05k|    } else {
  459|  5.05k|      InitializeStorage<QualDecayedTRef>(std::forward<F>(f));
  460|  5.05k|    }
  461|  5.05k|  }
runtime.cc:_ZN4absl12lts_2026052622internal_any_invocable8CoreImplILb0EvJEE17InitializeStorageIOZN8fuzztest8internal18FuzzTestFuzzerImpl11RunOneInputERKNS7_5InputEE3$_0JSB_EEEvDpOT0_:
  513|  5.05k|  void InitializeStorage(Args&&... args) {
  514|  5.05k|    using RawT = RemoveCVRef<QualTRef>;
  515|  5.05k|    if constexpr (IsStoredLocally<RawT>()) {
  516|  5.05k|      ::new (static_cast<void*>(&state_.storage))
  517|  5.05k|          RawT(std::forward<Args>(args)...);
  518|  5.05k|      invoker_ = LocalInvoker<SigIsNoexcept, ReturnType, QualTRef, P...>;
  519|       |      // We can simplify our manager if we know the type is trivially copyable.
  520|  5.05k|      if constexpr (std::is_trivially_copyable_v<RawT>) {
  521|  5.05k|        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|  5.05k|  }
runtime.cc:_ZN4absl12lts_2026052622internal_any_invocable12LocalInvokerILb0EvOZN8fuzztest8internal18FuzzTestFuzzerImpl11RunOneInputERKNS5_5InputEE3$_0JEEET0_PNS1_15TypeErasedStateEDpNS1_18ForwardedParameterIT2_E4typeE:
  271|  5.05k|    ForwardedParameterType<P>... args) noexcept(SigIsNoexcept) {
  272|  5.05k|  using RawT = RemoveCVRef<QualTRef>;
  273|  5.05k|  static_assert(
  274|  5.05k|      IsStoredLocally<RawT>(),
  275|  5.05k|      "Target object must be in local storage in order to be invoked from it.");
  276|       |
  277|  5.05k|  auto& f = (ObjectInLocalStorage<RawT>)(state);
  278|  5.05k|  return (InvokeR<ReturnType>)(static_cast<QualTRef>(f),
  279|  5.05k|                               static_cast<ForwardedParameterType<P>>(args)...);
  280|  5.05k|}
runtime.cc:_ZN4absl12lts_2026052622internal_any_invocable20ObjectInLocalStorageIZN8fuzztest8internal18FuzzTestFuzzerImpl11RunOneInputERKNS5_5InputEE3$_0EERT_PNS1_15TypeErasedStateE:
  191|  5.05k|T& ObjectInLocalStorage(TypeErasedState* const state) {
  192|       |  // We launder here because the storage may be reused with the same type.
  193|  5.05k|  return *std::launder(reinterpret_cast<T*>(&state->storage));
  194|  5.05k|}
runtime.cc:_ZN4absl12lts_2026052622internal_any_invocable7InvokeRIvZN8fuzztest8internal18FuzzTestFuzzerImpl11RunOneInputERKNS5_5InputEE3$_0JEEET_OT0_DpOT1_:
  119|  5.05k|ReturnType InvokeR(F&& f, P&&... args) {
  120|  5.05k|  if constexpr (std::is_void_v<ReturnType>) {
  121|  5.05k|    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|  5.05k|}
_ZN4absl12lts_2026052622internal_any_invocable4ImplIFvvOEE14ExtractInvokerEv:
  736|  5.06k|    InvokerType<noex, ReturnType, P...>* ExtractInvoker() cv {                 \
  737|  5.06k|      using QualifiedTestType = int cv ref;                                    \
  738|  5.06k|      auto* invoker = this->invoker_;                                          \
  739|  5.06k|      if (!std::is_const<QualifiedTestType>::value &&                          \
  ------------------
  |  Branch (739:11): [True: 0, Folded]
  ------------------
  740|  5.06k|          std::is_rvalue_reference<QualifiedTestType>::value) {                \
  ------------------
  |  Branch (740:11): [True: 0, Folded]
  ------------------
  741|  5.06k|        ABSL_ASSERT([this]() {                                                 \
  ------------------
  |  |  127|  5.06k|#define ABSL_ASSERT(expr) ABSL_INTERNAL_UNEVALUATED((expr) ? void() : void())
  |  |  ------------------
  |  |  |  |   87|  5.06k|#define ABSL_INTERNAL_UNEVALUATED(expr) (false ? (void)(expr) : void())
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (87:42): [Folded, False: 5.06k]
  |  |  |  |  |  Branch (87:57): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  742|  5.06k|          /* We checked that this isn't const above, so const_cast is safe */  \
  743|  5.06k|          const_cast<Impl*>(this)->invoker_ = InvokedAfterMove;                \
  744|  5.06k|          return this->HasValue();                                             \
  745|  5.06k|        }());                                                                  \
  746|  5.06k|      }                                                                        \
  747|  5.06k|      return invoker;                                                          \
  748|  5.06k|    }                                                                          \

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|  23.7k|    countl_zero(T x) noexcept {
  109|  23.7k|  return numeric_internal::CountLeadingZeroes(x);
  110|  23.7k|}
_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.77k|    bit_width(T x) noexcept {
  166|  4.77k|  return std::numeric_limits<T>::digits - countl_zero(x);
  167|  4.77k|}

_ZN4absl12lts_20260526mlENS0_7uint128ES1_:
 1059|  21.5k|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|  21.5k|  return static_cast<unsigned __int128>(lhs) *
 1063|  21.5k|         static_cast<unsigned __int128>(rhs);
 1064|  21.5k|}
_ZNK4absl12lts_202605267uint128cvoEv:
  794|   268k|constexpr uint128::operator unsigned __int128() const {
  795|   268k|  return (static_cast<unsigned __int128>(hi_) << 64) + lo_;
  796|   268k|}
_ZN4absl12lts_202605267uint128C2Eo:
  692|   122k|    : lo_{static_cast<uint64_t>(v & ~uint64_t{0})},
  693|   122k|      hi_{static_cast<uint64_t>(v >> 64)} {}
_ZN4absl12lts_202605267uint128C2Em:
  683|  48.6k|constexpr uint128::uint128(unsigned long v) : lo_{v}, hi_{0} {}
_ZNK4absl12lts_202605267uint128cvmEv:
  777|  16.0k|constexpr uint128::operator unsigned long() const {  // NOLINT(runtime/int)
  778|  16.0k|  return static_cast<unsigned long>(lo_);            // NOLINT(runtime/int)
  779|  16.0k|}
_ZN4absl12lts_20260526rsENS0_7uint128Ei:
  974|  26.1k|constexpr uint128 operator>>(uint128 lhs, int amount) {
  975|  26.1k|#ifdef ABSL_HAVE_INTRINSIC_INT128
  976|  26.1k|  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|  26.1k|}
_ZN4absl12lts_202605267uint128mLES1_:
  646|  12.4k|inline uint128& uint128::operator*=(uint128 other) {
  647|  12.4k|  *this = *this * other;
  648|  12.4k|  return *this;
  649|  12.4k|}
_ZN4absl12lts_2026052613Uint128High64ENS0_7uint128E:
  663|  52.3k|constexpr uint64_t Uint128High64(uint128 v) { return v.hi_; }
_ZN4absl12lts_2026052612Uint128Low64ENS0_7uint128E:
  661|  11.8k|constexpr uint64_t Uint128Low64(uint128 v) { return v.lo_; }
_ZN4absl12lts_202605267uint128rSEi:
  631|  26.1k|inline uint128& uint128::operator>>=(int amount) {
  632|  26.1k|  *this = *this >> amount;
  633|  26.1k|  return *this;
  634|  26.1k|}
_ZN4absl12lts_202605267uint128pLES1_:
  636|  2.24k|inline uint128& uint128::operator+=(uint128 other) {
  637|  2.24k|  *this = *this + other;
  638|  2.24k|  return *this;
  639|  2.24k|}
_ZN4absl12lts_20260526eqENS0_7uint128ES1_:
  820|  25.1k|constexpr bool operator==(uint128 lhs, uint128 rhs) {
  821|  25.1k|#if defined(ABSL_HAVE_INTRINSIC_INT128)
  822|  25.1k|  return static_cast<unsigned __int128>(lhs) ==
  823|  25.1k|         static_cast<unsigned __int128>(rhs);
  824|       |#else
  825|       |  return (Uint128Low64(lhs) == Uint128Low64(rhs) &&
  826|       |          Uint128High64(lhs) == Uint128High64(rhs));
  827|       |#endif
  828|  25.1k|}
_ZN4absl12lts_20260526ltENS0_7uint128ES1_:
  832|  14.3k|constexpr bool operator<(uint128 lhs, uint128 rhs) {
  833|  14.3k|#ifdef ABSL_HAVE_INTRINSIC_INT128
  834|  14.3k|  return static_cast<unsigned __int128>(lhs) <
  835|  14.3k|         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|  14.3k|}
_ZN4absl12lts_20260526gtENS0_7uint128ES1_:
  843|  14.3k|constexpr bool operator>(uint128 lhs, uint128 rhs) { return rhs < lhs; }
_ZN4absl12lts_20260526anENS0_7uint128ES1_:
  923|  15.8k|constexpr inline uint128 operator&(uint128 lhs, uint128 rhs) {
  924|  15.8k|#if defined(ABSL_HAVE_INTRINSIC_INT128)
  925|  15.8k|  return static_cast<unsigned __int128>(lhs) &
  926|  15.8k|         static_cast<unsigned __int128>(rhs);
  927|       |#else
  928|       |  return MakeUint128(Uint128High64(lhs) & Uint128High64(rhs),
  929|       |                     Uint128Low64(lhs) & Uint128Low64(rhs));
  930|       |#endif
  931|  15.8k|}
_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|  30.4k|constexpr uint128 operator<<(uint128 lhs, int amount) {
  961|  30.4k|#ifdef ABSL_HAVE_INTRINSIC_INT128
  962|  30.4k|  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|  30.4k|}
_ZN4absl12lts_20260526plENS0_7uint128ES1_:
  999|  3.66k|constexpr uint128 operator+(uint128 lhs, uint128 rhs) {
 1000|  3.66k|#if defined(ABSL_HAVE_INTRINSIC_INT128)
 1001|  3.66k|  return static_cast<unsigned __int128>(lhs) +
 1002|  3.66k|         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.66k|}
_ZN4absl12lts_20260526miENS0_7uint128ES1_:
 1022|  25.1k|constexpr uint128 operator-(uint128 lhs, uint128 rhs) {
 1023|  25.1k|#if defined(ABSL_HAVE_INTRINSIC_INT128)
 1024|  25.1k|  return static_cast<unsigned __int128>(lhs) -
 1025|  25.1k|         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|  25.1k|}
_ZN4absl12lts_202605267uint128ppEv:
 1091|    650|inline uint128& uint128::operator++() {
 1092|    650|  *this += 1;
 1093|    650|  return *this;
 1094|    650|}
_ZN4absl12lts_202605267uint128C2Ei:
  672|  58.9k|    : lo_{static_cast<uint64_t>(v)},
  673|  58.9k|      hi_{v < 0 ? (std::numeric_limits<uint64_t>::max)() : 0} {}
  ------------------
  |  Branch (673:11): [True: 0, False: 58.9k]
  ------------------

_ZN4absl12lts_2026052616numeric_internal18CountLeadingZeroesImEEiT_:
  268|  23.7k|CountLeadingZeroes(T x) {
  269|  23.7k|  static_assert(std::is_unsigned<T>::value, "T must be unsigned");
  270|  23.7k|  static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
  271|  23.7k|                "T must have a power-of-2 size");
  272|  23.7k|  static_assert(sizeof(T) <= sizeof(uint64_t), "T too large");
  273|  23.7k|  return sizeof(T) <= sizeof(uint16_t)
  ------------------
  |  Branch (273:10): [Folded, False: 23.7k]
  ------------------
  274|  23.7k|             ? CountLeadingZeroes16(static_cast<uint16_t>(x)) -
  275|      0|                   (std::numeric_limits<uint16_t>::digits -
  276|      0|                    std::numeric_limits<T>::digits)
  277|  23.7k|             : (sizeof(T) <= sizeof(uint32_t)
  ------------------
  |  Branch (277:17): [Folded, False: 23.7k]
  ------------------
  278|  23.7k|                    ? CountLeadingZeroes32(static_cast<uint32_t>(x)) -
  279|      0|                          (std::numeric_limits<uint32_t>::digits -
  280|      0|                           std::numeric_limits<T>::digits)
  281|  23.7k|                    : CountLeadingZeroes64(x));
  282|  23.7k|}
_ZN4absl12lts_2026052616numeric_internal20CountLeadingZeroes64Em:
  214|  23.7k|CountLeadingZeroes64(uint64_t x) {
  215|  23.7k|#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|  23.7k|  static_assert(sizeof(unsigned long long) == sizeof(x),  // NOLINT(runtime/int)
  221|  23.7k|                "__builtin_clzll does not take 64-bit arg");
  222|       |
  223|       |  // Handle 0 as a special case because __builtin_clzll(0) is undefined.
  224|  23.7k|  return x == 0 ? 64 : __builtin_clzll(x);
  ------------------
  |  Branch (224:10): [True: 0, False: 23.7k]
  ------------------
  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|  23.7k|}
_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.30k|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.30k|  if (ref_.load(std::memory_order_acquire) == 1 ||
  ------------------
  |  Branch (57:7): [True: 3.30k, False: 0]
  ------------------
   58|  3.30k|      ref_.fetch_sub(1, std::memory_order_acq_rel) - 1 == 0) {
  ------------------
  |  Branch (58:7): [True: 0, False: 0]
  ------------------
   59|  3.30k|    delete this;
   60|  3.30k|  }
   61|  3.30k|}
_ZN4absl12lts_2026052615status_internal9StatusRep17AddSourceLocationENS0_14SourceLocationE:
  141|  3.30k|void StatusRep::AddSourceLocation(absl::SourceLocation loc) {
  142|  3.30k|  source_locations_.push_back(loc);
  143|  3.30k|}

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

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

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

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

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

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

_ZN4absl12lts_2026052610from_charsEPKcS2_RdNS0_12chars_formatE:
  949|  25.5k|                             chars_format fmt) {
  950|  25.5k|  return FromCharsImpl(first, last, value, fmt);
  951|  25.5k|}
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_113FromCharsImplIdEENS0_17from_chars_resultEPKcS5_RT_NS0_12chars_formatE:
  862|  25.5k|                                chars_format fmt_flags) {
  863|  25.5k|  from_chars_result result;
  864|  25.5k|  result.ptr = first;  // overwritten on successful parse
  865|  25.5k|  result.ec = std::errc();
  866|       |
  867|  25.5k|  bool negative = false;
  868|  25.5k|  if (first != last && *first == '-') {
  ------------------
  |  Branch (868:7): [True: 25.5k, False: 0]
  |  Branch (868:24): [True: 3.29k, False: 22.2k]
  ------------------
  869|  3.29k|    ++first;
  870|  3.29k|    negative = true;
  871|  3.29k|  }
  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.5k|  if ((fmt_flags & chars_format::hex) == chars_format{} && last - first >= 2 &&
  ------------------
  |  Branch (874:7): [True: 25.5k, False: 0]
  |  Branch (874:60): [True: 23.5k, False: 1.95k]
  ------------------
  875|  23.5k|      *first == '0' && (first[1] == 'x' || first[1] == 'X')) {
  ------------------
  |  Branch (875:7): [True: 5.96k, False: 17.6k]
  |  Branch (875:25): [True: 2.86k, False: 3.10k]
  |  Branch (875:44): [True: 2.06k, False: 1.03k]
  ------------------
  876|  4.93k|    const char* hex_first = first + 2;
  877|  4.93k|    strings_internal::ParsedFloat hex_parse =
  878|  4.93k|        strings_internal::ParseFloat<16>(hex_first, last, fmt_flags);
  879|  4.93k|    if (hex_parse.end == nullptr ||
  ------------------
  |  Branch (879:9): [True: 30, False: 4.90k]
  ------------------
  880|  4.90k|        hex_parse.type != strings_internal::FloatType::kNumber) {
  ------------------
  |  Branch (880:9): [True: 2, False: 4.89k]
  ------------------
  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|     32|      if (fmt_flags == chars_format::scientific) {
  ------------------
  |  Branch (888:11): [True: 0, False: 32]
  ------------------
  889|      0|        result.ec = std::errc::invalid_argument;
  890|     32|      } else {
  891|     32|        result.ptr = first + 1;
  892|     32|        value = negative ? -0.0f : 0.0f;
  ------------------
  |  Branch (892:17): [True: 3, False: 29]
  ------------------
  893|     32|      }
  894|     32|      return result;
  895|     32|    }
  896|       |    // We matched a value.
  897|  4.89k|    result.ptr = hex_parse.end;
  898|  4.89k|    if (HandleEdgeCase(hex_parse, negative, &value)) {
  ------------------
  |  Branch (898:9): [True: 972, False: 3.92k]
  ------------------
  899|    972|      return result;
  900|    972|    }
  901|  3.92k|    CalculatedFloat calculated =
  902|  3.92k|        CalculateFromParsedHexadecimal<FloatType>(hex_parse);
  903|  3.92k|    EncodeResult(calculated, negative, &result, &value);
  904|  3.92k|    return result;
  905|  4.89k|  }
  906|       |  // Otherwise, we choose the number base based on the flags.
  907|  20.5k|  if ((fmt_flags & chars_format::hex) == chars_format::hex) {
  ------------------
  |  Branch (907:7): [True: 0, False: 20.5k]
  ------------------
  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.5k|  } else {
  923|  20.5k|    strings_internal::ParsedFloat decimal_parse =
  924|  20.5k|        strings_internal::ParseFloat<10>(first, last, fmt_flags);
  925|  20.5k|    if (decimal_parse.end == nullptr) {
  ------------------
  |  Branch (925:9): [True: 101, False: 20.4k]
  ------------------
  926|    101|      result.ec = std::errc::invalid_argument;
  927|    101|      return result;
  928|    101|    }
  929|  20.4k|    result.ptr = decimal_parse.end;
  930|  20.4k|    if (HandleEdgeCase(decimal_parse, negative, &value)) {
  ------------------
  |  Branch (930:9): [True: 2.91k, False: 17.5k]
  ------------------
  931|  2.91k|      return result;
  932|  2.91k|    }
  933|       |    // A nullptr subrange_begin means that the decimal_parse.mantissa is exact
  934|       |    // (not truncated), a precondition of the Eisel-Lemire algorithm.
  935|  17.5k|    if ((decimal_parse.subrange_begin == nullptr) &&
  ------------------
  |  Branch (935:9): [True: 8.26k, False: 9.31k]
  ------------------
  936|  8.26k|        EiselLemire<FloatType>(decimal_parse, negative, &value, &result.ec)) {
  ------------------
  |  Branch (936:9): [True: 4.75k, False: 3.50k]
  ------------------
  937|  4.75k|      return result;
  938|  4.75k|    }
  939|  12.8k|    CalculatedFloat calculated =
  940|  12.8k|        CalculateFromParsedDecimal<FloatType>(decimal_parse);
  941|  12.8k|    EncodeResult(calculated, negative, &result, &value);
  942|  12.8k|    return result;
  943|  17.5k|  }
  944|  20.5k|}
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_114HandleEdgeCaseIdEEbRKNS0_16strings_internal11ParsedFloatEbPT_:
  360|  25.3k|                    FloatType* absl_nonnull value) {
  361|  25.3k|  if (input.type == strings_internal::FloatType::kNan) {
  ------------------
  |  Branch (361:7): [True: 662, False: 24.7k]
  ------------------
  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|    662|    constexpr ptrdiff_t kNanBufferSize = 128;
  368|       |#if (defined(__GNUC__) && !defined(__clang__))
  369|       |    volatile char n_char_sequence[kNanBufferSize];
  370|       |#else
  371|    662|    char n_char_sequence[kNanBufferSize];
  372|    662|#endif
  373|    662|    if (input.subrange_begin == nullptr) {
  ------------------
  |  Branch (373:9): [True: 662, False: 0]
  ------------------
  374|    662|      n_char_sequence[0] = '\0';
  375|    662|    } 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|    662|    char* nan_argument = const_cast<char*>(n_char_sequence);
  382|    662|    *value = negative ? -FloatTraits<FloatType>::MakeNan(nan_argument)
  ------------------
  |  Branch (382:14): [True: 194, False: 468]
  ------------------
  383|    662|                      : FloatTraits<FloatType>::MakeNan(nan_argument);
  384|    662|    return true;
  385|    662|  }
  386|  24.7k|  if (input.type == strings_internal::FloatType::kInfinity) {
  ------------------
  |  Branch (386:7): [True: 451, False: 24.2k]
  ------------------
  387|    451|    *value = negative ? -std::numeric_limits<FloatType>::infinity()
  ------------------
  |  Branch (387:14): [True: 28, False: 423]
  ------------------
  388|    451|                      : std::numeric_limits<FloatType>::infinity();
  389|    451|    return true;
  390|    451|  }
  391|  24.2k|  if (input.mantissa == 0) {
  ------------------
  |  Branch (391:7): [True: 2.77k, False: 21.5k]
  ------------------
  392|  2.77k|    *value = negative ? -0.0f : 0.0f;
  ------------------
  |  Branch (392:14): [True: 226, False: 2.54k]
  ------------------
  393|  2.77k|    return true;
  394|  2.77k|  }
  395|  21.5k|  return false;
  396|  24.2k|}
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_111FloatTraitsIdE7MakeNanEPKc:
  123|    662|  static double MakeNan(const char* absl_nonnull tagp) {
  124|    662|#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|    662|    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|    662|  }
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_130CalculateFromParsedHexadecimalIdEENS1_15CalculatedFloatERKNS0_16strings_internal11ParsedFloatE:
  599|  3.92k|    const strings_internal::ParsedFloat& parsed_hex) {
  600|  3.92k|  uint64_t mantissa = parsed_hex.mantissa;
  601|  3.92k|  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.92k|  int mantissa_width = static_cast<int>(bit_width(mantissa));
  605|  3.92k|  const int shift = NormalizedShiftSize<FloatType>(mantissa_width, exponent);
  606|  3.92k|  bool result_exact;
  607|  3.92k|  exponent += shift;
  608|  3.92k|  mantissa = ShiftRightAndRound(mantissa, shift,
  609|  3.92k|                                /* 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.92k|  return CalculatedFloatFromRawValues<FloatType>(mantissa, exponent);
  613|  3.92k|}
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_119NormalizedShiftSizeIdEEiii:
  335|  16.3k|int NormalizedShiftSize(int mantissa_width, int binary_exponent) {
  336|  16.3k|  const int normal_shift =
  337|  16.3k|      mantissa_width - FloatTraits<FloatType>::kTargetMantissaBits;
  338|  16.3k|  const int minimum_shift =
  339|  16.3k|      FloatTraits<FloatType>::kMinNormalExponent - binary_exponent;
  340|  16.3k|  return std::max(normal_shift, minimum_shift);
  341|  16.3k|}
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_118ShiftRightAndRoundENS0_7uint128EibPb:
  453|  16.3k|                            bool* absl_nonnull output_exact) {
  454|  16.3k|  if (shift <= 0) {
  ------------------
  |  Branch (454:7): [True: 1.67k, False: 14.6k]
  ------------------
  455|  1.67k|    *output_exact = input_exact;
  456|  1.67k|    return static_cast<uint64_t>(value << -shift);
  457|  1.67k|  }
  458|  14.6k|  if (shift >= 128) {
  ------------------
  |  Branch (458:7): [True: 224, False: 14.3k]
  ------------------
  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|    224|    *output_exact = true;
  463|    224|    return 0;
  464|    224|  }
  465|       |
  466|  14.3k|  *output_exact = true;
  467|  14.3k|  const uint128 shift_mask = (uint128(1) << shift) - 1;
  468|  14.3k|  const uint128 halfway_point = uint128(1) << (shift - 1);
  469|       |
  470|  14.3k|  const uint128 shifted_bits = value & shift_mask;
  471|  14.3k|  value >>= shift;
  472|  14.3k|  if (shifted_bits > halfway_point) {
  ------------------
  |  Branch (472:7): [True: 1.41k, False: 12.9k]
  ------------------
  473|       |    // Shifted bits greater than 10000... require rounding up.
  474|  1.41k|    return static_cast<uint64_t>(value + 1);
  475|  1.41k|  }
  476|  12.9k|  if (shifted_bits == halfway_point) {
  ------------------
  |  Branch (476:7): [True: 1.47k, False: 11.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.47k|    if ((value & 1) == 1 || !input_exact) {
  ------------------
  |  Branch (483:9): [True: 426, False: 1.05k]
  |  Branch (483:29): [True: 224, False: 827]
  ------------------
  484|    650|      ++value;
  485|    650|    }
  486|  1.47k|    return static_cast<uint64_t>(value);
  487|  1.47k|  }
  488|  11.5k|  if (!input_exact && shifted_bits == halfway_point - 1) {
  ------------------
  |  Branch (488:7): [True: 10.7k, False: 793]
  |  Branch (488:23): [True: 9.82k, False: 889]
  ------------------
  489|       |    // Rounding direction is unclear, due to error.
  490|  9.82k|    *output_exact = false;
  491|  9.82k|  }
  492|       |  // Otherwise, round down.
  493|  11.5k|  return static_cast<uint64_t>(value);
  494|  12.9k|}
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_128CalculatedFloatFromRawValuesIdEENS1_15CalculatedFloatEmi:
  580|  16.3k|CalculatedFloat CalculatedFloatFromRawValues(uint64_t mantissa, int exponent) {
  581|  16.3k|  CalculatedFloat result;
  582|  16.3k|  if (mantissa == uint64_t{1} << FloatTraits<FloatType>::kTargetMantissaBits) {
  ------------------
  |  Branch (582:7): [True: 668, False: 15.6k]
  ------------------
  583|    668|    mantissa >>= 1;
  584|    668|    exponent += 1;
  585|    668|  }
  586|  16.3k|  if (exponent > FloatTraits<FloatType>::kMaxExponent) {
  ------------------
  |  Branch (586:7): [True: 2.03k, False: 14.2k]
  ------------------
  587|  2.03k|    result.exponent = kOverflow;
  588|  14.2k|  } else if (mantissa == 0) {
  ------------------
  |  Branch (588:14): [True: 740, False: 13.5k]
  ------------------
  589|    740|    result.exponent = kUnderflow;
  590|  13.5k|  } else {
  591|  13.5k|    result.exponent = exponent;
  592|  13.5k|    result.mantissa = mantissa;
  593|  13.5k|  }
  594|  16.3k|  return result;
  595|  16.3k|}
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_112EncodeResultIdEEvRKNS1_15CalculatedFloatEbPNS0_17from_chars_resultEPT_:
  407|  16.7k|                  FloatType* absl_nonnull value) {
  408|  16.7k|  if (calculated.exponent == kOverflow) {
  ------------------
  |  Branch (408:7): [True: 2.25k, False: 14.4k]
  ------------------
  409|  2.25k|    result->ec = std::errc::result_out_of_range;
  410|  2.25k|    *value = negative ? -std::numeric_limits<FloatType>::max()
  ------------------
  |  Branch (410:14): [True: 140, False: 2.11k]
  ------------------
  411|  2.25k|                      : std::numeric_limits<FloatType>::max();
  412|  2.25k|    return;
  413|  14.4k|  } else if (calculated.mantissa == 0 || calculated.exponent == kUnderflow) {
  ------------------
  |  Branch (413:14): [True: 969, False: 13.5k]
  |  Branch (413:42): [True: 0, False: 13.5k]
  ------------------
  414|    969|    result->ec = std::errc::result_out_of_range;
  415|    969|    *value = negative ? -0.0f : 0.0f;
  ------------------
  |  Branch (415:14): [True: 129, False: 840]
  ------------------
  416|    969|    return;
  417|    969|  }
  418|  13.5k|  *value = FloatTraits<FloatType>::Make(
  419|  13.5k|      static_cast<typename FloatTraits<FloatType>::mantissa_t>(
  420|  13.5k|          calculated.mantissa),
  421|  13.5k|      calculated.exponent, negative);
  422|  13.5k|}
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_111FloatTraitsIdE4MakeEmib:
  150|  13.5k|  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.5k|    constexpr uint64_t kMantissaMask =
  158|  13.5k|        (uint64_t{1} << (kTargetMantissaBits - 1)) - 1;
  159|  13.5k|    uint64_t dbl = static_cast<uint64_t>(sign) << 63;
  160|  13.5k|    if (mantissa > kMantissaMask) {
  ------------------
  |  Branch (160:9): [True: 12.7k, False: 730]
  ------------------
  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.7k|      dbl += static_cast<uint64_t>(exponent + 1023 + kTargetMantissaBits - 1)
  166|  12.7k|             << 52;
  167|  12.7k|      mantissa &= kMantissaMask;
  168|  12.7k|    } else {
  169|       |      // subnormal value
  170|       |      assert(exponent == kMinNormalExponent);
  171|    730|    }
  172|  13.5k|    dbl += mantissa;
  173|  13.5k|    return absl::bit_cast<double>(dbl);
  174|  13.5k|#endif  // ABSL_BIT_PACK_FLOATS
  175|  13.5k|  }
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_111EiselLemireIdEEbRKNS0_16strings_internal11ParsedFloatEbPT_PNSt3__14errcE:
  687|  8.26k|                 FloatType* absl_nonnull value, std::errc* absl_nonnull ec) {
  688|  8.26k|  uint64_t man = input.mantissa;
  689|  8.26k|  int exp10 = input.exponent;
  690|  8.26k|  if (exp10 < FloatTraits<FloatType>::kEiselLemireMinInclusiveExp10) {
  ------------------
  |  Branch (690:7): [True: 311, False: 7.95k]
  ------------------
  691|    311|    *value = negative ? -0.0f : 0.0f;
  ------------------
  |  Branch (691:14): [True: 2, False: 309]
  ------------------
  692|    311|    *ec = std::errc::result_out_of_range;
  693|    311|    return true;
  694|  7.95k|  } else if (exp10 >= FloatTraits<FloatType>::kEiselLemireMaxExclusiveExp10) {
  ------------------
  |  Branch (694:14): [True: 468, False: 7.48k]
  ------------------
  695|       |    // Return max (a finite value) consistent with from_chars and DR 3081. For
  696|       |    // SimpleAtod and SimpleAtof, post-processing will return infinity.
  697|    468|    *value = negative ? -std::numeric_limits<FloatType>::max()
  ------------------
  |  Branch (697:14): [True: 226, False: 242]
  ------------------
  698|    468|                      : std::numeric_limits<FloatType>::max();
  699|    468|    *ec = std::errc::result_out_of_range;
  700|    468|    return true;
  701|    468|  }
  702|       |
  703|       |  // Assert kPower10TableMinInclusive <= exp10 < kPower10TableMaxExclusive.
  704|       |  // Equivalently, !Power10Underflow(exp10) and !Power10Overflow(exp10).
  705|  7.48k|  static_assert(
  706|  7.48k|      FloatTraits<FloatType>::kEiselLemireMinInclusiveExp10 >=
  707|  7.48k|          kPower10TableMinInclusive,
  708|  7.48k|      "(exp10-kPower10TableMinInclusive) in kPower10MantissaHighTable bounds");
  709|  7.48k|  static_assert(
  710|  7.48k|      FloatTraits<FloatType>::kEiselLemireMaxExclusiveExp10 <=
  711|  7.48k|          kPower10TableMaxExclusive,
  712|  7.48k|      "(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.48k|  int clz = countl_zero(man);
  728|  7.48k|  man <<= static_cast<unsigned int>(clz);
  729|       |  // The 217706 etc magic numbers are from the Power10Exponent function.
  730|  7.48k|  uint64_t ret_exp2 =
  731|  7.48k|      static_cast<uint64_t>((217706 * exp10 >> 16) + 64 +
  732|  7.48k|                            FloatTraits<FloatType>::kExponentBias - clz);
  733|       |
  734|       |  // (+) Multiplication.
  735|  7.48k|  uint128 x = static_cast<uint128>(man) *
  736|  7.48k|              static_cast<uint128>(
  737|  7.48k|                  kPower10MantissaHighTable[exp10 - kPower10TableMinInclusive]);
  738|       |
  739|       |  // (+) Wider Approximation.
  740|  7.48k|  static constexpr uint64_t high64_mask =
  741|  7.48k|      FloatTraits<FloatType>::kEiselLemireMask;
  742|  7.48k|  if (((Uint128High64(x) & high64_mask) == high64_mask) &&
  ------------------
  |  Branch (742:7): [True: 2.32k, False: 5.16k]
  ------------------
  743|  2.32k|      (man > (std::numeric_limits<uint64_t>::max() - Uint128Low64(x)))) {
  ------------------
  |  Branch (743:7): [True: 1.59k, False: 727]
  ------------------
  744|  1.59k|    uint128 y =
  745|  1.59k|        static_cast<uint128>(man) *
  746|  1.59k|        static_cast<uint128>(
  747|  1.59k|            kPower10MantissaLowTable[exp10 - kPower10TableMinInclusive]);
  748|  1.59k|    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|  1.59k|    if (((Uint128High64(x) & high64_mask) == high64_mask) &&
  ------------------
  |  Branch (758:9): [True: 1.02k, False: 572]
  ------------------
  759|  1.02k|        ((Uint128Low64(x) + 1) == 0) &&
  ------------------
  |  Branch (759:9): [True: 717, False: 309]
  ------------------
  760|    717|        (man > (std::numeric_limits<uint64_t>::max() - Uint128Low64(y)))) {
  ------------------
  |  Branch (760:9): [True: 717, False: 0]
  ------------------
  761|    717|      return false;
  762|    717|    }
  763|  1.59k|  }
  764|       |
  765|       |  // (+) Shifting to 54 Bits (or for single precision, to 25 bits).
  766|  6.76k|  uint64_t msb = Uint128High64(x) >> 63;
  767|  6.76k|  uint64_t ret_man =
  768|  6.76k|      Uint128High64(x) >> (msb + FloatTraits<FloatType>::kEiselLemireShift);
  769|  6.76k|  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.76k|  if ((Uint128Low64(x) == 0) && ((Uint128High64(x) & high64_mask) == 0) &&
  ------------------
  |  Branch (780:7): [True: 4.12k, False: 2.64k]
  |  Branch (780:33): [True: 2.97k, False: 1.14k]
  ------------------
  781|  2.97k|      ((ret_man & 3) == 1)) {
  ------------------
  |  Branch (781:7): [True: 615, False: 2.36k]
  ------------------
  782|    615|    return false;
  783|    615|  }
  784|       |
  785|       |  // (+) From 54 to 53 Bits (or for single precision, from 25 to 24 bits).
  786|  6.15k|  ret_man += ret_man & 1;  // Line From54a.
  787|  6.15k|  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|  6.15k|  if ((ret_man >> FloatTraits<FloatType>::kTargetMantissaBits) > 0) {
  ------------------
  |  Branch (796:7): [True: 201, False: 5.95k]
  ------------------
  797|    201|    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|    201|  }
  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|  6.15k|  static constexpr uint64_t max_exp2 =
  821|  6.15k|      (1 << FloatTraits<FloatType>::kTargetExponentBits) - 1;
  822|  6.15k|  if ((ret_exp2 - 1) >= (max_exp2 - 1)) {
  ------------------
  |  Branch (822:7): [True: 2.17k, False: 3.97k]
  ------------------
  823|  2.17k|    return false;
  824|  2.17k|  }
  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.97k|  if (FloatTraits<FloatType>::kTargetBits == 64) {
  ------------------
  |  Branch (839:7): [True: 3.97k, Folded]
  ------------------
  840|  3.97k|    uint64_t ret_bits = (ret_exp2 << 52) | (ret_man & 0x000FFFFFFFFFFFFFu);
  841|  3.97k|    if (negative) {
  ------------------
  |  Branch (841:9): [True: 433, False: 3.54k]
  ------------------
  842|    433|      ret_bits |= 0x8000000000000000u;
  843|    433|    }
  844|  3.97k|    *value = static_cast<FloatType>(absl::bit_cast<double>(ret_bits));
  845|  3.97k|    return true;
  846|  3.97k|  } 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.97k|}
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_126CalculateFromParsedDecimalIdEENS1_15CalculatedFloatERKNS0_16strings_internal11ParsedFloatE:
  617|  12.8k|    const strings_internal::ParsedFloat& parsed_decimal) {
  618|  12.8k|  CalculatedFloat result;
  619|       |
  620|       |  // Large or small enough decimal exponents will always result in overflow
  621|       |  // or underflow.
  622|  12.8k|  if (Power10Underflow(parsed_decimal.exponent)) {
  ------------------
  |  Branch (622:7): [True: 229, False: 12.5k]
  ------------------
  623|    229|    result.exponent = kUnderflow;
  624|    229|    return result;
  625|  12.5k|  } else if (Power10Overflow(parsed_decimal.exponent)) {
  ------------------
  |  Branch (625:14): [True: 219, False: 12.3k]
  ------------------
  626|    219|    result.exponent = kOverflow;
  627|    219|    return result;
  628|    219|  }
  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|  12.3k|  uint128 wide_binary_mantissa = parsed_decimal.mantissa;
  633|  12.3k|  wide_binary_mantissa *= Power10Mantissa(parsed_decimal.exponent);
  634|  12.3k|  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|  12.3k|  bool mantissa_exact;
  642|  12.3k|  int mantissa_width;
  643|  12.3k|  if (parsed_decimal.subrange_begin) {
  ------------------
  |  Branch (643:7): [True: 8.86k, False: 3.50k]
  ------------------
  644|       |    // Truncated mantissa
  645|  8.86k|    mantissa_width = 58;
  646|  8.86k|    mantissa_exact = false;
  647|  8.86k|    binary_exponent +=
  648|  8.86k|        TruncateToBitWidth(mantissa_width, &wide_binary_mantissa);
  649|  8.86k|  } else if (!Power10Exact(parsed_decimal.exponent)) {
  ------------------
  |  Branch (649:14): [True: 2.89k, False: 615]
  ------------------
  650|       |    // Exact mantissa, truncated power of ten
  651|  2.89k|    mantissa_width = 63;
  652|  2.89k|    mantissa_exact = false;
  653|  2.89k|    binary_exponent +=
  654|  2.89k|        TruncateToBitWidth(mantissa_width, &wide_binary_mantissa);
  655|  2.89k|  } else {
  656|       |    // Product is exact
  657|    615|    mantissa_width = BitWidth(wide_binary_mantissa);
  658|    615|    mantissa_exact = true;
  659|    615|  }
  660|       |
  661|       |  // Shift into an FloatType-sized mantissa, and round to nearest.
  662|  12.3k|  const int shift =
  663|  12.3k|      NormalizedShiftSize<FloatType>(mantissa_width, binary_exponent);
  664|  12.3k|  bool result_exact;
  665|  12.3k|  binary_exponent += shift;
  666|  12.3k|  uint64_t binary_mantissa = ShiftRightAndRound(wide_binary_mantissa, shift,
  667|  12.3k|                                                mantissa_exact, &result_exact);
  668|  12.3k|  if (!result_exact) {
  ------------------
  |  Branch (668:7): [True: 9.82k, False: 2.55k]
  ------------------
  669|       |    // We could not determine the rounding direction using int128 math.  Use
  670|       |    // full resolution math instead.
  671|  9.82k|    if (MustRoundUp(binary_mantissa, binary_exponent, parsed_decimal)) {
  ------------------
  |  Branch (671:9): [True: 2.87k, False: 6.95k]
  ------------------
  672|  2.87k|      binary_mantissa += 1;
  673|  2.87k|    }
  674|  9.82k|  }
  675|       |
  676|  12.3k|  return CalculatedFloatFromRawValues<FloatType>(binary_mantissa,
  677|  12.3k|                                                 binary_exponent);
  678|  12.8k|}
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_116Power10UnderflowEi:
  288|  12.8k|bool Power10Underflow(int n) { return n < kPower10TableMinInclusive; }
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_115Power10OverflowEi:
  284|  12.5k|bool Power10Overflow(int n) { return n >= kPower10TableMaxExclusive; }
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_115Power10MantissaEi:
  270|  12.3k|uint64_t Power10Mantissa(int n) {
  271|  12.3k|  return kPower10MantissaHighTable[n - kPower10TableMinInclusive];
  272|  12.3k|}
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_115Power10ExponentEi:
  274|  12.3k|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|  12.3k|  return (217706 * n >> 16) - 63;
  280|  12.3k|}
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_118TruncateToBitWidthEiPNS0_7uint128E:
  348|  11.7k|int TruncateToBitWidth(int bit_width, uint128* absl_nonnull value) {
  349|  11.7k|  const int current_bit_width = BitWidth(*value);
  350|  11.7k|  const int shift = current_bit_width - bit_width;
  351|  11.7k|  *value >>= shift;
  352|  11.7k|  return shift;
  353|  11.7k|}
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_112Power10ExactEi:
  293|  3.50k|bool Power10Exact(int n) { return n >= 0 && n <= 27; }
  ------------------
  |  Branch (293:35): [True: 2.09k, False: 1.41k]
  |  Branch (293:45): [True: 615, False: 1.47k]
  ------------------
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_18BitWidthENS0_7uint128E:
  317|  12.3k|int BitWidth(uint128 value) {
  318|  12.3k|  if (Uint128High64(value) == 0) {
  ------------------
  |  Branch (318:7): [True: 849, False: 11.5k]
  ------------------
  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|    849|    return static_cast<int>(bit_width(Uint128Low64(value)));
  322|    849|  }
  323|  11.5k|  return 128 - countl_zero(Uint128High64(value));
  324|  12.3k|}
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_111MustRoundUpEmiRKNS0_16strings_internal11ParsedFloatE:
  510|  9.82k|                 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.82k|  absl::strings_internal::BigUnsigned<84> exact_mantissa;
  516|  9.82k|  int exact_exponent = exact_mantissa.ReadFloatMantissa(parsed_decimal, 768);
  517|       |
  518|       |  // Adjust the `guess` arguments to be halfway between A and B.
  519|  9.82k|  guess_mantissa = guess_mantissa * 2 + 1;
  520|  9.82k|  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.82k|  absl::strings_internal::BigUnsigned<84>& lhs = exact_mantissa;
  530|  9.82k|  int comparison;
  531|  9.82k|  if (exact_exponent >= 0) {
  ------------------
  |  Branch (531:7): [True: 3.56k, False: 6.25k]
  ------------------
  532|  3.56k|    lhs.MultiplyByFiveToTheNth(exact_exponent);
  533|  3.56k|    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.56k|    if (exact_exponent > guess_exponent) {
  ------------------
  |  Branch (536:9): [True: 0, False: 3.56k]
  ------------------
  537|      0|      lhs.ShiftLeft(exact_exponent - guess_exponent);
  538|  3.56k|    } else {
  539|  3.56k|      rhs.ShiftLeft(guess_exponent - exact_exponent);
  540|  3.56k|    }
  541|  3.56k|    comparison = Compare(lhs, rhs);
  542|  6.25k|  } 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.25k|    absl::strings_internal::BigUnsigned<84> rhs =
  547|  6.25k|        absl::strings_internal::BigUnsigned<84>::FiveToTheNth(-exact_exponent);
  548|  6.25k|    rhs.MultiplyBy(guess_mantissa);
  549|  6.25k|    if (exact_exponent > guess_exponent) {
  ------------------
  |  Branch (549:9): [True: 2.02k, False: 4.22k]
  ------------------
  550|  2.02k|      lhs.ShiftLeft(exact_exponent - guess_exponent);
  551|  4.22k|    } else {
  552|  4.22k|      rhs.ShiftLeft(guess_exponent - exact_exponent);
  553|  4.22k|    }
  554|  6.25k|    comparison = Compare(lhs, rhs);
  555|  6.25k|  }
  556|  9.82k|  if (comparison < 0) {
  ------------------
  |  Branch (556:7): [True: 6.44k, False: 3.37k]
  ------------------
  557|  6.44k|    return false;
  558|  6.44k|  } else if (comparison > 0) {
  ------------------
  |  Branch (558:14): [True: 2.51k, False: 854]
  ------------------
  559|  2.51k|    return true;
  560|  2.51k|  } 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|    854|    return (guess_mantissa & 2) == 2;
  566|    854|  }
  567|  9.82k|}

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

_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.82k|                                              int significant_digits) {
  173|  9.82k|  SetToZero();
  174|  9.82k|  assert(fp.type == FloatType::kNumber);
  175|       |
  176|  9.82k|  if (fp.subrange_begin == nullptr) {
  ------------------
  |  Branch (176:7): [True: 1.74k, False: 8.08k]
  ------------------
  177|       |    // We already exactly parsed the mantissa, so no more work is necessary.
  178|  1.74k|    words_[0] = fp.mantissa & 0xffffffffu;
  179|  1.74k|    words_[1] = fp.mantissa >> 32;
  180|  1.74k|    if (words_[1]) {
  ------------------
  |  Branch (180:9): [True: 453, False: 1.28k]
  ------------------
  181|    453|      size_ = 2;
  182|  1.28k|    } else if (words_[0]) {
  ------------------
  |  Branch (182:16): [True: 1.28k, False: 0]
  ------------------
  183|  1.28k|      size_ = 1;
  184|  1.28k|    }
  185|  1.74k|    return fp.exponent;
  186|  1.74k|  }
  187|  8.08k|  int exponent_adjust =
  188|  8.08k|      ReadDigits(fp.subrange_begin, fp.subrange_end, significant_digits);
  189|  8.08k|  return fp.literal_exponent + exponent_adjust;
  190|  9.82k|}
_ZN4absl12lts_2026052616strings_internal11BigUnsignedILi84EE12FiveToTheNthEi:
  289|  6.25k|    int n) {
  290|  6.25k|  BigUnsigned answer(1u);
  291|       |
  292|       |  // Seed from the table of large powers, if possible.
  293|  6.25k|  bool first_pass = true;
  294|  12.8k|  while (n >= kLargePowerOfFiveStep) {
  ------------------
  |  Branch (294:10): [True: 6.56k, False: 6.25k]
  ------------------
  295|  6.56k|    int big_power =
  296|  6.56k|        std::min(n / kLargePowerOfFiveStep, kLargestPowerOfFiveIndex);
  297|  6.56k|    if (first_pass) {
  ------------------
  |  Branch (297:9): [True: 3.97k, False: 2.58k]
  ------------------
  298|       |      // just copy, rather than multiplying by 1
  299|  3.97k|      std::copy_n(LargePowerOfFiveData(big_power),
  300|  3.97k|                  LargePowerOfFiveSize(big_power), answer.words_);
  301|  3.97k|      answer.size_ = LargePowerOfFiveSize(big_power);
  302|  3.97k|      first_pass = false;
  303|  3.97k|    } else {
  304|  2.58k|      answer.MultiplyBy(LargePowerOfFiveSize(big_power),
  305|  2.58k|                        LargePowerOfFiveData(big_power));
  306|  2.58k|    }
  307|  6.56k|    n -= kLargePowerOfFiveStep * big_power;
  308|  6.56k|  }
  309|  6.25k|  answer.MultiplyByFiveToTheNth(n);
  310|  6.25k|  return answer;
  311|  6.25k|}
_ZN4absl12lts_2026052616strings_internal11BigUnsignedILi84EE10ReadDigitsEPKcS5_i:
  194|  8.08k|                                       int significant_digits) {
  195|  8.08k|  assert(significant_digits <= Digits10() + 1);
  196|  8.08k|  SetToZero();
  197|       |
  198|  8.08k|  bool after_decimal_point = false;
  199|       |  // Discard any leading zeroes before the decimal point
  200|  8.54k|  while (begin < end && *begin == '0') {
  ------------------
  |  Branch (200:10): [True: 8.54k, False: 0]
  |  Branch (200:25): [True: 459, False: 8.08k]
  ------------------
  201|    459|    ++begin;
  202|    459|  }
  203|  8.08k|  int dropped_digits = 0;
  204|       |  // Discard any trailing zeroes.  These may or may not be after the decimal
  205|       |  // point.
  206|  1.32M|  while (begin < end && *std::prev(end) == '0') {
  ------------------
  |  Branch (206:10): [True: 1.32M, False: 0]
  |  Branch (206:25): [True: 1.31M, False: 8.08k]
  ------------------
  207|  1.31M|    --end;
  208|  1.31M|    ++dropped_digits;
  209|  1.31M|  }
  210|  8.08k|  if (begin < end && *std::prev(end) == '.') {
  ------------------
  |  Branch (210:7): [True: 8.08k, False: 0]
  |  Branch (210:22): [True: 297, False: 7.78k]
  ------------------
  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|    297|    dropped_digits = 0;
  214|    297|    --end;
  215|    637|    while (begin < end && *std::prev(end) == '0') {
  ------------------
  |  Branch (215:12): [True: 637, False: 0]
  |  Branch (215:27): [True: 340, False: 297]
  ------------------
  216|    340|      --end;
  217|    340|      ++dropped_digits;
  218|    340|    }
  219|  7.78k|  } else if (dropped_digits) {
  ------------------
  |  Branch (219:14): [True: 642, False: 7.14k]
  ------------------
  220|       |    // We dropped digits, and aren't sure if they're before or after the decimal
  221|       |    // point.  Figure that out now.
  222|    642|    const char* dp = std::find(begin, end, '.');
  223|    642|    if (dp != end) {
  ------------------
  |  Branch (223:9): [True: 380, False: 262]
  ------------------
  224|       |      // The dropped trailing digits were after the decimal point, so don't
  225|       |      // count them.
  226|    380|      dropped_digits = 0;
  227|    380|    }
  228|    642|  }
  229|       |  // Any non-fraction digits we dropped need to be accounted for in our exponent
  230|       |  // adjustment.
  231|  8.08k|  int exponent_adjust = dropped_digits;
  232|       |
  233|  8.08k|  uint32_t queued = 0;
  234|  8.08k|  int digits_queued = 0;
  235|  2.06M|  for (; begin != end && significant_digits > 0; ++begin) {
  ------------------
  |  Branch (235:10): [True: 2.05M, False: 7.07k]
  |  Branch (235:26): [True: 2.05M, False: 1.00k]
  ------------------
  236|  2.05M|    if (*begin == '.') {
  ------------------
  |  Branch (236:9): [True: 4.91k, False: 2.05M]
  ------------------
  237|  4.91k|      after_decimal_point = true;
  238|  4.91k|      continue;
  239|  4.91k|    }
  240|  2.05M|    if (after_decimal_point) {
  ------------------
  |  Branch (240:9): [True: 1.93M, False: 119k]
  ------------------
  241|       |      // For each fractional digit we emit in our parsed integer, adjust our
  242|       |      // decimal exponent to compensate.
  243|  1.93M|      --exponent_adjust;
  244|  1.93M|    }
  245|  2.05M|    char digit = (*begin - '0');
  246|  2.05M|    --significant_digits;
  247|  2.05M|    if (significant_digits == 0 && std::next(begin) != end &&
  ------------------
  |  Branch (247:9): [True: 1.33k, False: 2.05M]
  |  Branch (247:36): [True: 1.00k, False: 328]
  ------------------
  248|  1.00k|        (digit == 0 || digit == 5)) {
  ------------------
  |  Branch (248:10): [True: 513, False: 496]
  |  Branch (248:24): [True: 226, False: 270]
  ------------------
  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|    739|      ++digit;
  257|    739|    }
  258|  2.05M|    queued = 10 * queued + static_cast<uint32_t>(digit);
  259|  2.05M|    ++digits_queued;
  260|  2.05M|    if (digits_queued == kMaxSmallPowerOfTen) {
  ------------------
  |  Branch (260:9): [True: 225k, False: 1.82M]
  ------------------
  261|   225k|      MultiplyBy(kTenToNth[kMaxSmallPowerOfTen]);
  262|   225k|      AddWithCarry(0, queued);
  263|   225k|      queued = digits_queued = 0;
  264|   225k|    }
  265|  2.05M|  }
  266|       |  // Encode any remaining digits.
  267|  8.08k|  if (digits_queued) {
  ------------------
  |  Branch (267:7): [True: 7.17k, False: 912]
  ------------------
  268|  7.17k|    MultiplyBy(kTenToNth[digits_queued]);
  269|  7.17k|    AddWithCarry(0, queued);
  270|  7.17k|  }
  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|  8.08k|  if (begin < end && !after_decimal_point) {
  ------------------
  |  Branch (275:7): [True: 1.00k, False: 7.07k]
  |  Branch (275:22): [True: 2, False: 1.00k]
  ------------------
  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|  8.08k|  return exponent_adjust;
  285|  8.08k|}
_ZN4absl12lts_2026052616strings_internal11BigUnsignedILi84EE12MultiplyStepEiPKjii:
  316|   289k|                                          int other_size, int step) {
  317|   289k|  int this_i = std::min(original_size - 1, step);
  318|   289k|  int other_i = step - this_i;
  319|       |
  320|   289k|  uint64_t this_word = 0;
  321|   289k|  uint64_t carry = 0;
  322|  1.67M|  for (; this_i >= 0 && other_i < other_size; --this_i, ++other_i) {
  ------------------
  |  Branch (322:10): [True: 1.63M, False: 39.4k]
  |  Branch (322:25): [True: 1.38M, False: 249k]
  ------------------
  323|  1.38M|    uint64_t product = words_[this_i];
  324|  1.38M|    product *= other_words[other_i];
  325|  1.38M|    this_word += product;
  326|  1.38M|    carry += (this_word >> 32);
  327|  1.38M|    this_word &= 0xffffffff;
  328|  1.38M|  }
  329|   289k|  AddWithCarry(step + 1, carry);
  330|   289k|  words_[step] = this_word & 0xffffffff;
  331|   289k|  if (this_word > 0 && size_ <= step) {
  ------------------
  |  Branch (331:7): [True: 289k, False: 0]
  |  Branch (331:24): [True: 3.57k, False: 285k]
  ------------------
  332|  3.57k|    size_ = step + 1;
  333|  3.57k|  }
  334|   289k|}
charconv_bigint.cc:_ZN4absl12lts_2026052616strings_internal12_GLOBAL__N_120LargePowerOfFiveDataEi:
  152|  6.56k|const uint32_t* LargePowerOfFiveData(int i) {
  153|  6.56k|  return kLargePowersOfFive + i * (i - 1);
  154|  6.56k|}
charconv_bigint.cc:_ZN4absl12lts_2026052616strings_internal12_GLOBAL__N_120LargePowerOfFiveSizeEi:
  158|  10.5k|int LargePowerOfFiveSize(int i) { return 2 * i; }

_ZN4absl12lts_2026052616strings_internal11BigUnsignedILi84EEC2Ev:
   62|  9.82k|  BigUnsigned() : size_(0), words_{} {}
_ZN4absl12lts_2026052616strings_internal11BigUnsignedILi84EE22MultiplyByFiveToTheNthEi:
  174|  9.82k|  void MultiplyByFiveToTheNth(int n) {
  175|  48.0k|    while (n >= kMaxSmallPowerOfFive) {
  ------------------
  |  Branch (175:12): [True: 38.2k, False: 9.82k]
  ------------------
  176|  38.2k|      MultiplyBy(kFiveToNth[kMaxSmallPowerOfFive]);
  177|  38.2k|      n -= kMaxSmallPowerOfFive;
  178|  38.2k|    }
  179|  9.82k|    if (n > 0) {
  ------------------
  |  Branch (179:9): [True: 7.96k, False: 1.85k]
  ------------------
  180|  7.96k|      MultiplyBy(kFiveToNth[n]);
  181|  7.96k|    }
  182|  9.82k|  }
_ZN4absl12lts_2026052616strings_internal11BigUnsignedILi84EE10MultiplyByEj:
  140|   278k|  void MultiplyBy(uint32_t v) {
  141|   278k|    if (size_ == 0 || v == 1) {
  ------------------
  |  Branch (141:9): [True: 8.08k, False: 270k]
  |  Branch (141:23): [True: 0, False: 270k]
  ------------------
  142|  8.08k|      return;
  143|  8.08k|    }
  144|   270k|    if (v == 0) {
  ------------------
  |  Branch (144:9): [True: 0, False: 270k]
  ------------------
  145|      0|      SetToZero();
  146|      0|      return;
  147|      0|    }
  148|   270k|    const uint64_t factor = v;
  149|   270k|    uint64_t window = 0;
  150|  8.55M|    for (int i = 0; i < size_; ++i) {
  ------------------
  |  Branch (150:21): [True: 8.28M, False: 270k]
  ------------------
  151|  8.28M|      window += factor * words_[i];
  152|  8.28M|      words_[i] = window & 0xffffffff;
  153|  8.28M|      window >>= 32;
  154|  8.28M|    }
  155|       |    // If carry bits remain and there's space for them, grow size_.
  156|   270k|    if (window && size_ < max_words) {
  ------------------
  |  Branch (156:9): [True: 247k, False: 22.8k]
  |  Branch (156:19): [True: 247k, False: 0]
  ------------------
  157|   247k|      words_[size_] = window & 0xffffffff;
  158|   247k|      ++size_;
  159|   247k|    }
  160|   270k|  }
_ZN4absl12lts_2026052616strings_internal11BigUnsignedILi84EE9SetToZeroEv:
  209|  17.9k|  void SetToZero() {
  210|  17.9k|    std::fill_n(words_, size_, 0u);
  211|  17.9k|    size_ = 0;
  212|  17.9k|  }
_ZN4absl12lts_2026052616strings_internal11BigUnsignedILi84EEC2Em:
   64|  9.82k|      : size_((v >> 32) ? 2 : v ? 1 : 0),
  ------------------
  |  Branch (64:15): [True: 3.56k, False: 6.25k]
  |  Branch (64:31): [True: 6.25k, False: 0]
  ------------------
   65|  9.82k|        words_{static_cast<uint32_t>(v & 0xffffffffu),
   66|  9.82k|               static_cast<uint32_t>(v >> 32)} {}
_ZN4absl12lts_2026052616strings_internal11BigUnsignedILi84EE9ShiftLeftEi:
  102|  9.82k|  void ShiftLeft(int count) {
  103|  9.82k|    if (count > 0) {
  ------------------
  |  Branch (103:9): [True: 9.57k, False: 244]
  ------------------
  104|  9.57k|      const int word_shift = count / 32;
  105|  9.57k|      if (word_shift >= max_words) {
  ------------------
  |  Branch (105:11): [True: 0, False: 9.57k]
  ------------------
  106|      0|        SetToZero();
  107|      0|        return;
  108|      0|      }
  109|  9.57k|      size_ = (std::min)(size_ + word_shift, max_words);
  110|  9.57k|      count %= 32;
  111|  9.57k|      if (count == 0) {
  ------------------
  |  Branch (111:11): [True: 827, False: 8.75k]
  ------------------
  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|    827|        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.75k|      } else {
  124|   161k|        for (int i = (std::min)(size_, max_words - 1); i > word_shift; --i) {
  ------------------
  |  Branch (124:56): [True: 152k, False: 8.75k]
  ------------------
  125|   152k|          words_[i] = (words_[i - word_shift] << count) |
  126|   152k|                      (words_[i - word_shift - 1] >> (32 - count));
  127|   152k|        }
  128|  8.75k|        words_[word_shift] = words_[0] << count;
  129|       |        // Grow size_ if necessary.
  130|  8.75k|        if (size_ < max_words && words_[size_]) {
  ------------------
  |  Branch (130:13): [True: 8.75k, False: 0]
  |  Branch (130:34): [True: 4.21k, False: 4.54k]
  ------------------
  131|  4.21k|          ++size_;
  132|  4.21k|        }
  133|  8.75k|      }
  134|  9.57k|      std::fill_n(words_, word_shift, 0u);
  135|  9.57k|    }
  136|  9.82k|  }
_ZN4absl12lts_2026052616strings_internal7CompareILi84ELi84EEEiRKNS1_11BigUnsignedIXT_EEERKNS3_IXT0_EEE:
  363|  9.82k|int Compare(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs) {
  364|  9.82k|  int limit = (std::max)(lhs.size(), rhs.size());
  365|  28.8k|  for (int i = limit - 1; i >= 0; --i) {
  ------------------
  |  Branch (365:27): [True: 27.9k, False: 854]
  ------------------
  366|  27.9k|    const uint32_t lhs_word = lhs.GetWord(i);
  367|  27.9k|    const uint32_t rhs_word = rhs.GetWord(i);
  368|  27.9k|    if (lhs_word < rhs_word) {
  ------------------
  |  Branch (368:9): [True: 6.44k, False: 21.5k]
  ------------------
  369|  6.44k|      return -1;
  370|  21.5k|    } else if (lhs_word > rhs_word) {
  ------------------
  |  Branch (370:16): [True: 2.51k, False: 18.9k]
  ------------------
  371|  2.51k|      return 1;
  372|  2.51k|    }
  373|  27.9k|  }
  374|    854|  return 0;
  375|  9.82k|}
_ZNK4absl12lts_2026052616strings_internal11BigUnsignedILi84EE4sizeEv:
  227|  19.6k|  int size() const { return size_; }
_ZNK4absl12lts_2026052616strings_internal11BigUnsignedILi84EE7GetWordEi:
  216|  55.9k|  uint32_t GetWord(int index) const {
  217|  55.9k|    if (index < 0 || index >= size_) {
  ------------------
  |  Branch (217:9): [True: 0, False: 55.9k]
  |  Branch (217:22): [True: 194, False: 55.7k]
  ------------------
  218|    194|      return 0;
  219|    194|    }
  220|  55.7k|    return words_[index];
  221|  55.9k|  }
_ZN4absl12lts_2026052616strings_internal11BigUnsignedILi84EE10MultiplyByEm:
  162|  6.25k|  void MultiplyBy(uint64_t v) {
  163|  6.25k|    uint32_t words[2];
  164|  6.25k|    words[0] = static_cast<uint32_t>(v);
  165|  6.25k|    words[1] = static_cast<uint32_t>(v >> 32);
  166|  6.25k|    if (words[1] == 0) {
  ------------------
  |  Branch (166:9): [True: 0, False: 6.25k]
  ------------------
  167|      0|      MultiplyBy(words[0]);
  168|  6.25k|    } else {
  169|  6.25k|      MultiplyBy(2, words);
  170|  6.25k|    }
  171|  6.25k|  }
_ZN4absl12lts_2026052616strings_internal11BigUnsignedILi84EE10MultiplyByEiPKj:
  280|  8.84k|  void MultiplyBy(int other_size, const uint32_t* other_words) {
  281|  8.84k|    const int original_size = size_;
  282|  8.84k|    const int first_step =
  283|  8.84k|        (std::min)(original_size + other_size - 2, max_words - 1);
  284|   297k|    for (int step = first_step; step >= 0; --step) {
  ------------------
  |  Branch (284:33): [True: 289k, False: 8.84k]
  ------------------
  285|   289k|      MultiplyStep(original_size, other_words, other_size, step);
  286|   289k|    }
  287|  8.84k|  }
_ZN4absl12lts_2026052616strings_internal11BigUnsignedILi84EE12AddWithCarryEij:
  290|   370k|  void AddWithCarry(int index, uint32_t value) {
  291|   370k|    if (value) {
  ------------------
  |  Branch (291:9): [True: 369k, False: 841]
  ------------------
  292|   767k|      while (index < max_words && value > 0) {
  ------------------
  |  Branch (292:14): [True: 767k, False: 0]
  |  Branch (292:35): [True: 397k, False: 369k]
  ------------------
  293|   397k|        words_[index] += value;
  294|       |        // carry if we overflowed in this word:
  295|   397k|        if (value > words_[index]) {
  ------------------
  |  Branch (295:13): [True: 27.3k, False: 369k]
  ------------------
  296|  27.3k|          value = 1;
  297|  27.3k|          ++index;
  298|   369k|        } else {
  299|   369k|          value = 0;
  300|   369k|        }
  301|   397k|      }
  302|   369k|      size_ = (std::min)(max_words, (std::max)(index + 1, size_));
  303|   369k|    }
  304|   370k|  }
_ZN4absl12lts_2026052616strings_internal11BigUnsignedILi84EE12AddWithCarryEim:
  306|   289k|  void AddWithCarry(int index, uint64_t value) {
  307|   289k|    if (value && index < max_words) {
  ------------------
  |  Branch (307:9): [True: 285k, False: 3.93k]
  |  Branch (307:18): [True: 285k, False: 0]
  ------------------
  308|   285k|      uint32_t high = value >> 32;
  309|   285k|      uint32_t low = value & 0xffffffff;
  310|   285k|      words_[index] += low;
  311|   285k|      if (words_[index] < low) {
  ------------------
  |  Branch (311:11): [True: 96.3k, False: 188k]
  ------------------
  312|  96.3k|        ++high;
  313|  96.3k|        if (high == 0) {
  ------------------
  |  Branch (313:13): [True: 0, False: 96.3k]
  ------------------
  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|  96.3k|      }
  320|   285k|      if (high > 0) {
  ------------------
  |  Branch (320:11): [True: 138k, False: 147k]
  ------------------
  321|   138k|        AddWithCarry(index + 1, high);
  322|   147k|      } 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|   147k|        size_ = (std::min)(max_words, (std::max)(index + 1, size_));
  326|   147k|      }
  327|   285k|    }
  328|   289k|  }

_ZN4absl12lts_2026052616strings_internal10ParseFloatILi10EEENS1_11ParsedFloatEPKcS5_NS0_12chars_formatE:
  356|  20.5k|                                         chars_format format_flags) {
  357|  20.5k|  strings_internal::ParsedFloat result;
  358|       |
  359|       |  // Exit early if we're given an empty range.
  360|  20.5k|  if (begin == end) return result;
  ------------------
  |  Branch (360:7): [True: 1, False: 20.5k]
  ------------------
  361|       |
  362|       |  // Handle the infinity and NaN cases.
  363|  20.5k|  if (ParseInfinityOrNan(begin, end, &result)) {
  ------------------
  |  Branch (363:7): [True: 1.11k, False: 19.4k]
  ------------------
  364|  1.11k|    return result;
  365|  1.11k|  }
  366|       |
  367|  19.4k|  const char* const mantissa_begin = begin;
  368|  21.5k|  while (begin < end && *begin == '0') {
  ------------------
  |  Branch (368:10): [True: 20.8k, False: 635]
  |  Branch (368:25): [True: 2.04k, False: 18.8k]
  ------------------
  369|  2.04k|    ++begin;  // skip leading zeros
  370|  2.04k|  }
  371|  19.4k|  uint64_t mantissa = 0;
  372|       |
  373|  19.4k|  int exponent_adjustment = 0;
  374|  19.4k|  bool mantissa_is_inexact = false;
  375|  19.4k|  int pre_decimal_digits = ConsumeDigits<base>(
  376|  19.4k|      begin, end, MantissaDigitsMax<base>(), &mantissa, &mantissa_is_inexact);
  377|  19.4k|  begin += pre_decimal_digits;
  378|  19.4k|  int digits_left;
  379|  19.4k|  if (pre_decimal_digits >= DigitLimit<base>()) {
  ------------------
  |  Branch (379:7): [True: 0, False: 19.4k]
  ------------------
  380|       |    // refuse to parse pathological inputs
  381|      0|    return result;
  382|  19.4k|  } else if (pre_decimal_digits > MantissaDigitsMax<base>()) {
  ------------------
  |  Branch (382:14): [True: 5.26k, False: 14.2k]
  ------------------
  383|       |    // We dropped some non-fraction digits on the floor.  Adjust our exponent
  384|       |    // to compensate.
  385|  5.26k|    exponent_adjustment =
  386|  5.26k|        static_cast<int>(pre_decimal_digits - MantissaDigitsMax<base>());
  387|  5.26k|    digits_left = 0;
  388|  14.2k|  } else {
  389|  14.2k|    digits_left =
  390|  14.2k|        static_cast<int>(MantissaDigitsMax<base>() - pre_decimal_digits);
  391|  14.2k|  }
  392|  19.4k|  if (begin < end && *begin == '.') {
  ------------------
  |  Branch (392:7): [True: 15.9k, False: 3.57k]
  |  Branch (392:22): [True: 8.10k, False: 7.80k]
  ------------------
  393|  8.10k|    ++begin;
  394|  8.10k|    if (mantissa == 0) {
  ------------------
  |  Branch (394:9): [True: 4.73k, False: 3.37k]
  ------------------
  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.73k|      const char* begin_zeros = begin;
  398|  5.43k|      while (begin < end && *begin == '0') {
  ------------------
  |  Branch (398:14): [True: 4.80k, False: 630]
  |  Branch (398:29): [True: 708, False: 4.10k]
  ------------------
  399|    708|        ++begin;
  400|    708|      }
  401|  4.73k|      int zeros_skipped = static_cast<int>(begin - begin_zeros);
  402|  4.73k|      if (zeros_skipped >= DigitLimit<base>()) {
  ------------------
  |  Branch (402:11): [True: 0, False: 4.73k]
  ------------------
  403|       |        // refuse to parse pathological inputs
  404|      0|        return result;
  405|      0|      }
  406|  4.73k|      exponent_adjustment -= static_cast<int>(zeros_skipped);
  407|  4.73k|    }
  408|  8.10k|    int post_decimal_digits = ConsumeDigits<base>(
  409|  8.10k|        begin, end, digits_left, &mantissa, &mantissa_is_inexact);
  410|  8.10k|    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.10k|    if (post_decimal_digits >= DigitLimit<base>()) {
  ------------------
  |  Branch (416:9): [True: 0, False: 8.10k]
  ------------------
  417|       |      // refuse to parse pathological inputs
  418|      0|      return result;
  419|  8.10k|    } else if (post_decimal_digits > digits_left) {
  ------------------
  |  Branch (419:16): [True: 5.27k, False: 2.82k]
  ------------------
  420|  5.27k|      exponent_adjustment -= digits_left;
  421|  5.27k|    } else {
  422|  2.82k|      exponent_adjustment -= post_decimal_digits;
  423|  2.82k|    }
  424|  8.10k|  }
  425|       |  // If we've found no mantissa whatsoever, this isn't a number.
  426|  19.4k|  if (mantissa_begin == begin) {
  ------------------
  |  Branch (426:7): [True: 76, False: 19.4k]
  ------------------
  427|     76|    return result;
  428|     76|  }
  429|       |  // A bare "." doesn't count as a mantissa either.
  430|  19.4k|  if (begin - mantissa_begin == 1 && *mantissa_begin == '.') {
  ------------------
  |  Branch (430:7): [True: 5.31k, False: 14.0k]
  |  Branch (430:38): [True: 24, False: 5.28k]
  ------------------
  431|     24|    return result;
  432|     24|  }
  433|       |
  434|  19.3k|  if (mantissa_is_inexact) {
  ------------------
  |  Branch (434:7): [True: 9.31k, False: 10.0k]
  ------------------
  435|       |    // We dropped significant digits on the floor.  Handle this appropriately.
  436|  9.31k|    if (base == 10) {
  ------------------
  |  Branch (436:9): [True: 9.31k, 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|  9.31k|      result.subrange_begin = mantissa_begin;
  440|  9.31k|      result.subrange_end = begin;
  441|  9.31k|    } 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|  9.31k|  }
  447|  19.3k|  result.mantissa = mantissa;
  448|       |
  449|  19.3k|  const char* const exponent_begin = begin;
  450|  19.3k|  result.literal_exponent = 0;
  451|  19.3k|  bool found_exponent = false;
  452|  19.3k|  if (AllowExponent(format_flags) && begin < end &&
  ------------------
  |  Branch (452:7): [True: 19.3k, False: 0]
  |  Branch (452:38): [True: 8.53k, False: 10.8k]
  ------------------
  453|  8.53k|      IsExponentCharacter<base>(*begin)) {
  ------------------
  |  Branch (453:7): [True: 8.43k, False: 94]
  ------------------
  454|  8.43k|    bool negative_exponent = false;
  455|  8.43k|    ++begin;
  456|  8.43k|    if (begin < end && *begin == '-') {
  ------------------
  |  Branch (456:9): [True: 8.42k, False: 9]
  |  Branch (456:24): [True: 3.27k, False: 5.15k]
  ------------------
  457|  3.27k|      negative_exponent = true;
  458|  3.27k|      ++begin;
  459|  5.15k|    } else if (begin < end && *begin == '+') {
  ------------------
  |  Branch (459:16): [True: 5.15k, False: 9]
  |  Branch (459:31): [True: 338, False: 4.81k]
  ------------------
  460|    338|      ++begin;
  461|    338|    }
  462|  8.43k|    const char* const exponent_digits_begin = begin;
  463|       |    // Exponent is always expressed in decimal, even for hexadecimal floats.
  464|  8.43k|    begin += ConsumeDigits<10>(begin, end, kDecimalExponentDigitsMax,
  465|  8.43k|                               &result.literal_exponent, nullptr);
  466|  8.43k|    if (begin == exponent_digits_begin) {
  ------------------
  |  Branch (466:9): [True: 33, False: 8.40k]
  ------------------
  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|     33|      found_exponent = false;
  470|     33|      begin = exponent_begin;
  471|  8.40k|    } else {
  472|  8.40k|      found_exponent = true;
  473|  8.40k|      if (negative_exponent) {
  ------------------
  |  Branch (473:11): [True: 3.27k, False: 5.12k]
  ------------------
  474|  3.27k|        result.literal_exponent = -result.literal_exponent;
  475|  3.27k|      }
  476|  8.40k|    }
  477|  8.43k|  }
  478|       |
  479|  19.3k|  if (!found_exponent && RequireExponent(format_flags)) {
  ------------------
  |  Branch (479:7): [True: 10.9k, False: 8.40k]
  |  Branch (479:26): [True: 0, False: 10.9k]
  ------------------
  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|  19.3k|  result.type = strings_internal::FloatType::kNumber;
  487|  19.3k|  if (result.mantissa > 0) {
  ------------------
  |  Branch (487:7): [True: 17.5k, False: 1.79k]
  ------------------
  488|  17.5k|    result.exponent = result.literal_exponent +
  489|  17.5k|                      (DigitMagnitude<base>() * exponent_adjustment);
  490|  17.5k|  } else {
  491|  1.79k|    result.exponent = 0;
  492|  1.79k|  }
  493|  19.3k|  result.end = begin;
  494|  19.3k|  return result;
  495|  19.3k|}
_ZN4absl12lts_2026052616strings_internal10ParseFloatILi16EEENS1_11ParsedFloatEPKcS5_NS0_12chars_formatE:
  356|  4.93k|                                         chars_format format_flags) {
  357|  4.93k|  strings_internal::ParsedFloat result;
  358|       |
  359|       |  // Exit early if we're given an empty range.
  360|  4.93k|  if (begin == end) return result;
  ------------------
  |  Branch (360:7): [True: 3, False: 4.92k]
  ------------------
  361|       |
  362|       |  // Handle the infinity and NaN cases.
  363|  4.92k|  if (ParseInfinityOrNan(begin, end, &result)) {
  ------------------
  |  Branch (363:7): [True: 2, False: 4.92k]
  ------------------
  364|      2|    return result;
  365|      2|  }
  366|       |
  367|  4.92k|  const char* const mantissa_begin = begin;
  368|  5.69k|  while (begin < end && *begin == '0') {
  ------------------
  |  Branch (368:10): [True: 5.48k, False: 215]
  |  Branch (368:25): [True: 772, False: 4.71k]
  ------------------
  369|    772|    ++begin;  // skip leading zeros
  370|    772|  }
  371|  4.92k|  uint64_t mantissa = 0;
  372|       |
  373|  4.92k|  int exponent_adjustment = 0;
  374|  4.92k|  bool mantissa_is_inexact = false;
  375|  4.92k|  int pre_decimal_digits = ConsumeDigits<base>(
  376|  4.92k|      begin, end, MantissaDigitsMax<base>(), &mantissa, &mantissa_is_inexact);
  377|  4.92k|  begin += pre_decimal_digits;
  378|  4.92k|  int digits_left;
  379|  4.92k|  if (pre_decimal_digits >= DigitLimit<base>()) {
  ------------------
  |  Branch (379:7): [True: 0, False: 4.92k]
  ------------------
  380|       |    // refuse to parse pathological inputs
  381|      0|    return result;
  382|  4.92k|  } else if (pre_decimal_digits > MantissaDigitsMax<base>()) {
  ------------------
  |  Branch (382:14): [True: 707, False: 4.21k]
  ------------------
  383|       |    // We dropped some non-fraction digits on the floor.  Adjust our exponent
  384|       |    // to compensate.
  385|    707|    exponent_adjustment =
  386|    707|        static_cast<int>(pre_decimal_digits - MantissaDigitsMax<base>());
  387|    707|    digits_left = 0;
  388|  4.21k|  } else {
  389|  4.21k|    digits_left =
  390|  4.21k|        static_cast<int>(MantissaDigitsMax<base>() - pre_decimal_digits);
  391|  4.21k|  }
  392|  4.92k|  if (begin < end && *begin == '.') {
  ------------------
  |  Branch (392:7): [True: 3.15k, False: 1.77k]
  |  Branch (392:22): [True: 1.80k, False: 1.34k]
  ------------------
  393|  1.80k|    ++begin;
  394|  1.80k|    if (mantissa == 0) {
  ------------------
  |  Branch (394:9): [True: 1.16k, False: 638]
  ------------------
  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|  1.16k|      const char* begin_zeros = begin;
  398|  1.78k|      while (begin < end && *begin == '0') {
  ------------------
  |  Branch (398:14): [True: 1.34k, False: 435]
  |  Branch (398:29): [True: 612, False: 734]
  ------------------
  399|    612|        ++begin;
  400|    612|      }
  401|  1.16k|      int zeros_skipped = static_cast<int>(begin - begin_zeros);
  402|  1.16k|      if (zeros_skipped >= DigitLimit<base>()) {
  ------------------
  |  Branch (402:11): [True: 0, False: 1.16k]
  ------------------
  403|       |        // refuse to parse pathological inputs
  404|      0|        return result;
  405|      0|      }
  406|  1.16k|      exponent_adjustment -= static_cast<int>(zeros_skipped);
  407|  1.16k|    }
  408|  1.80k|    int post_decimal_digits = ConsumeDigits<base>(
  409|  1.80k|        begin, end, digits_left, &mantissa, &mantissa_is_inexact);
  410|  1.80k|    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.80k|    if (post_decimal_digits >= DigitLimit<base>()) {
  ------------------
  |  Branch (416:9): [True: 0, False: 1.80k]
  ------------------
  417|       |      // refuse to parse pathological inputs
  418|      0|      return result;
  419|  1.80k|    } else if (post_decimal_digits > digits_left) {
  ------------------
  |  Branch (419:16): [True: 552, False: 1.25k]
  ------------------
  420|    552|      exponent_adjustment -= digits_left;
  421|  1.25k|    } else {
  422|  1.25k|      exponent_adjustment -= post_decimal_digits;
  423|  1.25k|    }
  424|  1.80k|  }
  425|       |  // If we've found no mantissa whatsoever, this isn't a number.
  426|  4.92k|  if (mantissa_begin == begin) {
  ------------------
  |  Branch (426:7): [True: 9, False: 4.91k]
  ------------------
  427|      9|    return result;
  428|      9|  }
  429|       |  // A bare "." doesn't count as a mantissa either.
  430|  4.91k|  if (begin - mantissa_begin == 1 && *mantissa_begin == '.') {
  ------------------
  |  Branch (430:7): [True: 1.74k, False: 3.16k]
  |  Branch (430:38): [True: 18, False: 1.73k]
  ------------------
  431|     18|    return result;
  432|     18|  }
  433|       |
  434|  4.89k|  if (mantissa_is_inexact) {
  ------------------
  |  Branch (434:7): [True: 961, False: 3.93k]
  ------------------
  435|       |    // We dropped significant digits on the floor.  Handle this appropriately.
  436|    961|    if (base == 10) {
  ------------------
  |  Branch (436:9): [Folded, False: 961]
  ------------------
  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|    961|    } else if (base == 16) {
  ------------------
  |  Branch (441:16): [True: 961, 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|    961|      mantissa |= 1;
  445|    961|    }
  446|    961|  }
  447|  4.89k|  result.mantissa = mantissa;
  448|       |
  449|  4.89k|  const char* const exponent_begin = begin;
  450|  4.89k|  result.literal_exponent = 0;
  451|  4.89k|  bool found_exponent = false;
  452|  4.89k|  if (AllowExponent(format_flags) && begin < end &&
  ------------------
  |  Branch (452:7): [True: 4.89k, False: 0]
  |  Branch (452:38): [True: 1.69k, False: 3.20k]
  ------------------
  453|  1.69k|      IsExponentCharacter<base>(*begin)) {
  ------------------
  |  Branch (453:7): [True: 1.66k, False: 24]
  ------------------
  454|  1.66k|    bool negative_exponent = false;
  455|  1.66k|    ++begin;
  456|  1.66k|    if (begin < end && *begin == '-') {
  ------------------
  |  Branch (456:9): [True: 1.65k, False: 8]
  |  Branch (456:24): [True: 848, False: 811]
  ------------------
  457|    848|      negative_exponent = true;
  458|    848|      ++begin;
  459|    848|    } else if (begin < end && *begin == '+') {
  ------------------
  |  Branch (459:16): [True: 811, False: 8]
  |  Branch (459:31): [True: 251, False: 560]
  ------------------
  460|    251|      ++begin;
  461|    251|    }
  462|  1.66k|    const char* const exponent_digits_begin = begin;
  463|       |    // Exponent is always expressed in decimal, even for hexadecimal floats.
  464|  1.66k|    begin += ConsumeDigits<10>(begin, end, kDecimalExponentDigitsMax,
  465|  1.66k|                               &result.literal_exponent, nullptr);
  466|  1.66k|    if (begin == exponent_digits_begin) {
  ------------------
  |  Branch (466:9): [True: 21, False: 1.64k]
  ------------------
  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|     21|      found_exponent = false;
  470|     21|      begin = exponent_begin;
  471|  1.64k|    } else {
  472|  1.64k|      found_exponent = true;
  473|  1.64k|      if (negative_exponent) {
  ------------------
  |  Branch (473:11): [True: 847, False: 799]
  ------------------
  474|    847|        result.literal_exponent = -result.literal_exponent;
  475|    847|      }
  476|  1.64k|    }
  477|  1.66k|  }
  478|       |
  479|  4.89k|  if (!found_exponent && RequireExponent(format_flags)) {
  ------------------
  |  Branch (479:7): [True: 3.25k, False: 1.64k]
  |  Branch (479:26): [True: 0, False: 3.25k]
  ------------------
  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|  4.89k|  result.type = strings_internal::FloatType::kNumber;
  487|  4.89k|  if (result.mantissa > 0) {
  ------------------
  |  Branch (487:7): [True: 3.92k, False: 972]
  ------------------
  488|  3.92k|    result.exponent = result.literal_exponent +
  489|  3.92k|                      (DigitMagnitude<base>() * exponent_adjustment);
  490|  3.92k|  } else {
  491|    972|    result.exponent = 0;
  492|    972|  }
  493|  4.89k|  result.end = begin;
  494|  4.89k|  return result;
  495|  4.89k|}
charconv_parse.cc:_ZN4absl12lts_2026052612_GLOBAL__N_113AllowExponentENS0_12chars_formatE:
  122|  24.2k|bool AllowExponent(chars_format flags) {
  123|  24.2k|  bool fixed = (flags & chars_format::fixed) == chars_format::fixed;
  124|  24.2k|  bool scientific =
  125|  24.2k|      (flags & chars_format::scientific) == chars_format::scientific;
  126|  24.2k|  return scientific || !fixed;
  ------------------
  |  Branch (126:10): [True: 24.2k, False: 0]
  |  Branch (126:24): [True: 0, False: 0]
  ------------------
  127|  24.2k|}
charconv_parse.cc:_ZN4absl12lts_2026052612_GLOBAL__N_115RequireExponentENS0_12chars_formatE:
  130|  14.2k|bool RequireExponent(chars_format flags) {
  131|  14.2k|  bool fixed = (flags & chars_format::fixed) == chars_format::fixed;
  132|  14.2k|  bool scientific =
  133|  14.2k|      (flags & chars_format::scientific) == chars_format::scientific;
  134|  14.2k|  return scientific && !fixed;
  ------------------
  |  Branch (134:10): [True: 14.2k, False: 0]
  |  Branch (134:24): [True: 0, False: 14.2k]
  ------------------
  135|  14.2k|}
charconv_parse.cc:_ZN4absl12lts_2026052612_GLOBAL__N_119IsExponentCharacterILi10EEEbc:
  201|  8.53k|bool IsExponentCharacter<10>(char ch) {
  202|  8.53k|  return ch == 'e' || ch == 'E';
  ------------------
  |  Branch (202:10): [True: 6.56k, False: 1.96k]
  |  Branch (202:23): [True: 1.87k, False: 94]
  ------------------
  203|  8.53k|}
charconv_parse.cc:_ZN4absl12lts_2026052612_GLOBAL__N_119IsExponentCharacterILi16EEEbc:
  206|  1.69k|bool IsExponentCharacter<16>(char ch) {
  207|  1.69k|  return ch == 'p' || ch == 'P';
  ------------------
  |  Branch (207:10): [True: 885, False: 806]
  |  Branch (207:23): [True: 782, False: 24]
  ------------------
  208|  1.69k|}
charconv_parse.cc:_ZN4absl12lts_2026052612_GLOBAL__N_117MantissaDigitsMaxILi10EEEiv:
  211|  58.4k|constexpr int MantissaDigitsMax<10>() {
  212|  58.4k|  return kDecimalMantissaDigitsMax;
  213|  58.4k|}
charconv_parse.cc:_ZN4absl12lts_2026052612_GLOBAL__N_117MantissaDigitsMaxILi16EEEiv:
  215|  14.7k|constexpr int MantissaDigitsMax<16>() {
  216|  14.7k|  return kHexadecimalMantissaDigitsMax;
  217|  14.7k|}
charconv_parse.cc:_ZN4absl12lts_2026052612_GLOBAL__N_110DigitLimitILi10EEEiv:
  220|  32.3k|constexpr int DigitLimit<10>() {
  221|  32.3k|  return kDecimalDigitLimit;
  222|  32.3k|}
charconv_parse.cc:_ZN4absl12lts_2026052612_GLOBAL__N_110DigitLimitILi16EEEiv:
  224|  7.90k|constexpr int DigitLimit<16>() {
  225|  7.90k|  return kHexadecimalDigitLimit;
  226|  7.90k|}
charconv_parse.cc:_ZN4absl12lts_2026052612_GLOBAL__N_114DigitMagnitudeILi10EEEiv:
  229|  17.5k|constexpr int DigitMagnitude<10>() {
  230|  17.5k|  return 1;
  231|  17.5k|}
charconv_parse.cc:_ZN4absl12lts_2026052612_GLOBAL__N_114DigitMagnitudeILi16EEEiv:
  233|  3.92k|constexpr int DigitMagnitude<16>() {
  234|  3.92k|  return 4;
  235|  3.92k|}
charconv_parse.cc:_ZN4absl12lts_2026052612_GLOBAL__N_118ParseInfinityOrNanEPKcS3_PNS0_16strings_internal11ParsedFloatE:
  298|  25.5k|                        strings_internal::ParsedFloat* out) {
  299|  25.5k|  if (end - begin < 3) {
  ------------------
  |  Branch (299:7): [True: 4.26k, False: 21.2k]
  ------------------
  300|  4.26k|    return false;
  301|  4.26k|  }
  302|  21.2k|  switch (*begin) {
  303|    276|    case 'i':
  ------------------
  |  Branch (303:5): [True: 276, False: 20.9k]
  ------------------
  304|    470|    case 'I': {
  ------------------
  |  Branch (304:5): [True: 194, False: 21.0k]
  ------------------
  305|       |      // An infinity string consists of the characters "inf" or "infinity",
  306|       |      // case insensitive.
  307|    470|      if (strings_internal::memcasecmp(begin + 1, "nf", 2) != 0) {
  ------------------
  |  Branch (307:11): [True: 19, False: 451]
  ------------------
  308|     19|        return false;
  309|     19|      }
  310|    451|      out->type = strings_internal::FloatType::kInfinity;
  311|    451|      if (end - begin >= 8 &&
  ------------------
  |  Branch (311:11): [True: 29, False: 422]
  ------------------
  312|     29|          strings_internal::memcasecmp(begin + 3, "inity", 5) == 0) {
  ------------------
  |  Branch (312:11): [True: 1, False: 28]
  ------------------
  313|      1|        out->end = begin + 8;
  314|    450|      } else {
  315|    450|        out->end = begin + 3;
  316|    450|      }
  317|    451|      return true;
  318|    470|    }
  319|    261|    case 'n':
  ------------------
  |  Branch (319:5): [True: 261, False: 20.9k]
  ------------------
  320|    679|    case 'N': {
  ------------------
  |  Branch (320:5): [True: 418, False: 20.8k]
  ------------------
  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|    679|      if (strings_internal::memcasecmp(begin + 1, "an", 2) != 0) {
  ------------------
  |  Branch (324:11): [True: 15, False: 664]
  ------------------
  325|     15|        return false;
  326|     15|      }
  327|    664|      out->type = strings_internal::FloatType::kNan;
  328|    664|      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|    664|      begin += 3;
  332|    664|      if (begin < end && *begin == '(') {
  ------------------
  |  Branch (332:11): [True: 2, False: 662]
  |  Branch (332:26): [True: 0, False: 2]
  ------------------
  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|    664|      return true;
  345|    679|    }
  346|  20.1k|    default:
  ------------------
  |  Branch (346:5): [True: 20.1k, False: 1.14k]
  ------------------
  347|  20.1k|      return false;
  348|  21.2k|  }
  349|  21.2k|}
charconv_parse.cc:_ZN4absl12lts_2026052612_GLOBAL__N_113ConsumeDigitsILi10EmEEiPKcS4_iPT0_Pb:
  250|  27.5k|                  bool* dropped_nonzero_digit) {
  251|  27.5k|  if (base == 10) {
  ------------------
  |  Branch (251:7): [True: 27.5k, Folded]
  ------------------
  252|  27.5k|    assert(max_digits <= std::numeric_limits<T>::digits10);
  253|  27.5k|  } 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.5k|  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.5k|  while (!*out && end != begin && *begin == '0') ++begin;
  ------------------
  |  Branch (261:10): [True: 24.2k, False: 3.37k]
  |  Branch (261:19): [True: 22.9k, False: 1.26k]
  |  Branch (261:35): [True: 0, False: 22.9k]
  ------------------
  262|       |
  263|  27.5k|  T accumulator = *out;
  264|  27.5k|  const char* significant_digits_end =
  265|  27.5k|      (end - begin > max_digits) ? begin + max_digits : end;
  ------------------
  |  Branch (265:7): [True: 14.9k, False: 12.6k]
  ------------------
  266|   239k|  while (begin < significant_digits_end && IsDigit<base>(*begin)) {
  ------------------
  |  Branch (266:10): [True: 224k, False: 15.2k]
  |  Branch (266:44): [True: 212k, False: 12.2k]
  ------------------
  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|   212k|    auto digit = static_cast<T>(ToDigit<base>(*begin));
  270|   212k|    assert(accumulator * base >= accumulator);
  271|   212k|    accumulator *= base;
  272|   212k|    assert(accumulator + digit >= accumulator);
  273|   212k|    accumulator += digit;
  274|   212k|    ++begin;
  275|   212k|  }
  276|  27.5k|  bool dropped_nonzero = false;
  277|  8.90M|  while (begin < end && IsDigit<base>(*begin)) {
  ------------------
  |  Branch (277:10): [True: 8.89M, False: 10.8k]
  |  Branch (277:25): [True: 8.87M, False: 16.7k]
  ------------------
  278|  8.87M|    dropped_nonzero = dropped_nonzero || (*begin != '0');
  ------------------
  |  Branch (278:23): [True: 8.86M, False: 14.1k]
  |  Branch (278:42): [True: 10.5k, False: 3.67k]
  ------------------
  279|  8.87M|    ++begin;
  280|  8.87M|  }
  281|  27.5k|  if (dropped_nonzero && dropped_nonzero_digit != nullptr) {
  ------------------
  |  Branch (281:7): [True: 10.5k, False: 17.0k]
  |  Branch (281:26): [True: 10.5k, False: 0]
  ------------------
  282|  10.5k|    *dropped_nonzero_digit = true;
  283|  10.5k|  }
  284|  27.5k|  *out = accumulator;
  285|  27.5k|  return static_cast<int>(begin - original_begin);
  286|  27.5k|}
charconv_parse.cc:_ZN4absl12lts_2026052612_GLOBAL__N_17IsDigitILi10EEEbc:
  183|  16.9M|bool IsDigit<10>(char ch) {
  184|  16.9M|  return ch >= '0' && ch <= '9';
  ------------------
  |  Branch (184:10): [True: 16.8M, False: 14.7k]
  |  Branch (184:23): [True: 16.8M, False: 14.3k]
  ------------------
  185|  16.9M|}
charconv_parse.cc:_ZN4absl12lts_2026052612_GLOBAL__N_17ToDigitILi10EEEjc:
  192|   238k|unsigned ToDigit<10>(char ch) {
  193|   238k|  return static_cast<unsigned>(ch - '0');
  194|   238k|}
charconv_parse.cc:_ZN4absl12lts_2026052612_GLOBAL__N_113ConsumeDigitsILi10EiEEiPKcS4_iPT0_Pb:
  250|  10.1k|                  bool* dropped_nonzero_digit) {
  251|  10.1k|  if (base == 10) {
  ------------------
  |  Branch (251:7): [True: 10.1k, Folded]
  ------------------
  252|  10.1k|    assert(max_digits <= std::numeric_limits<T>::digits10);
  253|  10.1k|  } 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.1k|  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|  10.9k|  while (!*out && end != begin && *begin == '0') ++begin;
  ------------------
  |  Branch (261:10): [True: 10.9k, False: 0]
  |  Branch (261:19): [True: 10.2k, False: 703]
  |  Branch (261:35): [True: 867, False: 9.40k]
  ------------------
  262|       |
  263|  10.1k|  T accumulator = *out;
  264|  10.1k|  const char* significant_digits_end =
  265|  10.1k|      (end - begin > max_digits) ? begin + max_digits : end;
  ------------------
  |  Branch (265:7): [True: 382, False: 9.72k]
  ------------------
  266|  36.5k|  while (begin < significant_digits_end && IsDigit<base>(*begin)) {
  ------------------
  |  Branch (266:10): [True: 26.5k, False: 10.0k]
  |  Branch (266:44): [True: 26.4k, False: 50]
  ------------------
  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|  26.4k|    auto digit = static_cast<T>(ToDigit<base>(*begin));
  270|  26.4k|    assert(accumulator * base >= accumulator);
  271|  26.4k|    accumulator *= base;
  272|  26.4k|    assert(accumulator + digit >= accumulator);
  273|  26.4k|    accumulator += digit;
  274|  26.4k|    ++begin;
  275|  26.4k|  }
  276|  10.1k|  bool dropped_nonzero = false;
  277|  7.76M|  while (begin < end && IsDigit<base>(*begin)) {
  ------------------
  |  Branch (277:10): [True: 7.75M, False: 10.0k]
  |  Branch (277:25): [True: 7.75M, False: 53]
  ------------------
  278|  7.75M|    dropped_nonzero = dropped_nonzero || (*begin != '0');
  ------------------
  |  Branch (278:23): [True: 7.75M, False: 381]
  |  Branch (278:42): [True: 360, False: 21]
  ------------------
  279|  7.75M|    ++begin;
  280|  7.75M|  }
  281|  10.1k|  if (dropped_nonzero && dropped_nonzero_digit != nullptr) {
  ------------------
  |  Branch (281:7): [True: 360, False: 9.74k]
  |  Branch (281:26): [True: 0, False: 360]
  ------------------
  282|      0|    *dropped_nonzero_digit = true;
  283|      0|  }
  284|  10.1k|  *out = accumulator;
  285|  10.1k|  return static_cast<int>(begin - original_begin);
  286|  10.1k|}
charconv_parse.cc:_ZN4absl12lts_2026052612_GLOBAL__N_113ConsumeDigitsILi16EmEEiPKcS4_iPT0_Pb:
  250|  6.73k|                  bool* dropped_nonzero_digit) {
  251|  6.73k|  if (base == 10) {
  ------------------
  |  Branch (251:7): [Folded, False: 6.73k]
  ------------------
  252|      0|    assert(max_digits <= std::numeric_limits<T>::digits10);
  253|  6.73k|  } else if (base == 16) {
  ------------------
  |  Branch (253:14): [True: 6.73k, Folded]
  ------------------
  254|  6.73k|    assert(max_digits * 4 <= std::numeric_limits<T>::digits);
  255|  6.73k|  }
  256|  6.73k|  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.73k|  while (!*out && end != begin && *begin == '0') ++begin;
  ------------------
  |  Branch (261:10): [True: 6.09k, False: 638]
  |  Branch (261:19): [True: 5.44k, False: 650]
  |  Branch (261:35): [True: 0, False: 5.44k]
  ------------------
  262|       |
  263|  6.73k|  T accumulator = *out;
  264|  6.73k|  const char* significant_digits_end =
  265|  6.73k|      (end - begin > max_digits) ? begin + max_digits : end;
  ------------------
  |  Branch (265:7): [True: 1.70k, False: 5.02k]
  ------------------
  266|  35.6k|  while (begin < significant_digits_end && IsDigit<base>(*begin)) {
  ------------------
  |  Branch (266:10): [True: 31.9k, False: 3.70k]
  |  Branch (266:44): [True: 28.9k, False: 3.02k]
  ------------------
  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|  28.9k|    auto digit = static_cast<T>(ToDigit<base>(*begin));
  270|  28.9k|    assert(accumulator * base >= accumulator);
  271|  28.9k|    accumulator *= base;
  272|  28.9k|    assert(accumulator + digit >= accumulator);
  273|  28.9k|    accumulator += digit;
  274|  28.9k|    ++begin;
  275|  28.9k|  }
  276|  6.73k|  bool dropped_nonzero = false;
  277|  12.5M|  while (begin < end && IsDigit<base>(*begin)) {
  ------------------
  |  Branch (277:10): [True: 12.5M, False: 3.21k]
  |  Branch (277:25): [True: 12.5M, False: 3.51k]
  ------------------
  278|  12.5M|    dropped_nonzero = dropped_nonzero || (*begin != '0');
  ------------------
  |  Branch (278:23): [True: 12.5M, False: 1.63k]
  |  Branch (278:42): [True: 1.08k, False: 549]
  ------------------
  279|  12.5M|    ++begin;
  280|  12.5M|  }
  281|  6.73k|  if (dropped_nonzero && dropped_nonzero_digit != nullptr) {
  ------------------
  |  Branch (281:7): [True: 1.08k, False: 5.64k]
  |  Branch (281:26): [True: 1.08k, False: 0]
  ------------------
  282|  1.08k|    *dropped_nonzero_digit = true;
  283|  1.08k|  }
  284|  6.73k|  *out = accumulator;
  285|  6.73k|  return static_cast<int>(begin - original_begin);
  286|  6.73k|}
charconv_parse.cc:_ZN4absl12lts_2026052612_GLOBAL__N_17IsDigitILi16EEEbc:
  187|  12.5M|bool IsDigit<16>(char ch) {
  188|  12.5M|  return kAsciiToInt[static_cast<unsigned char>(ch)] >= 0;
  189|  12.5M|}
charconv_parse.cc:_ZN4absl12lts_2026052612_GLOBAL__N_17ToDigitILi16EEEjc:
  196|  28.9k|unsigned ToDigit<16>(char ch) {
  197|  28.9k|  return static_cast<unsigned>(kAsciiToInt[static_cast<unsigned char>(ch)]);
  198|  28.9k|}

_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.17k|int memcasecmp(const char* s1, const char* s2, size_t len) {
   26|  1.17k|  const unsigned char* us1 = reinterpret_cast<const unsigned char*>(s1);
   27|  1.17k|  const unsigned char* us2 = reinterpret_cast<const unsigned char*>(s2);
   28|       |
   29|  3.46k|  for (size_t i = 0; i < len; i++) {
  ------------------
  |  Branch (29:22): [True: 2.34k, False: 1.11k]
  ------------------
   30|  2.34k|    unsigned char c1 = us1[i];
   31|  2.34k|    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.34k|    if (c1 != c2) {
  ------------------
  |  Branch (36:9): [True: 687, False: 1.65k]
  ------------------
   37|    687|      c1 = c1 >= 'A' && c1 <= 'Z' ? c1 - 'A' + 'a' : c1;
  ------------------
  |  Branch (37:12): [True: 670, False: 17]
  |  Branch (37:25): [True: 644, False: 26]
  ------------------
   38|    687|      c2 = c2 >= 'A' && c2 <= 'Z' ? c2 - 'A' + 'a' : c2;
  ------------------
  |  Branch (38:12): [True: 687, False: 0]
  |  Branch (38:25): [True: 0, False: 687]
  ------------------
   39|    687|      const int diff = int{c1} - int{c2};
   40|    687|      if (diff != 0) return diff;
  ------------------
  |  Branch (40:11): [True: 62, False: 625]
  ------------------
   41|    687|    }
   42|  2.34k|  }
   43|  1.11k|  return 0;
   44|  1.17k|}

_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.5k|bool SimpleAtod(absl::string_view str, double* absl_nonnull out) {
   87|  25.5k|  *out = 0.0;
   88|  25.5k|  str = StripAsciiWhitespace(str);
   89|  25.5k|  if (str.empty()) {
  ------------------
  |  Branch (89:7): [True: 18, False: 25.5k]
  ------------------
   90|       |    // absl::from_chars doesn't accept empty strings.
   91|     18|    return false;
   92|     18|  }
   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.5k|  if (str[0] == '+') {
  ------------------
  |  Branch (95:7): [True: 211, False: 25.3k]
  ------------------
   96|    211|    str.remove_prefix(1);
   97|    211|    if (str.empty() || str[0] == '-') {
  ------------------
  |  Branch (97:9): [True: 1, False: 210]
  |  Branch (97:24): [True: 1, False: 209]
  ------------------
   98|      2|      return false;
   99|      2|    }
  100|    211|  }
  101|  25.5k|  auto result = absl::from_chars(str.data(), str.data() + str.size(), *out);
  102|  25.5k|  if (result.ec == std::errc::invalid_argument) {
  ------------------
  |  Branch (102:7): [True: 101, False: 25.4k]
  ------------------
  103|    101|    return false;
  104|    101|  }
  105|  25.4k|  if (result.ptr != str.data() + str.size()) {
  ------------------
  |  Branch (105:7): [True: 266, False: 25.1k]
  ------------------
  106|       |    // not all non-whitespace characters consumed
  107|    266|    return false;
  108|    266|  }
  109|       |  // from_chars() with DR 3081's current wording will return max() on
  110|       |  // overflow.  SimpleAtod returns infinity instead.
  111|  25.1k|  if (result.ec == std::errc::result_out_of_range) {
  ------------------
  |  Branch (111:7): [True: 3.98k, False: 21.1k]
  ------------------
  112|  3.98k|    if (*out > 1.0) {
  ------------------
  |  Branch (112:9): [True: 2.34k, False: 1.63k]
  ------------------
  113|  2.34k|      *out = std::numeric_limits<double>::infinity();
  114|  2.34k|    } else if (*out < -1.0) {
  ------------------
  |  Branch (114:16): [True: 365, False: 1.27k]
  ------------------
  115|    365|      *out = -std::numeric_limits<double>::infinity();
  116|    365|    }
  117|  3.98k|  }
  118|  25.1k|  return true;
  119|  25.4k|}
_ZN4absl12lts_2026052616numbers_internal18safe_strtou64_baseENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPmi:
 1625|  1.40k|                        int base) {
 1626|  1.40k|  return safe_uint_internal<uint64_t>(text, value, base);
 1627|  1.40k|}
numbers.cc:_ZN4absl12lts_2026052612_GLOBAL__N_124safe_parse_sign_and_baseEPNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPiPb:
 1168|  1.40k|    bool* absl_nonnull negative_ptr /*output*/) {
 1169|  1.40k|  if (text->data() == nullptr) {
  ------------------
  |  Branch (1169:7): [True: 0, False: 1.40k]
  ------------------
 1170|      0|    return false;
 1171|      0|  }
 1172|       |
 1173|  1.40k|  const char* start = text->data();
 1174|  1.40k|  const char* end = start + text->size();
 1175|  1.40k|  int base = *base_ptr;
 1176|       |
 1177|       |  // Consume whitespace.
 1178|  1.40k|  while (start < end &&
  ------------------
  |  Branch (1178:10): [True: 1.39k, False: 12]
  ------------------
 1179|  1.39k|         absl::ascii_isspace(static_cast<unsigned char>(start[0]))) {
  ------------------
  |  Branch (1179:10): [True: 0, False: 1.39k]
  ------------------
 1180|      0|    ++start;
 1181|      0|  }
 1182|  1.59k|  while (start < end &&
  ------------------
  |  Branch (1182:10): [True: 1.58k, False: 12]
  ------------------
 1183|  1.58k|         absl::ascii_isspace(static_cast<unsigned char>(end[-1]))) {
  ------------------
  |  Branch (1183:10): [True: 194, False: 1.39k]
  ------------------
 1184|    194|    --end;
 1185|    194|  }
 1186|  1.40k|  if (start >= end) {
  ------------------
  |  Branch (1186:7): [True: 12, False: 1.39k]
  ------------------
 1187|     12|    return false;
 1188|     12|  }
 1189|       |
 1190|       |  // Consume sign.
 1191|  1.39k|  *negative_ptr = (start[0] == '-');
 1192|  1.39k|  if (*negative_ptr || start[0] == '+') {
  ------------------
  |  Branch (1192:7): [True: 3, False: 1.39k]
  |  Branch (1192:24): [True: 216, False: 1.17k]
  ------------------
 1193|    219|    ++start;
 1194|    219|    if (start >= end) {
  ------------------
  |  Branch (1194:9): [True: 2, False: 217]
  ------------------
 1195|      2|      return false;
 1196|      2|    }
 1197|    219|  }
 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|  1.39k|  if (base == 0) {
  ------------------
  |  Branch (1203:7): [True: 0, False: 1.39k]
  ------------------
 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|  1.39k|  } else if (base == 16) {
  ------------------
  |  Branch (1218:14): [True: 0, False: 1.39k]
  ------------------
 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|  1.39k|  } else if (base >= 2 && base <= 36) {
  ------------------
  |  Branch (1227:14): [True: 1.39k, False: 0]
  |  Branch (1227:27): [True: 1.39k, False: 0]
  ------------------
 1228|       |    // okay
 1229|  1.39k|  } else {
 1230|      0|    return false;
 1231|      0|  }
 1232|  1.39k|  *text = absl::string_view(start, static_cast<size_t>(end - start));
 1233|  1.39k|  *base_ptr = base;
 1234|  1.39k|  return true;
 1235|  1.39k|}
numbers.cc:_ZN4absl12lts_2026052612_GLOBAL__N_118safe_uint_internalImEEbNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPT_i:
 1550|  1.40k|                               IntType* absl_nonnull value_p, int base) {
 1551|  1.40k|  *value_p = 0;
 1552|  1.40k|  bool negative;
 1553|  1.40k|  if (!safe_parse_sign_and_base(&text, &base, &negative) || negative) {
  ------------------
  |  Branch (1553:7): [True: 14, False: 1.39k]
  |  Branch (1553:61): [True: 2, False: 1.38k]
  ------------------
 1554|     16|    return false;
 1555|     16|  }
 1556|  1.38k|  return safe_parse_positive_int(text, base, value_p);
 1557|  1.40k|}
numbers.cc:_ZN4absl12lts_2026052612_GLOBAL__N_123safe_parse_positive_intImEEbNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEiPT_:
 1453|  1.38k|                                    IntType* absl_nonnull value_p) {
 1454|  1.38k|  IntType value = 0;
 1455|  1.38k|  const IntType vmax = std::numeric_limits<IntType>::max();
 1456|  1.38k|  assert(vmax > 0);
 1457|  1.38k|  assert(base >= 0);
 1458|  1.38k|  const IntType base_inttype = static_cast<IntType>(base);
 1459|  1.38k|  assert(vmax >= base_inttype);
 1460|  1.38k|  const IntType vmax_over_base = LookupTables<IntType>::kVmaxOverBase[base];
 1461|  1.38k|  assert(base < 2 ||
 1462|  1.38k|         std::numeric_limits<IntType>::max() / base_inttype == vmax_over_base);
 1463|  1.38k|  const char* start = text.data();
 1464|  1.38k|  const char* end = start + text.size();
 1465|       |  // loop over digits
 1466|  5.38k|  for (; start < end; ++start) {
  ------------------
  |  Branch (1466:10): [True: 4.10k, False: 1.27k]
  ------------------
 1467|  4.10k|    unsigned char c = static_cast<unsigned char>(start[0]);
 1468|  4.10k|    IntType digit = static_cast<IntType>(kAsciiToInt[c]);
 1469|  4.10k|    if (digit >= base_inttype) {
  ------------------
  |  Branch (1469:9): [True: 44, False: 4.06k]
  ------------------
 1470|     44|      *value_p = value;
 1471|     44|      return false;
 1472|     44|    }
 1473|  4.06k|    if (value > vmax_over_base) {
  ------------------
  |  Branch (1473:9): [True: 69, False: 3.99k]
  ------------------
 1474|     69|      *value_p = vmax;
 1475|     69|      return false;
 1476|     69|    }
 1477|  3.99k|    value *= base_inttype;
 1478|  3.99k|    if (value > vmax - digit) {
  ------------------
  |  Branch (1478:9): [True: 1, False: 3.99k]
  ------------------
 1479|      1|      *value_p = vmax;
 1480|      1|      return false;
 1481|      1|    }
 1482|  3.99k|    value += digit;
 1483|  3.99k|  }
 1484|  1.27k|  *value_p = value;
 1485|  1.27k|  return true;
 1486|  1.38k|}

_ZN4absl12lts_2026052616numbers_internal16safe_strtoi_baseImEEbNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPT_i:
  247|  1.40k|                                    int_type* absl_nonnull out, int base) {
  248|  1.40k|  static_assert(sizeof(*out) == 1 || sizeof(*out) == 2 || sizeof(*out) == 4 ||
  249|  1.40k|                    sizeof(*out) == 8,
  250|  1.40k|                "SimpleAtoi works only with 8, 16, 32, or 64-bit integers.");
  251|  1.40k|  static_assert(!std::is_floating_point<int_type>::value,
  252|  1.40k|                "Use SimpleAtof or SimpleAtod instead.");
  253|  1.40k|  bool parsed;
  254|       |  // These conditions are constexpr bools to suppress MSVC warning C4127.
  255|  1.40k|  constexpr bool kIsSigned = is_signed<int_type>();
  256|  1.40k|  constexpr int kIntTypeSize = sizeof(*out) * 8;
  257|  1.40k|  if (kIsSigned) {
  ------------------
  |  Branch (257:7): [Folded, False: 1.40k]
  ------------------
  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|  1.40k|  } else {
  276|  1.40k|    if (kIntTypeSize == 64) {
  ------------------
  |  Branch (276:9): [True: 1.40k, Folded]
  ------------------
  277|  1.40k|      uint64_t val;
  278|  1.40k|      parsed = numbers_internal::safe_strtou64_base(s, &val, base);
  279|  1.40k|      *out = static_cast<int_type>(val);
  280|  1.40k|    } 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|  1.40k|  }
  294|  1.40k|  return parsed;
  295|  1.40k|}
_ZN4absl12lts_2026052610SimpleAtoiImEEbNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPT_:
  330|  1.40k|                              int_type* absl_nonnull out) {
  331|  1.40k|  return numbers_internal::safe_strtoi_base(str, out, 10);
  332|  1.40k|}

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

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

clock.cc:_ZN4absl12lts_2026052613time_internalL29GetCurrentTimeNanosFromSystemEv:
   13|  15.1k|static int64_t GetCurrentTimeNanosFromSystem() {
   14|  15.1k|  const int64_t kNanosPerSecond = 1000 * 1000 * 1000;
   15|  15.1k|  struct timespec ts;
   16|  15.1k|  ABSL_RAW_CHECK(clock_gettime(CLOCK_REALTIME, &ts) == 0,
  ------------------
  |  |   60|  15.1k|  do {                                                                 \
  |  |   61|  15.1k|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  190|  15.1k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 15.1k]
  |  |  |  |  |  Branch (190:49): [Folded, False: 15.1k]
  |  |  |  |  |  Branch (190:58): [True: 0, False: 15.1k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   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|  15.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 15.1k]
  |  |  ------------------
  ------------------
   17|  15.1k|                 "Failed to read real-time clock.");
   18|  15.1k|  return (int64_t{ts.tv_sec} * kNanosPerSecond +
   19|  15.1k|          int64_t{ts.tv_nsec});
   20|  15.1k|}

_ZN4absl12lts_202605268DurationC2Ev:
  186|  10.1k|  constexpr Duration() : rep_hi_(0), rep_lo_(0) {}  // zero-length duration
_ZN4absl12lts_202605268DurationC2Elj:
  248|  23.5k|  constexpr Duration(int64_t hi, uint32_t lo) : rep_hi_(hi), rep_lo_(lo) {}
_ZN4absl12lts_202605268Duration5HiRepC2El:
  268|  33.6k|          lo_(0),
  269|  33.6k|          hi_(0)
  270|       |#endif
  271|  33.6k|    {
  272|  33.6k|      *this = value;
  273|  33.6k|    }
_ZNK4absl12lts_202605268Duration5HiRep3GetEv:
  275|  87.5k|    constexpr int64_t Get() const {
  276|  87.5k|      const uint64_t unsigned_value =
  277|  87.5k|          (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|  87.5k|      static_assert(
  285|  87.5k|          (static_cast<int64_t>((std::numeric_limits<uint64_t>::max)()) ==
  286|  87.5k|           int64_t{-1}) &&
  287|  87.5k|              (static_cast<int64_t>(static_cast<uint64_t>(
  288|  87.5k|                                        (std::numeric_limits<int64_t>::max)()) +
  289|  87.5k|                                    1) ==
  290|  87.5k|               (std::numeric_limits<int64_t>::min)()),
  291|  87.5k|          "static_cast<int64_t>(uint64_t) does not have c++20 semantics");
  292|  87.5k|      return static_cast<int64_t>(unsigned_value);
  293|  87.5k|    }
_ZN4absl12lts_202605268Duration5HiRepaSEl:
  295|  43.7k|    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|  43.7k|      const auto unsigned_value = static_cast<uint64_t>(value);
  301|  43.7k|      hi_ = static_cast<uint32_t>(unsigned_value >> 32);
  302|  43.7k|      lo_ = static_cast<uint32_t>(unsigned_value);
  303|  43.7k|      return *this;
  304|  43.7k|    }
_ZN4absl12lts_202605264TimeC2ENS0_8DurationE:
  878|  23.5k|  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|  10.1k|                                                       Duration rhs) {
  338|  10.1k|  return rhs < lhs;
  339|  10.1k|}
_ZN4absl12lts_20260526leENS0_8DurationES1_:
  345|      8|                                                        Duration rhs) {
  346|      8|  return !(rhs < lhs);
  347|      8|}
_ZN4absl12lts_20260526miENS0_8DurationES1_:
  362|  10.1k|                                                        Duration rhs) {
  363|  10.1k|  return lhs -= rhs;
  364|  10.1k|}
_ZN4absl12lts_2026052612ZeroDurationEv:
  438|  10.1k|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr Duration ZeroDuration() {
  439|  10.1k|  return Duration();
  440|  10.1k|}
_ZN4absl12lts_20260526eqENS0_4TimeES1_:
  904|  8.35k|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr bool operator==(Time lhs, Time rhs) {
  905|  8.35k|  return lhs.rep_ == rhs.rep_;
  906|  8.35k|}
_ZN4absl12lts_20260526neENS0_4TimeES1_:
  907|  8.35k|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr bool operator!=(Time lhs, Time rhs) {
  908|  8.35k|  return !(lhs == rhs);
  909|  8.35k|}
_ZN4absl12lts_20260526miENS0_4TimeES1_:
  921|  10.1k|ABSL_ATTRIBUTE_CONST_FUNCTION inline Duration operator-(Time lhs, Time rhs) {
  922|  10.1k|  return lhs.rep_ - rhs.rep_;
  923|  10.1k|}
_ZN4absl12lts_2026052614InfiniteFutureEv:
  944|  8.36k|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr Time InfiniteFuture() {
  945|  8.36k|  return Time(time_internal::MakeDuration((std::numeric_limits<int64_t>::max)(),
  946|  8.36k|                                          ~uint32_t{0}));
  947|  8.36k|}
_ZN4absl12lts_2026052613time_internal12MakeDurationElj:
 1598|  23.5k|                                                              uint32_t lo = 0) {
 1599|  23.5k|  return Duration(hi, lo);
 1600|  23.5k|}
_ZN4absl12lts_2026052613time_internal12MakeDurationEll:
 1603|  15.1k|                                                              int64_t lo) {
 1604|  15.1k|  return MakeDuration(hi, static_cast<uint32_t>(lo));
 1605|  15.1k|}
_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|  36.9k|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr int64_t GetRepHi(Duration d) {
 1631|  36.9k|  return d.rep_hi_.Get();
 1632|  36.9k|}
_ZN4absl12lts_2026052613time_internal8GetRepLoENS0_8DurationE:
 1633|  36.9k|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr uint32_t GetRepLo(Duration d) {
 1634|  36.9k|  return d.rep_lo_;
 1635|  36.9k|}
_ZN4absl12lts_2026052613time_internal18IsInfiniteDurationENS0_8DurationE:
 1638|  20.2k|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr bool IsInfiniteDuration(Duration d) {
 1639|  20.2k|  return GetRepLo(d) == ~uint32_t{0};
 1640|  20.2k|}
_ZN4absl12lts_2026052613time_internal16FromUnixDurationENS0_8DurationE:
 1663|  15.1k|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr Time FromUnixDuration(Duration d) {
 1664|  15.1k|  return Time(d);
 1665|  15.1k|}
_ZN4absl12lts_20260526ltENS0_8DurationES1_:
 1760|  10.1k|                                                       Duration rhs) {
 1761|  10.1k|  return time_internal::GetRepHi(lhs) != time_internal::GetRepHi(rhs)
  ------------------
  |  Branch (1761:10): [True: 10.1k, False: 6]
  ------------------
 1762|  10.1k|             ? time_internal::GetRepHi(lhs) < time_internal::GetRepHi(rhs)
 1763|  10.1k|         : 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|  10.1k|}
_ZN4absl12lts_20260526eqENS0_8DurationES1_:
 1788|  8.36k|                                                        Duration rhs) {
 1789|  8.36k|  return time_internal::GetRepHi(lhs) == time_internal::GetRepHi(rhs) &&
  ------------------
  |  Branch (1789:10): [True: 8.36k, False: 0]
  ------------------
 1790|  8.36k|         time_internal::GetRepLo(lhs) == time_internal::GetRepLo(rhs);
  ------------------
  |  Branch (1790:10): [True: 8.36k, False: 0]
  ------------------
 1791|  8.36k|}
_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|  5.20k|    -> decltype(GetDataImpl(c, 0)) {
   51|  5.20k|  return GetDataImpl(c, 0);
   52|  5.20k|}
_ZN4absl12lts_2026052613span_internal11GetDataImplIKNSt3__16vectorIN8fuzztest8internal6no_adl8IRObjectENS3_9allocatorIS8_EEEEEEDTcldtfp_4dataEERT_c:
   38|  5.20k|    -> decltype(c.data()) {
   39|  5.20k|  return c.data();
   40|  5.20k|}
_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.30k|      const char* absl_nonnull file_name = __builtin_FILE()) {
  114|  3.30k|    return SourceLocation(line, file_name);
  115|  3.30k|  }
_ZN4absl12lts_2026052614SourceLocationC2EjPKc:
  151|  3.30k|      : line_(line), file_name_(file_name) {}
_ZNK4absl12lts_2026052614SourceLocation9file_nameEv:
  133|  3.30k|  constexpr const char* absl_nonnull file_name() const noexcept {
  134|  3.30k|    return file_name_;
  135|  3.30k|  }

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

_ZN8fuzztest8internal25SetExternalEngineCallbackEPNS0_22ExternalEngineCallbackE:
   33|      2|void SetExternalEngineCallback(ExternalEngineCallback* callback) {
   34|      2|  external_engine_callback = callback;
   35|      2|}
_ZN8fuzztest8internal25GetExternalEngineCallbackEv:
   37|  8.36k|ExternalEngineCallback* GetExternalEngineCallback() {
   38|  8.36k|  return external_engine_callback;
   39|  8.36k|}
_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|  8.35k|void FuzzTestExternalEngineAdaptor::RunOneInputData(absl::string_view data) {
  110|  8.35k|  auto& impl = GetFuzzerImpl();
  111|  8.35k|  if (impl.ShouldStop()) {
  ------------------
  |  Branch (111:7): [True: 0, False: 8.35k]
  ------------------
  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|  8.35k|  if (data.size() == 0) return;
  ------------------
  |  Branch (116:7): [True: 0, False: 8.35k]
  ------------------
  117|  8.35k|  auto input = impl.TryParse(data);
  118|  8.35k|  if (!input.ok()) return;
  ------------------
  |  Branch (118:7): [True: 3.30k, False: 5.05k]
  ------------------
  119|  5.05k|  impl.RunOneInput({*std::move(input)});
  120|  5.05k|}
_ZN8fuzztest8internal29FuzzTestExternalEngineAdaptor13GetFuzzerImplEv:
  151|  8.36k|FuzzTestExternalEngineAdaptor::GetFuzzerImpl() {
  152|       |  // Postpone the creation to override libFuzzer signal setup.
  153|  8.36k|  if (!fuzzer_impl_) {
  ------------------
  |  Branch (153:7): [True: 2, False: 8.35k]
  ------------------
  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|  8.36k|  return *fuzzer_impl_;
  159|  8.36k|}
compatibility_mode.cc:_ZZN8fuzztest8internal29FuzzTestExternalEngineAdaptor16RunInFuzzingModeEPiPPPcRKNS0_13ConfigurationEENK3$_1clEv:
   81|  5.05k|  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|  8.35k|        argc, argv, [](const uint8_t* data, size_t size) -> int {
   90|  8.35k|          GetExternalEngineCallback()->RunOneInputData(
   91|  8.35k|              absl::string_view(reinterpret_cast<const char*>(data), size));
   92|  8.35k|          return 0;
   93|  8.35k|        });

_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|  5.05k|  absl::Status ValidateCorpusValue(const corpus_type& corpus_value) const {
  174|  5.05k|    absl::Status result = absl::OkStatus();
  175|  5.05k|    ApplyIndex<sizeof...(Inner)>([&](auto... I) {
  176|  5.05k|      (
  177|  5.05k|          [&] {
  178|  5.05k|            if (!result.ok()) return;
  179|  5.05k|            const absl::Status s = std::get<I>(inner_).ValidateCorpusValue(
  180|  5.05k|                std::get<I>(corpus_value));
  181|  5.05k|            result = Prefix(s, "Invalid value in aggregate");
  182|  5.05k|          }(),
  183|  5.05k|          ...);
  184|  5.05k|    });
  185|  5.05k|    return result;
  186|  5.05k|  }
_ZZNK8fuzztest8internal15AggregateOfImplINSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplIS9_NS0_13ArbitraryImplIcvEEEEEE19ValidateCorpusValueERKSA_ENKUlDpT_E_clIJNS2_17integral_constantImLm0EEEEEEDaSK_:
  175|  5.05k|    ApplyIndex<sizeof...(Inner)>([&](auto... I) {
  176|  5.05k|      (
  177|  5.05k|          [&] {
  178|  5.05k|            if (!result.ok()) return;
  179|  5.05k|            const absl::Status s = std::get<I>(inner_).ValidateCorpusValue(
  180|  5.05k|                std::get<I>(corpus_value));
  181|  5.05k|            result = Prefix(s, "Invalid value in aggregate");
  182|  5.05k|          }(),
  183|  5.05k|          ...);
  184|  5.05k|    });
_ZZZNK8fuzztest8internal15AggregateOfImplINSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplIS9_NS0_13ArbitraryImplIcvEEEEEE19ValidateCorpusValueERKSA_ENKUlDpT_E_clIJNS2_17integral_constantImLm0EEEEEEDaSK_ENKUlvE_clEv:
  177|  5.05k|          [&] {
  178|  5.05k|            if (!result.ok()) return;
  ------------------
  |  Branch (178:17): [True: 0, False: 5.05k]
  ------------------
  179|  5.05k|            const absl::Status s = std::get<I>(inner_).ValidateCorpusValue(
  180|  5.05k|                std::get<I>(corpus_value));
  181|  5.05k|            result = Prefix(s, "Invalid value in aggregate");
  182|  5.05k|          }(),
_ZNK8fuzztest8internal15AggregateOfImplINSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplIS9_NS0_13ArbitraryImplIcvEEEEEE11ParseCorpusERKNS0_6no_adl8IRObjectE:
  157|  6.97k|  std::optional<corpus_type> ParseCorpus(const IRObject& obj) const {
  158|       |    if constexpr (has_custom_corpus_type) {
  159|       |      return ParseWithDomainTuple(inner_, obj);
  160|  6.97k|    } else {
  161|  6.97k|      return obj.ToCorpus<corpus_type>();
  162|  6.97k|    }
  163|  6.97k|  }
_ZNK8fuzztest8internal15AggregateOfImplINSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplIS9_NS0_13ArbitraryImplIcvEEEEEE8GetValueERKSA_:
  115|  5.05k|  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|  5.05k|    } else {
  132|  5.05k|      return value;
  133|  5.05k|    }
  134|  5.05k|  }
_ZN8fuzztest8internal15AggregateOfImplINSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplIS9_NS0_13ArbitraryImplIcvEEEEEEC2ENS2_10in_place_tESF_:
   58|      2|      : inner_(std::move(inner)...) {}

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

_ZNK8fuzztest8internal19ContainerOfImplBaseINS0_23SequenceContainerOfImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_13ArbitraryImplIcvEEEES9_SB_E19ValidateCorpusValueERKS9_:
  339|  5.05k|  absl::Status ValidateCorpusValue(const corpus_type& corpus_value) const {
  340|       |    // Check size.
  341|  5.05k|    if (corpus_value.size() < min_size()) {
  ------------------
  |  Branch (341:9): [True: 0, False: 5.05k]
  ------------------
  342|      0|      return absl::InvalidArgumentError(absl::StrCat(
  343|      0|          "Invalid size: ", corpus_value.size(), ". Min size: ", min_size()));
  344|      0|    }
  345|  5.05k|    if (validate_max_size() && corpus_value.size() > max_size()) {
  ------------------
  |  Branch (345:9): [True: 5.05k, False: 0]
  |  Branch (345:32): [True: 0, False: 5.05k]
  ------------------
  346|      0|      return absl::InvalidArgumentError(absl::StrCat(
  347|      0|          "Invalid size: ", corpus_value.size(), ". Max size: ", max_size()));
  348|      0|    }
  349|       |    // Check elements.
  350|  5.05k|    int i = 0;
  351|  25.4M|    for (const auto& elem : corpus_value) {
  ------------------
  |  Branch (351:27): [True: 25.4M, False: 5.05k]
  ------------------
  352|  25.4M|      const absl::Status s = inner_.ValidateCorpusValue(elem);
  353|  25.4M|      if (!s.ok()) {
  ------------------
  |  Branch (353:11): [True: 0, False: 25.4M]
  ------------------
  354|      0|        return Prefix(s,
  355|      0|                      absl::StrCat("Invalid value in container at index ", i));
  356|      0|      }
  357|  25.4M|      i++;
  358|  25.4M|    }
  359|  5.05k|    return absl::OkStatus();
  360|  5.05k|  }
_ZNK8fuzztest8internal19ContainerOfImplBaseINS0_23SequenceContainerOfImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_13ArbitraryImplIcvEEEES9_SB_E8min_sizeEv:
  394|  5.05k|  size_t min_size() const { return min_size_; }
_ZNK8fuzztest8internal19ContainerOfImplBaseINS0_23SequenceContainerOfImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_13ArbitraryImplIcvEEEES9_SB_E17validate_max_sizeEv:
  398|  5.05k|  bool validate_max_size() const { return validate_max_size_; }
_ZNK8fuzztest8internal19ContainerOfImplBaseINS0_23SequenceContainerOfImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_13ArbitraryImplIcvEEEES9_SB_E8max_sizeEv:
  395|  5.05k|  size_t max_size() const {
  396|  5.05k|    return max_size_.value_or(std::max(min_size_, kDefaultContainerMaxSize));
  397|  5.05k|  }
_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|  5.05k|  value_type GetValue(const corpus_type& corpus_value) const {
  348|  5.05k|    return inner_->UntypedGetValue(corpus_value);
  349|  5.05k|  }
_ZNK8fuzztest13UntypedDomain11ParseCorpusERKNS_8internal6no_adl8IRObjectE:
  351|  6.97k|  std::optional<corpus_type> ParseCorpus(const internal::IRObject& obj) const {
  352|  6.97k|    return inner_->UntypedParseCorpus(obj);
  353|  6.97k|  }
_ZNK8fuzztest13UntypedDomain19ValidateCorpusValueERKNS_8internal11CopyableAnyE:
  359|  5.05k|  absl::Status ValidateCorpusValue(const corpus_type& corpus_value) const {
  360|  5.05k|    return inner_->UntypedValidateCorpusValue(corpus_value);
  361|  5.05k|  }

_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|  6.97k|      const IRObject& obj) const final {
  181|  6.97k|    if (auto res = domain_.ParseCorpus(obj)) {
  ------------------
  |  Branch (181:14): [True: 5.05k, False: 1.91k]
  ------------------
  182|  5.05k|      return GenericDomainCorpusType(std::in_place_type<CorpusType>,
  183|  5.05k|                                     *std::move(res));
  184|  5.05k|    } else {
  185|  1.91k|      return std::nullopt;
  186|  1.91k|    }
  187|  6.97k|  }
_ZNK8fuzztest8internal11DomainModelINS0_15AggregateOfImplINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplISA_NS0_13ArbitraryImplIcvEEEEEEEE26UntypedValidateCorpusValueERKNS0_11CopyableAnyE:
  195|  5.05k|      const GenericDomainCorpusType& corpus_value) const final {
  196|  5.05k|    return domain_.ValidateCorpusValue(corpus_value.GetAs<CorpusType>());
  197|  5.05k|  }
_ZNK8fuzztest8internal18TypedDomainConceptINSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEE15UntypedGetValueERKNS0_11CopyableAnyE:
  115|  5.05k|      const GenericDomainCorpusType& v) const final {
  116|  5.05k|    return GenericDomainValueType(std::in_place_type<ValueType>,
  117|  5.05k|                                  TypedGetValue(v));
  118|  5.05k|  }
_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|  5.05k|  ValueType TypedGetValue(const GenericDomainCorpusType& v) const final {
  160|  5.05k|    return domain_.GetValue(v.GetAs<CorpusType>());
  161|  5.05k|  }

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

_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|  5.05k|  void Test(MoveOnlyAny&& args_untyped) const override {
  322|  5.05k|    std::apply(
  323|  5.05k|        [&](auto&&... args) {
  324|  5.05k|          target_function_(ForceVectorForStringView<Args>(std::move(args))...);
  325|  5.05k|        },
  326|  5.05k|        args_untyped.GetAs<value_type_t<DomainT>>());
  327|  5.05k|  }
_ZZNK8fuzztest8internal13FixtureDriverINS_6DomainINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEENS0_9NoFixtureEPFvNS3_17basic_string_viewIcS7_EEEPvE4TestEONS0_11MoveOnlyAnyEENKUlDpOT_E_clIJRSA_EEEDaSO_:
  323|  5.05k|        [&](auto&&... args) {
  324|  5.05k|          target_function_(ForceVectorForStringView<Args>(std::move(args))...);
  325|  5.05k|        },
_ZN8fuzztest8internal24ForceVectorForStringViewINSt3__117basic_string_viewIcNS2_11char_traitsIcEEEENS2_12basic_stringIcS5_NS2_9allocatorIcEEEEEEDcOT0_:
  212|  5.05k|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|  5.05k|                               void(std::string_view, std::string)>) {
  217|  5.05k|    return ForceVector{std::vector<char>(src.begin(), src.end())};
  218|       |  } else {
  219|       |    return std::forward<Src>(src);
  220|       |  }
  221|  5.05k|}
_ZNK8fuzztest8internal11ForceVectorcvNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEEv:
  207|  5.05k|  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|      6|  for (const auto* test : GetRegisteredTests()) {
  ------------------
  |  Branch (30:25): [True: 6, False: 2]
  ------------------
   31|      6|    if (!test->should_run()) continue;
  ------------------
  |  Branch (31:9): [True: 4, 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|      8|    for (int j = 0; j < unit_test.GetTestSuite(i)->total_test_count(); ++j) {
  ------------------
  |  Branch (190:21): [True: 6, False: 2]
  ------------------
  191|      6|      result.push_back(unit_test.GetTestSuite(i)->GetTestInfo(j));
  192|      6|    }
  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|  5.05k|constexpr auto ApplyIndex(F f) {
   55|  5.05k|  return ApplyIndexImpl(f, std::make_index_sequence<N>{});
   56|  5.05k|}
_ZN8fuzztest8internal14ApplyIndexImplIJLm0EEZNKS0_15AggregateOfImplINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplISA_NS0_13ArbitraryImplIcvEEEEEE19ValidateCorpusValueERKSB_EUlDpT_E_EEDaT0_NS3_16integer_sequenceImJXspT_EEEE:
   39|  5.05k|constexpr auto ApplyIndexImpl(F f, std::index_sequence<I...>) {
   40|  5.05k|  return f(std::integral_constant<size_t, I>{}...);
   41|  5.05k|}
_ZN8fuzztest8internal10ApplyIndexILm1EZNKS0_6no_adl8IRObject8ToCorpusINSt3__15tupleIJNS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEEEEEENS5_8optionalIT_EEvEUlDpT_E_EEDaT0_:
   54|  5.07k|constexpr auto ApplyIndex(F f) {
   55|  5.07k|  return ApplyIndexImpl(f, std::make_index_sequence<N>{});
   56|  5.07k|}
_ZN8fuzztest8internal14ApplyIndexImplIJLm0EEZNKS0_6no_adl8IRObject8ToCorpusINSt3__15tupleIJNS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEEEEEENS5_8optionalIT_EEvEUlDpT_E_EEDaT0_NS5_16integer_sequenceImJXspT_EEEE:
   39|  5.07k|constexpr auto ApplyIndexImpl(F f, std::index_sequence<I...>) {
   40|  5.07k|  return f(std::integral_constant<size_t, I>{}...);
   41|  5.07k|}
_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|  15.1k|void Runtime::Spinlock::Lock() {
  435|  15.1k|  while (locked_.test_and_set(std::memory_order_acq_rel)) {
  ------------------
  |  Branch (435:10): [True: 0, False: 15.1k]
  ------------------
  436|      0|    std::this_thread::yield();
  437|      0|  }
  438|  15.1k|}
_ZN8fuzztest8internal7Runtime8Spinlock6UnlockEv:
  440|  15.1k|void Runtime::Spinlock::Unlock() { locked_.clear(std::memory_order_release); }
_ZN8fuzztest8internal7Runtime19CheckWatchdogLimitsEv:
  453|  5.05k|void Runtime::CheckWatchdogLimits() {
  454|       |  // Centipede runner has its own watchdog.
  455|  5.05k|#ifndef FUZZTEST_USE_CENTIPEDE
  456|  5.05k|  watchdog_spinlock_.Lock();
  457|  5.05k|  if (current_configuration_ == nullptr || !test_iteration_started_ ||
  ------------------
  |  Branch (457:7): [True: 0, False: 5.05k]
  |  Branch (457:44): [True: 0, False: 5.05k]
  ------------------
  458|  5.05k|      watchdog_limit_exceeded_) {
  ------------------
  |  Branch (458:7): [True: 0, False: 5.05k]
  ------------------
  459|      0|    watchdog_spinlock_.Unlock();
  460|      0|    return;
  461|      0|  }
  462|  5.05k|  const absl::Duration run_duration =
  463|  5.05k|      clock_fn_() - current_iteration_start_time_;
  464|  5.05k|  if (current_configuration_->time_limit_per_input > absl::ZeroDuration() &&
  ------------------
  |  Branch (464:7): [True: 5.05k, False: 0]
  ------------------
  465|  5.05k|      run_duration > current_configuration_->time_limit_per_input) {
  ------------------
  |  Branch (465:7): [True: 0, False: 5.05k]
  ------------------
  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|  5.05k|  const size_t rss_usage = GetPeakRSSBytes();
  475|  5.05k|  if (current_configuration_->rss_limit > 0 &&
  ------------------
  |  Branch (475:7): [True: 0, False: 5.05k]
  ------------------
  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|  5.05k|  watchdog_spinlock_.Unlock();
  485|  5.05k|#endif  // FUZZTEST_USE_CENTIPEDE
  486|  5.05k|}
_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|  5.05k|void Runtime::OnTestIterationStart(const absl::Time& start_time) {
  508|  5.05k|  watchdog_spinlock_.Lock();
  509|  5.05k|  current_iteration_start_time_ = start_time;
  510|  5.05k|  test_iteration_started_ = true;
  511|  5.05k|  watchdog_spinlock_.Unlock();
  512|  5.05k|}
_ZN8fuzztest8internal7Runtime18OnTestIterationEndEv:
  514|  5.05k|void Runtime::OnTestIterationEnd() {
  515|  5.05k|  CheckWatchdogLimits();
  516|  5.05k|  watchdog_spinlock_.Lock();
  517|  5.05k|  test_iteration_started_ = false;
  518|  5.05k|  watchdog_spinlock_.Unlock();
  519|  5.05k|}
_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|  8.35k|    absl::string_view data) {
  721|  8.35k|  auto ir_value = ParseIRObject(data);
  722|  8.35k|  if (!ir_value) {
  ------------------
  |  Branch (722:7): [True: 1.38k, False: 6.97k]
  ------------------
  723|  1.38k|    return absl::InvalidArgumentError("Unexpected file format");
  724|  1.38k|  }
  725|  6.97k|  auto corpus_value = params_domain_.ParseCorpus(*ir_value);
  726|  6.97k|  if (!corpus_value) {
  ------------------
  |  Branch (726:7): [True: 1.91k, False: 5.05k]
  ------------------
  727|  1.91k|    return absl::InvalidArgumentError("Unexpected intermediate representation");
  728|  1.91k|  }
  729|  5.05k|  absl::Status is_valid = params_domain_.ValidateCorpusValue(*corpus_value);
  730|  5.05k|  if (!is_valid.ok()) {
  ------------------
  |  Branch (730:7): [True: 0, False: 5.05k]
  ------------------
  731|      0|    return Prefix(is_valid, "Invalid corpus value");
  732|      0|  }
  733|  5.05k|  return *corpus_value;
  734|  5.05k|}
_ZN8fuzztest8internal18FuzzTestFuzzerImpl10ShouldStopEv:
 1010|  8.35k|bool FuzzTestFuzzerImpl::ShouldStop() {
 1011|  8.35k|  if (runs_limit_.has_value() && stats_.runs >= *runs_limit_) return true;
  ------------------
  |  Branch (1011:7): [True: 0, False: 8.35k]
  |  Branch (1011:34): [True: 0, False: 0]
  ------------------
 1012|  8.35k|  if (time_limit_ != absl::InfiniteFuture() && absl::Now() > time_limit_)
  ------------------
  |  Branch (1012:7): [True: 0, False: 8.35k]
  |  Branch (1012:48): [True: 0, False: 0]
  ------------------
 1013|      0|    return true;
 1014|  8.35k|  return runtime_.termination_requested();
 1015|  8.35k|}
_ZN8fuzztest8internal18FuzzTestFuzzerImpl11RunOneInputERKNS1_5InputE:
 1128|  5.05k|    const Input& input) {
 1129|  5.05k|  ++stats_.runs;
 1130|  5.05k|  auto untyped_args = params_domain_.GetValue(input.args);
 1131|  5.05k|  Runtime::Args debug_args{input.args, params_domain_};
 1132|  5.05k|  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|  5.05k|  if (execution_coverage_ != nullptr) {
  ------------------
  |  Branch (1137:7): [True: 0, False: 5.05k]
  ------------------
 1138|      0|    execution_coverage_->ResetState();
 1139|      0|  }
 1140|  5.05k|  absl::Time start = absl::Now();
 1141|  5.05k|  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|  5.05k|  if (execution_coverage_ != nullptr) {
  ------------------
  |  Branch (1145:7): [True: 0, False: 5.05k]
  ------------------
 1146|      0|    execution_coverage_->SetIsTracing(true);
 1147|      0|  }
 1148|       |
 1149|  5.05k|  runtime_.SetSkippingRequested(false);
 1150|  5.05k|  fixture_driver_->RunFuzzTestIteration([&] {
 1151|  5.05k|    if (!runtime_.skipping_requested()) {
 1152|  5.05k|      fixture_driver_->Test(std::move(untyped_args));
 1153|  5.05k|    }
 1154|  5.05k|  });
 1155|  5.05k|  if (execution_coverage_ != nullptr) {
  ------------------
  |  Branch (1155:7): [True: 0, False: 5.05k]
  ------------------
 1156|      0|    execution_coverage_->SetIsTracing(false);
 1157|      0|  }
 1158|  5.05k|  const absl::Duration run_time = absl::Now() - start;
 1159|       |
 1160|  5.05k|  bool new_coverage = false;
 1161|  5.05k|  if (execution_coverage_ != nullptr && !runtime_.skipping_requested()) {
  ------------------
  |  Branch (1161:7): [True: 0, False: 5.05k]
  |  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|  5.05k|  runtime_.OnTestIterationEnd();
 1168|  5.05k|  runtime_.UnsetCurrentArgs();
 1169|  5.05k|  return {new_coverage, run_time};
 1170|  5.05k|}
runtime.cc:_ZN8fuzztest8internalL15GetPeakRSSBytesEv:
  442|  5.05k|static size_t GetPeakRSSBytes() {
  443|       |#ifndef FUZZTEST_HAS_RUSAGE
  444|       |  return 0;
  445|       |#else
  446|  5.05k|  struct rusage usage = {};
  447|  5.05k|  if (getrusage(RUSAGE_SELF, &usage) != 0) return 0;
  ------------------
  |  Branch (447:7): [True: 0, False: 5.05k]
  ------------------
  448|       |  // On Linux, ru_maxrss is in KiB
  449|  5.05k|  return usage.ru_maxrss * 1024;
  450|  5.05k|#endif
  451|  5.05k|}
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|  5.05k|  fixture_driver_->RunFuzzTestIteration([&] {
 1151|  5.05k|    if (!runtime_.skipping_requested()) {
  ------------------
  |  Branch (1151:9): [True: 5.05k, False: 0]
  ------------------
 1152|  5.05k|      fixture_driver_->Test(std::move(untyped_args));
 1153|  5.05k|    }
 1154|  5.05k|  });

_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|  5.05k|  void SetSkippingRequested(bool requested) {
  140|  5.05k|    skipping_requested_.store(requested, std::memory_order_relaxed);
  141|  5.05k|  }
_ZNK8fuzztest8internal7Runtime18skipping_requestedEv:
  143|  5.05k|  bool skipping_requested() const {
  144|  5.05k|    return skipping_requested_.load(std::memory_order_relaxed);
  145|  5.05k|  }
_ZNK8fuzztest8internal7Runtime21termination_requestedEv:
  159|  8.35k|  bool termination_requested() const {
  160|  8.35k|    return termination_requested_.load(std::memory_order_relaxed);
  161|  8.35k|  }
_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|  5.05k|  void SetCurrentArgs(Args* args) { current_args_ = args; }
_ZN8fuzztest8internal7Runtime16UnsetCurrentArgsEv:
  194|  5.05k|  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|  8.35k|std::optional<IRObject> ParseIRObject(absl::string_view str) {
  329|  8.35k|  IRObject object;
  330|  8.35k|  if (IsInBinaryFormat(str)) {
  ------------------
  |  Branch (330:7): [True: 5.04k, False: 3.31k]
  ------------------
  331|  5.04k|    BinaryParseBuf buf = {str.data(), str.size()};
  332|  5.04k|    buf.Advance(kBinaryHeader.size());
  333|  5.04k|    if (!BinaryParse(object, buf, /*recursion_depth=*/0) || !buf.empty())
  ------------------
  |  Branch (333:9): [True: 26, False: 5.01k]
  |  Branch (333:61): [True: 1, False: 5.01k]
  ------------------
  334|     27|      return std::nullopt;
  335|  5.04k|  } else {
  336|  3.31k|    if (ReadToken(str) != kHeader) return std::nullopt;
  ------------------
  |  Branch (336:9): [True: 85, False: 3.23k]
  ------------------
  337|  3.23k|    if (!ParseImpl(object, str, /*recursion_depth=*/0) ||
  ------------------
  |  Branch (337:9): [True: 1.14k, False: 2.09k]
  |  Branch (337:9): [True: 1.27k, False: 1.96k]
  ------------------
  338|  2.09k|        !ReadToken(str).empty())
  ------------------
  |  Branch (338:9): [True: 132, False: 1.96k]
  ------------------
  339|  1.27k|      return std::nullopt;
  340|  3.23k|  }
  341|  6.97k|  return object;
  342|  8.35k|}
serialization.cc:_ZN8fuzztest8internal12_GLOBAL__N_116IsInBinaryFormatENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
  299|  8.35k|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|  8.35k|  return str.size() >= kBinaryHeader.size() &&
  ------------------
  |  Branch (302:10): [True: 8.29k, False: 62]
  ------------------
  303|  8.29k|         __builtin_memcmp(str.data(), kBinaryHeader.data(),
  ------------------
  |  Branch (303:10): [True: 5.04k, False: 3.25k]
  ------------------
  304|  8.29k|                          kBinaryHeader.size()) == 0;
  305|  8.35k|}
serialization.cc:_ZN8fuzztest8internal12_GLOBAL__N_114BinaryParseBuf7AdvanceEm:
  239|  35.6k|  void Advance(size_t s) {
  240|  35.6k|    if (s > size) s = size;
  ------------------
  |  Branch (240:9): [True: 0, False: 35.6k]
  ------------------
  241|  35.6k|    str += s;
  242|  35.6k|    size -= s;
  243|  35.6k|  }
serialization.cc:_ZN8fuzztest8internal12_GLOBAL__N_111BinaryParseERNS0_6no_adl8IRObjectERNS1_14BinaryParseBufEi:
  246|  13.5k|bool BinaryParse(IRObject& obj, BinaryParseBuf& buf, int recursion_depth) {
  247|  13.5k|  if (recursion_depth > kMaxParseRecursionDepth) return false;
  ------------------
  |  Branch (247:7): [True: 0, False: 13.5k]
  ------------------
  248|  13.5k|  if (buf.empty()) return false;
  ------------------
  |  Branch (248:7): [True: 0, False: 13.5k]
  ------------------
  249|  13.5k|  const auto h = static_cast<BinaryFormatHeader>(buf.str[0]);
  250|  13.5k|  buf.Advance(1);
  251|  13.5k|  switch (h) {
  ------------------
  |  Branch (251:11): [True: 13.5k, False: 19]
  ------------------
  252|  1.59k|    case BinaryFormatHeader::kEmpty: {
  ------------------
  |  Branch (252:5): [True: 1.59k, False: 11.9k]
  ------------------
  253|  1.59k|      return true;
  254|      0|    }
  255|    940|    case BinaryFormatHeader::kUInt64: {
  ------------------
  |  Branch (255:5): [True: 940, False: 12.6k]
  ------------------
  256|    940|      if (buf.size < sizeof(uint64_t)) return false;
  ------------------
  |  Branch (256:11): [True: 1, False: 939]
  ------------------
  257|    939|      auto& t = obj.MutableScalar<uint64_t>();
  258|    939|      std::memcpy(&t, buf.str, sizeof(uint64_t));
  259|    939|      buf.Advance(sizeof(uint64_t));
  260|    939|      return true;
  261|    940|    }
  262|      1|    case BinaryFormatHeader::kDouble: {
  ------------------
  |  Branch (262:5): [True: 1, False: 13.5k]
  ------------------
  263|      1|      if (buf.size < sizeof(double)) return false;
  ------------------
  |  Branch (263:11): [True: 0, False: 1]
  ------------------
  264|      1|      auto& t = obj.MutableScalar<double>();
  265|      1|      std::memcpy(&t, buf.str, sizeof(t));
  266|      1|      buf.Advance(sizeof(double));
  267|      1|      return true;
  268|      1|    }
  269|  5.01k|    case BinaryFormatHeader::kString: {
  ------------------
  |  Branch (269:5): [True: 5.01k, False: 8.57k]
  ------------------
  270|  5.01k|      if (buf.size < sizeof(uint64_t)) return false;
  ------------------
  |  Branch (270:11): [True: 0, False: 5.01k]
  ------------------
  271|  5.01k|      uint64_t str_size;
  272|  5.01k|      std::memcpy(&str_size, buf.str, sizeof(str_size));
  273|  5.01k|      buf.Advance(sizeof(uint64_t));
  274|  5.01k|      if (buf.size < str_size) return false;
  ------------------
  |  Branch (274:11): [True: 2, False: 5.01k]
  ------------------
  275|  5.01k|      obj.MutableScalar<std::string>() = {buf.str,
  276|  5.01k|                                          static_cast<size_t>(str_size)};
  277|  5.01k|      buf.Advance(str_size);
  278|  5.01k|      return true;
  279|  5.01k|    }
  280|  6.02k|    case BinaryFormatHeader::kObject: {
  ------------------
  |  Branch (280:5): [True: 6.02k, False: 7.56k]
  ------------------
  281|  6.02k|      if (buf.size < sizeof(uint64_t)) return false;
  ------------------
  |  Branch (281:11): [True: 3, False: 6.01k]
  ------------------
  282|  6.01k|      uint64_t vec_size;
  283|  6.01k|      std::memcpy(&vec_size, buf.str, sizeof(vec_size));
  284|  6.01k|      buf.Advance(sizeof(vec_size));
  285|       |      // This could happen for malformed inputs.
  286|  6.01k|      if (vec_size > buf.size) return false;
  ------------------
  |  Branch (286:11): [True: 1, False: 6.01k]
  ------------------
  287|  6.01k|      auto& v = obj.MutableSubs();
  288|  6.01k|      v.reserve(vec_size);
  289|  14.2k|      for (uint64_t i = 0; i < vec_size; ++i) {
  ------------------
  |  Branch (289:28): [True: 8.54k, False: 5.74k]
  ------------------
  290|  8.54k|        if (!BinaryParse(v.emplace_back(), buf, recursion_depth + 1))
  ------------------
  |  Branch (290:13): [True: 272, False: 8.27k]
  ------------------
  291|    272|          return false;
  292|  8.54k|      }
  293|  5.74k|      return true;
  294|  6.01k|    }
  295|  13.5k|  }
  296|     19|  return false;
  297|  13.5k|}
serialization.cc:_ZNK8fuzztest8internal12_GLOBAL__N_114BinaryParseBuf5emptyEv:
  238|  18.6k|  bool empty() const { return size == 0; }
serialization.cc:_ZN8fuzztest8internal12_GLOBAL__N_19ReadTokenERNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
   76|   169k|absl::string_view ReadToken(absl::string_view& in) {
   77|   199k|  while (!in.empty() && std::isspace(in[0])) in.remove_prefix(1);
  ------------------
  |  Branch (77:10): [True: 196k, False: 2.75k]
  |  Branch (77:25): [True: 29.6k, False: 167k]
  ------------------
   78|   169k|  if (in.empty()) return in;
  ------------------
  |  Branch (78:7): [True: 2.75k, False: 167k]
  ------------------
   79|   167k|  size_t end = 1;
   80|   167k|  const auto is_literal = [](char c) {
   81|   167k|    return std::isalnum(c) != 0 || c == '+' || c == '-' || c == '.';
   82|   167k|  };
   83|   167k|  if (is_literal(in[0])) {
  ------------------
  |  Branch (83:7): [True: 85.6k, False: 81.5k]
  ------------------
   84|  38.9M|    while (end < in.size() && is_literal(in[end])) ++end;
  ------------------
  |  Branch (84:12): [True: 38.9M, False: 2.70k]
  |  Branch (84:31): [True: 38.8M, False: 82.9k]
  ------------------
   85|  85.6k|  } else if (in[0] == '"') {
  ------------------
  |  Branch (85:14): [True: 498, False: 81.0k]
  ------------------
   86|  1.26M|    while (end < in.size() && in[end] != '"') ++end;
  ------------------
  |  Branch (86:12): [True: 1.26M, False: 18]
  |  Branch (86:31): [True: 1.25M, False: 480]
  ------------------
   87|    498|    if (end < in.size()) ++end;
  ------------------
  |  Branch (87:9): [True: 480, False: 18]
  ------------------
   88|    498|  }
   89|   167k|  absl::string_view res = in.substr(0, end);
   90|   167k|  in.remove_prefix(end);
   91|   167k|  return res;
   92|   169k|}
serialization.cc:_ZZN8fuzztest8internal12_GLOBAL__N_19ReadTokenERNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEENK3$_0clEc:
   80|  39.1M|  const auto is_literal = [](char c) {
   81|  39.1M|    return std::isalnum(c) != 0 || c == '+' || c == '-' || c == '.';
  ------------------
  |  Branch (81:12): [True: 38.9M, False: 210k]
  |  Branch (81:36): [True: 1.04k, False: 209k]
  |  Branch (81:48): [True: 35.2k, False: 174k]
  |  Branch (81:60): [True: 9.97k, False: 164k]
  ------------------
   82|  39.1M|  };
serialization.cc:_ZN8fuzztest8internal12_GLOBAL__N_19ParseImplERNS0_6no_adl8IRObjectERNSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEi:
  134|  31.0k|bool ParseImpl(IRObject& obj, absl::string_view& str, int recursion_depth) {
  135|  31.0k|  if (recursion_depth > kMaxParseRecursionDepth) return false;
  ------------------
  |  Branch (135:7): [True: 0, False: 31.0k]
  ------------------
  136|  31.0k|  absl::string_view key = ReadToken(str);
  137|  31.0k|  if (key.empty() || key == "}") {
  ------------------
  |  Branch (137:7): [True: 29, False: 30.9k]
  |  Branch (137:22): [True: 404, False: 30.5k]
  ------------------
  138|       |    // The object is empty. Put the token back and return.
  139|    433|    str = absl::string_view(key.data(), str.data() + str.size() - key.data());
  140|    433|    return true;
  141|    433|  }
  142|       |
  143|  30.5k|  if (key == "sub") {
  ------------------
  |  Branch (143:7): [True: 3.12k, False: 27.4k]
  ------------------
  144|  3.12k|    auto& v = obj.MutableSubs();
  145|  27.8k|    do {
  146|  27.8k|      if (ReadToken(str) != "{") return false;
  ------------------
  |  Branch (146:11): [True: 47, False: 27.7k]
  ------------------
  147|  27.7k|      if (!ParseImpl(v.emplace_back(), str, recursion_depth + 1)) return false;
  ------------------
  |  Branch (147:11): [True: 2.12k, False: 25.6k]
  ------------------
  148|  25.6k|      if (ReadToken(str) != "}") return false;
  ------------------
  |  Branch (148:11): [True: 546, False: 25.1k]
  ------------------
  149|  25.1k|      key = ReadToken(str);
  150|  25.1k|    } while (key == "sub");
  ------------------
  |  Branch (150:14): [True: 24.7k, False: 410]
  ------------------
  151|       |    // We are done reading this repeated sub.
  152|       |    // Put the token back for the caller.
  153|    410|    str = absl::string_view(key.data(), str.data() + str.size() - key.data());
  154|    410|    return true;
  155|  27.4k|  } else {
  156|  27.4k|    if (ReadToken(str) != ":") return false;
  ------------------
  |  Branch (156:9): [True: 22, False: 27.4k]
  ------------------
  157|  27.4k|    auto value = ReadToken(str);
  158|  27.4k|    if (key == "i") {
  ------------------
  |  Branch (158:9): [True: 1.40k, False: 26.0k]
  ------------------
  159|  1.40k|      return ReadScalar(obj.MutableScalar<uint64_t>(), value);
  160|  26.0k|    } else if (key == "d") {
  ------------------
  |  Branch (160:16): [True: 25.5k, False: 488]
  ------------------
  161|  25.5k|      return ReadScalar(obj.MutableScalar<double>(), value);
  162|  25.5k|    } else if (key == "s") {
  ------------------
  |  Branch (162:16): [True: 485, False: 3]
  ------------------
  163|    485|      return ReadScalar(obj.MutableScalar<std::string>(), value);
  164|    485|    } else {
  165|       |      // Unrecognized key
  166|      3|      return false;
  167|      3|    }
  168|  27.4k|  }
  169|  30.5k|}
serialization.cc:_ZN8fuzztest8internal12_GLOBAL__N_110ReadScalarERmNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   94|  1.40k|bool ReadScalar(uint64_t& out, absl::string_view value) {
   95|  1.40k|  return absl::SimpleAtoi(value, &out);
   96|  1.40k|}
serialization.cc:_ZN8fuzztest8internal12_GLOBAL__N_110ReadScalarERdNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   98|  25.5k|bool ReadScalar(double& out, absl::string_view value) {
   99|  25.5k|  return absl::SimpleAtod(value, &out);
  100|  25.5k|}
serialization.cc:_ZN8fuzztest8internal12_GLOBAL__N_110ReadScalarERNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS2_17basic_string_viewIcS5_EE:
  102|    485|bool ReadScalar(std::string& out, absl::string_view value) {
  103|    485|  if (value.empty() || value[0] != '"') return false;
  ------------------
  |  Branch (103:7): [True: 5, False: 480]
  |  Branch (103:24): [True: 0, False: 480]
  ------------------
  104|    480|  value.remove_prefix(1);
  105|       |
  106|    480|  if (value.empty() || value.back() != '"') return false;
  ------------------
  |  Branch (106:7): [True: 0, False: 480]
  |  Branch (106:24): [True: 0, False: 480]
  ------------------
  107|    480|  value.remove_suffix(1);
  108|       |
  109|  1.25M|  while (!value.empty()) {
  ------------------
  |  Branch (109:10): [True: 1.25M, False: 480]
  ------------------
  110|  1.25M|    if (value[0] != '\\') {
  ------------------
  |  Branch (110:9): [True: 1.25M, False: 0]
  ------------------
  111|  1.25M|      out += value[0];
  112|  1.25M|      value.remove_prefix(1);
  113|  1.25M|    } 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|  1.25M|  }
  129|    480|  return true;
  130|    480|}

_ZNK8fuzztest8internal6no_adl8IRObject8ToCorpusINSt3__15tupleIJNS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEEEENS4_8optionalIT_EEv:
  245|  6.97k|  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|  6.97k|    } else {
  305|       |      // Must be a tuple like object.
  306|  6.97k|      auto elems = Subs();
  307|  6.97k|      if (!elems || elems->size() != std::tuple_size_v<T>) return std::nullopt;
  ------------------
  |  Branch (307:11): [True: 1.77k, False: 5.20k]
  |  Branch (307:21): [True: 130, False: 5.07k]
  ------------------
  308|  5.07k|      auto it = elems->begin();
  309|  5.07k|      auto parts = ApplyIndex<std::tuple_size_v<T>>([&](auto... I) {
  310|  5.07k|        return std::tuple{it++->ToCorpus<std::tuple_element_t<I, T>>()...};
  311|  5.07k|      });
  312|  5.07k|      return std::apply(
  313|  5.07k|          [&](auto&... part) -> std::optional<T> {
  314|  5.07k|            if ((!part || ...)) return std::nullopt;
  315|  5.07k|            return T{*std::move(part)...};
  316|  5.07k|          },
  317|  5.07k|          parts);
  318|  6.97k|    }
  319|  6.97k|  }
_ZNK8fuzztest8internal6no_adl8IRObject4SubsEv:
  152|  6.97k|  std::optional<absl::Span<const IRObject>> Subs() const {
  153|  6.97k|    if (const auto* i = std::get_if<std::vector<IRObject>>(&value_)) {
  ------------------
  |  Branch (153:21): [True: 5.20k, False: 1.77k]
  ------------------
  154|  5.20k|      return *i;
  155|  5.20k|    }
  156|       |    // The empty vector is serialized the same way as the monostate: nothing.
  157|       |    // Handle that case too.
  158|  1.77k|    if (std::holds_alternative<std::monostate>(value_)) {
  ------------------
  |  Branch (158:9): [True: 2, False: 1.77k]
  ------------------
  159|      2|      return absl::Span<const IRObject>{};
  160|      2|    }
  161|  1.77k|    return std::nullopt;
  162|  1.77k|  }
_ZZNK8fuzztest8internal6no_adl8IRObject8ToCorpusINSt3__15tupleIJNS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEEEENS4_8optionalIT_EEvENKUlDpT_E_clIJNS4_17integral_constantImLm0EEEEEEDaSH_:
  309|  5.07k|      auto parts = ApplyIndex<std::tuple_size_v<T>>([&](auto... I) {
  310|  5.07k|        return std::tuple{it++->ToCorpus<std::tuple_element_t<I, T>>()...};
  311|  5.07k|      });
_ZNK8fuzztest8internal6no_adl8IRObject8ToCorpusINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEENS4_8optionalIT_EEv:
  245|  5.07k|  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|  5.07k|    } else if constexpr (std::is_constructible_v<IRObject, T>) {
  254|  5.07k|      if (auto v = GetScalar<T>()) {
  ------------------
  |  Branch (254:16): [True: 5.05k, False: 17]
  ------------------
  255|  5.05k|        return static_cast<T>(*v);
  256|  5.05k|      }
  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|  5.07k|  }
_ZNK8fuzztest8internal6no_adl8IRObject9GetScalarINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEDav:
   99|  5.07k|  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|  5.07k|    } else if constexpr (std::is_same_v<std::string, T>) {
  111|  5.07k|      std::optional<absl::string_view> out;
  112|  5.07k|      if (const auto* s = std::get_if<std::string>(&value_)) {
  ------------------
  |  Branch (112:23): [True: 5.05k, False: 17]
  ------------------
  113|  5.05k|        out = *s;
  114|  5.05k|      }
  115|  5.07k|      return out;
  116|  5.07k|    }
  117|  5.07k|  }
_ZZNK8fuzztest8internal6no_adl8IRObject8ToCorpusINSt3__15tupleIJNS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEEEENS4_8optionalIT_EEvENKUlDpRT_E_clIJNSD_ISB_EEEEENSD_ISC_EESI_:
  313|  5.07k|          [&](auto&... part) -> std::optional<T> {
  314|  5.07k|            if ((!part || ...)) return std::nullopt;
  ------------------
  |  Branch (314:18): [True: 17, False: 5.05k]
  ------------------
  315|  5.05k|            return T{*std::move(part)...};
  316|  5.07k|          },
_ZN8fuzztest8internal6no_adl8IRObjectC2Ev:
   75|  44.6k|  IRObject() = default;
_ZN8fuzztest8internal6no_adl8IRObject11MutableSubsEv:
  167|  9.14k|  std::vector<IRObject>& MutableSubs() {
  168|  9.14k|    if (!std::holds_alternative<std::vector<IRObject>>(value_)) {
  ------------------
  |  Branch (168:9): [True: 9.14k, False: 0]
  ------------------
  169|  9.14k|      value_.emplace<std::vector<IRObject>>();
  170|  9.14k|    }
  171|  9.14k|    return std::get<std::vector<IRObject>>(value_);
  172|  9.14k|  }
_ZN8fuzztest8internal6no_adl8IRObject13MutableScalarImEERDav:
  141|  2.34k|  auto& MutableScalar() {
  142|       |    if constexpr (is_monostate_v<T>) {
  143|       |      static_assert(always_false<T>, "Invalid type");
  144|       |    }
  145|  2.34k|    if (!std::holds_alternative<T>(value_)) {
  ------------------
  |  Branch (145:9): [True: 2.34k, False: 0]
  ------------------
  146|  2.34k|      value_.emplace<T>();
  147|  2.34k|    }
  148|  2.34k|    return std::get<T>(value_);
  149|  2.34k|  }
_ZN8fuzztest8internal6no_adl8IRObject13MutableScalarIdEERDav:
  141|  25.5k|  auto& MutableScalar() {
  142|       |    if constexpr (is_monostate_v<T>) {
  143|       |      static_assert(always_false<T>, "Invalid type");
  144|       |    }
  145|  25.5k|    if (!std::holds_alternative<T>(value_)) {
  ------------------
  |  Branch (145:9): [True: 25.5k, False: 0]
  ------------------
  146|  25.5k|      value_.emplace<T>();
  147|  25.5k|    }
  148|  25.5k|    return std::get<T>(value_);
  149|  25.5k|  }
_ZN8fuzztest8internal6no_adl8IRObject13MutableScalarINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEERDav:
  141|  5.49k|  auto& MutableScalar() {
  142|       |    if constexpr (is_monostate_v<T>) {
  143|       |      static_assert(always_false<T>, "Invalid type");
  144|       |    }
  145|  5.49k|    if (!std::holds_alternative<T>(value_)) {
  ------------------
  |  Branch (145:9): [True: 5.49k, False: 0]
  ------------------
  146|  5.49k|      value_.emplace<T>();
  147|  5.49k|    }
  148|  5.49k|    return std::get<T>(value_);
  149|  5.49k|  }

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

_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|     52|  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; }
_ZNK7testing8TestInfo4fileEv:
  565|     12|  const char* file() const { return location_.file.c_str(); }
_ZNK7testing8TestInfo4lineEv:
  568|     12|  int line() const { return location_.line; }
_ZN7testing9TestSuite13ShouldRunTestEPKNS_8TestInfoE:
  838|     12|  static bool ShouldRunTest(const TestInfo* test_info) {
  839|     12|    return test_info->should_run();
  840|     12|  }
_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|      6|  static void ClearTestResult(TestInfo* test_info) {
  639|      6|    test_info->result_.Clear();
  640|      6|  }
_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|      8|  bool should_run() const { return should_run_; }
_ZNK7testing8TestInfo10should_runEv:
  589|     12|  bool should_run() const { return should_run_; }
_ZNK7testing8TestInfo10type_paramEv:
  552|      6|  const char* type_param() const {
  553|      6|    if (type_param_ != nullptr) return type_param_->c_str();
  ------------------
  |  Branch (553:9): [True: 0, False: 6]
  ------------------
  554|      6|    return nullptr;
  555|      6|  }
_ZNK7testing8UnitTest4implEv:
 1281|     22|  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|      8|  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|      8|  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|      6|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|      6|  return &(TypeIdHelper<T>::dummy_);
  416|      6|}

_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|     14|  Mutex() {
 1715|     14|    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, nullptr));
  ------------------
  |  | 1100|     14|  if (const int gtest_error = (posix_call))    \
  |  |  ------------------
  |  |  |  Branch (1100:17): [True: 0, False: 14]
  |  |  ------------------
  |  | 1101|     14|  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|     14|    has_owner_ = false;
 1717|     14|  }
_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|     34|inline UnitTestImpl* GetUnitTestImpl() {
  983|     34|  return UnitTest::GetInstance()->impl();
  984|     34|}
_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|      6|                   TestInfo* test_info) {
  678|      6|#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|      6|    if (original_working_dir_.IsEmpty()) {
  ------------------
  |  Branch (686:9): [True: 2, False: 4]
  ------------------
  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|      6|#endif  // GTEST_HAS_FILE_SYSTEM
  692|       |
  693|      6|    GetTestSuite(test_info->test_suite_name_, test_info->type_param(),
  694|      6|                 set_up_tc, tear_down_tc)
  695|      6|        ->AddTestInfo(test_info);
  696|      6|  }
_ZNK7testing8internal12UnitTestImpl12GetTestSuiteEi:
  591|     14|  const TestSuite* GetTestSuite(int i) const {
  592|     14|    const int index = GetElementOr(test_suite_indices_, i, -1);
  593|     14|    return index < 0 ? nullptr : test_suites_[static_cast<size_t>(i)];
  ------------------
  |  Branch (593:12): [True: 0, False: 14]
  ------------------
  594|     14|  }
_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|     24|inline E GetElementOr(const std::vector<E>& v, int i, E default_value) {
  296|     24|  return (i < 0 || i >= static_cast<int>(v.size())) ? default_value
  ------------------
  |  Branch (296:11): [True: 0, False: 24]
  |  Branch (296:20): [True: 0, False: 24]
  ------------------
  297|     24|                                                    : v[static_cast<size_t>(i)];
  298|     24|}
_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|     16|  for (auto it = c.begin(); it != c.end(); ++it) {
  ------------------
  |  Branch (280:29): [True: 12, False: 4]
  ------------------
  281|     12|    if (predicate(*it)) ++count;
  ------------------
  |  Branch (281:9): [True: 4, False: 8]
  ------------------
  282|     12|  }
  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|      6|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.94k|  for (const char* ch = start; ch != end; ++ch) {
  ------------------
  |  Branch (2275:32): [True: 2.82k, False: 122]
  ------------------
 2276|  2.82k|    if (*ch == '\0') {
  ------------------
  |  Branch (2276:9): [True: 0, False: 2.82k]
  ------------------
 2277|      0|      result += "\\0";  // Replaces NUL with "\\0";
 2278|  2.82k|    } else {
 2279|  2.82k|      result += *ch;
 2280|  2.82k|    }
 2281|  2.82k|  }
 2282|       |
 2283|    122|  return result;
 2284|    122|}
_ZN7testing10TestResultC2Ev:
 2306|     10|    : 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|      8|void TestResult::Clear() {
 2453|      8|  test_part_results_.clear();
 2454|      8|  test_properties_.clear();
 2455|      8|  death_test_count_ = 0;
 2456|      8|  elapsed_time_ = 0;
 2457|      8|}
_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|      6|    : test_suite_name_(std::move(a_test_suite_name)),
 2778|      6|      name_(std::move(a_name)),
 2779|      6|      type_param_(a_type_param ? new std::string(a_type_param) : nullptr),
  ------------------
  |  Branch (2779:19): [True: 0, False: 6]
  ------------------
 2780|      6|      value_param_(a_value_param ? new std::string(a_value_param) : nullptr),
  ------------------
  |  Branch (2780:20): [True: 0, False: 6]
  ------------------
 2781|      6|      location_(std::move(a_code_location)),
 2782|      6|      fixture_class_id_(fixture_class_id),
 2783|      6|      should_run_(false),
 2784|      6|      is_disabled_(false),
 2785|      6|      matches_filter_(false),
 2786|      6|      is_in_another_shard_(false),
 2787|      6|      factory_(factory),
 2788|      6|      result_() {}
_ZN7testing8internal23MakeAndRegisterTestInfoENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPKcS9_S9_NS0_12CodeLocationEPKvPFvvESE_PNS0_15TestFactoryBaseE:
 2817|      6|    TearDownTestSuiteFunc tear_down_tc, TestFactoryBase* factory) {
 2818|      6|  TestInfo* const test_info =
 2819|      6|      new TestInfo(std::move(test_suite_name), name, type_param, value_param,
 2820|      6|                   std::move(code_location), fixture_class_id, factory);
 2821|      6|  GetUnitTestImpl()->AddTestInfo(set_up_tc, tear_down_tc, test_info);
 2822|      6|  return test_info;
 2823|      6|}
_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|     12|int TestSuite::total_test_count() const {
 2966|     12|  return static_cast<int>(test_info_list_.size());
 2967|     12|}
_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|      6|const TestInfo* TestSuite::GetTestInfo(int i) const {
 2998|      6|  const int index = GetElementOr(test_indices_, i, -1);
 2999|      6|  return index < 0 ? nullptr : test_info_list_[static_cast<size_t>(index)];
  ------------------
  |  Branch (2999:10): [True: 0, False: 6]
  ------------------
 3000|      6|}
_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|      6|void TestSuite::AddTestInfo(TestInfo* test_info) {
 3012|      6|  test_info_list_.push_back(test_info);
 3013|      6|  test_indices_.push_back(static_cast<int>(test_indices_.size()));
 3014|      6|}
_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|     58|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|     58|  static UnitTest instance;
 5260|     58|  return &instance;
 5261|     58|#endif  // defined(__BORLANDC__)
 5262|     58|}
_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|     14|const TestSuite* UnitTest::GetTestSuite(int i) const {
 5357|     14|  return impl()->GetTestSuite(i);
 5358|     14|}
_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|      6|    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|      6|  if (!test_suites_.empty() &&
  ------------------
  |  Branch (5843:7): [True: 4, False: 2]
  |  Branch (5843:7): [True: 4, False: 2]
  ------------------
 5844|      4|      (*test_suites_.rbegin())->name_ == test_suite_name) {
  ------------------
  |  Branch (5844:7): [True: 4, False: 0]
  ------------------
 5845|      4|    return *test_suites_.rbegin();
 5846|      4|  }
 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|      6|    for (TestInfo* test_info : test_suite->test_info_list()) {
  ------------------
  |  Branch (6262:30): [True: 6, False: 2]
  ------------------
 6263|      6|      const std::string& test_name = test_info->name_;
 6264|       |      // A test is disabled if test suite name or test name matches
 6265|       |      // kDisableTestFilter.
 6266|      6|      const bool is_disabled =
 6267|      6|          disable_test_filter.MatchesName(test_suite_name) ||
  ------------------
  |  Branch (6267:11): [True: 0, False: 6]
  ------------------
 6268|      6|          disable_test_filter.MatchesName(test_name);
  ------------------
  |  Branch (6268:11): [True: 0, False: 6]
  ------------------
 6269|      6|      test_info->is_disabled_ = is_disabled;
 6270|       |
 6271|      6|      const bool matches_filter =
 6272|      6|          gtest_flag_filter.MatchesTest(test_suite_name, test_name);
 6273|      6|      test_info->matches_filter_ = matches_filter;
 6274|       |
 6275|      6|      const bool is_runnable =
 6276|      6|          (GTEST_FLAG_GET(also_run_disabled_tests) || !is_disabled) &&
  ------------------
  |  | 2310|      6|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2242|      6|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  |  |  |  Branch (2310:30): [True: 0, False: 6]
  |  |  ------------------
  ------------------
  |  Branch (6276:55): [True: 6, False: 0]
  ------------------
 6277|      6|          matches_filter;
  ------------------
  |  Branch (6277:11): [True: 2, False: 4]
  ------------------
 6278|       |
 6279|      6|      const bool is_in_another_shard =
 6280|      6|          shard_tests != IGNORE_SHARDING_PROTOCOL &&
  ------------------
  |  Branch (6280:11): [True: 0, False: 6]
  ------------------
 6281|      0|          !ShouldRunTestOnShard(total_shards, shard_index, num_runnable_tests);
  ------------------
  |  Branch (6281:11): [True: 0, False: 0]
  ------------------
 6282|      6|      test_info->is_in_another_shard_ = is_in_another_shard;
 6283|      6|      const bool is_selected = is_runnable && !is_in_another_shard;
  ------------------
  |  Branch (6283:32): [True: 2, False: 4]
  |  Branch (6283:47): [True: 2, False: 0]
  ------------------
 6284|       |
 6285|      6|      num_runnable_tests += is_runnable;
 6286|      6|      num_selected_tests += is_selected;
 6287|       |
 6288|      6|      test_info->should_run_ = is_selected;
 6289|      6|      test_suite->set_should_run(test_suite->should_run() || is_selected);
  ------------------
  |  Branch (6289:34): [True: 0, False: 6]
  |  Branch (6289:62): [True: 2, False: 4]
  ------------------
 6290|      6|    }
 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|     26|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|     72|                     [](const char c) { return c == '?' || c == '*'; });
  ------------------
  |  Branch (791:48): [True: 0, False: 72]
  |  Branch (791:60): [True: 8, False: 64]
  ------------------
gtest-all.cc:_ZNK7testing8internal12_GLOBAL__N_114UnitTestFilter11MatchesNameERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
  817|     22|  bool MatchesName(const std::string& name) const {
  818|     22|    return exact_match_patterns_.find(name) != exact_match_patterns_.end() ||
  ------------------
  |  Branch (818:12): [True: 2, False: 20]
  ------------------
  819|     20|           std::any_of(glob_patterns_.begin(), glob_patterns_.end(),
  ------------------
  |  Branch (819:12): [True: 0, False: 20]
  ------------------
  820|     20|                       [&name](const std::string& pattern) {
  821|     20|                         return PatternMatchesString(
  822|     20|                             name, pattern.c_str(),
  823|     20|                             pattern.c_str() + pattern.size());
  824|     20|                       });
  825|     22|  }
gtest-all.cc:_ZZNK7testing8internal12_GLOBAL__N_114UnitTestFilter11MatchesNameERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEENKUlSB_E_clESB_:
  820|     28|                       [&name](const std::string& pattern) {
  821|     28|                         return PatternMatchesString(
  822|     28|                             name, pattern.c_str(),
  823|     28|                             pattern.c_str() + pattern.size());
  824|     28|                       });
gtest-all.cc:_ZN7testing8internalL20PatternMatchesStringERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPKcSB_:
  741|     28|                                 const char* pattern, const char* pattern_end) {
  742|     28|  const char* name = name_str.c_str();
  743|     28|  const char* const name_begin = name;
  744|     28|  const char* const name_end = name + name_str.size();
  745|       |
  746|     28|  const char* pattern_next = pattern;
  747|     28|  const char* name_next = name;
  748|       |
  749|    472|  while (pattern < pattern_end || name < name_end) {
  ------------------
  |  Branch (749:10): [True: 472, False: 0]
  |  Branch (749:35): [True: 0, False: 0]
  ------------------
  750|    472|    if (pattern < pattern_end) {
  ------------------
  |  Branch (750:9): [True: 472, False: 0]
  ------------------
  751|    472|      switch (*pattern) {
  752|    242|        default:  // Match an ordinary character.
  ------------------
  |  Branch (752:9): [True: 242, False: 230]
  ------------------
  753|    242|          if (name < name_end && *name == *pattern) {
  ------------------
  |  Branch (753:15): [True: 226, False: 16]
  |  Branch (753:34): [True: 0, False: 226]
  ------------------
  754|      0|            ++pattern;
  755|      0|            ++name;
  756|      0|            continue;
  757|      0|          }
  758|    242|          break;
  759|    242|        case '?':  // Match any single character.
  ------------------
  |  Branch (759:9): [True: 0, False: 472]
  ------------------
  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|    230|        case '*':
  ------------------
  |  Branch (766:9): [True: 230, False: 242]
  ------------------
  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|    230|          pattern_next = pattern;
  771|    230|          name_next = name + 1;
  772|    230|          ++pattern;
  773|    230|          continue;
  774|    472|      }
  775|    472|    }
  776|       |    // Failed to match a character. Restart if possible.
  777|    242|    if (name_begin < name_next && name_next <= name_end) {
  ------------------
  |  Branch (777:9): [True: 230, False: 12]
  |  Branch (777:35): [True: 214, False: 16]
  ------------------
  778|    214|      pattern = pattern_next;
  779|    214|      name = name_next;
  780|    214|      continue;
  781|    214|    }
  782|     28|    return false;
  783|    242|  }
  784|      0|  return true;
  785|     28|}
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|      6|                   const std::string& test_name) const {
  871|      6|    return MatchesName(test_suite_name + "." + test_name);
  872|      6|  }
gtest-all.cc:_ZNK7testing8internal12_GLOBAL__N_133PositiveAndNegativeUnitTestFilter11MatchesNameERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
  876|      6|  bool MatchesName(const std::string& name) const {
  877|      6|    return positive_filter_.MatchesName(name) &&
  ------------------
  |  Branch (877:12): [True: 2, False: 4]
  ------------------
  878|      2|           !negative_filter_.MatchesName(name);
  ------------------
  |  Branch (878:12): [True: 2, False: 0]
  ------------------
  879|      6|  }
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|}
gtest-all.cc:_ZZN7testing9TestSuite3RunEvENK3$_0clEPKNS_8TestInfoES4_:
 3035|      6|                   [](const TestInfo* const a, const TestInfo* const b) {
 3036|      6|                     if (const int result = std::strcmp(a->file(), b->file())) {
  ------------------
  |  Branch (3036:36): [True: 0, False: 6]
  ------------------
 3037|      0|                       return result < 0;
 3038|      0|                     }
 3039|       |
 3040|      6|                     return a->line() < b->line();
 3041|      6|                   });
_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|}

WebPGetAlphaWindowRows:
  129|  2.48k|int WebPGetAlphaWindowRows(const VP8Decoder* const dec, const VP8Io* const io) {
  130|  2.48k|  const int width = io->width;
  131|       |  // Alpha rows are always decoded starting from row 0 (for spatial filtering
  132|       |  // and lossless stream dependencies) and decoding stops at io->crop_bottom
  133|       |  // (which equals io->height when cropping is not used).
  134|  2.48k|  const int height = io->crop_bottom;
  135|  2.48k|  if (dec->alpha_data == NULL) return 0;
  ------------------
  |  Branch (135:7): [True: 2.48k, False: 0]
  ------------------
  136|       |  // For each non-last macroblock row (16 pixel rows), FinishRow() in
  137|       |  // frame_dec.c holds back up to 8 bottom pixel rows (kFilterExtraRows[] for
  138|       |  // complex filtering) until the next macroblock row is decoded. On the last
  139|       |  // macroblock row, no bottom rows are held back, so FinishRow() requests the 8
  140|       |  // pixel rows held back from the previous macroblock row plus all 16 pixel
  141|       |  // rows of the last macroblock row (24 pixel rows total), while retaining 1
  142|       |  // preceding row (row - 1) for spatial unfiltering and fancy upsampling.
  143|      0|  return (dec->alpha_dithering > 0)
  ------------------
  |  Branch (143:10): [True: 0, False: 0]
  ------------------
  144|      0|             ? height
  145|      0|             : VP8LGetWindowRows(width, height, /*max_history_rows=*/25);
  146|  2.48k|}
WebPDeallocateAlphaMemory:
  223|  4.83k|void WebPDeallocateAlphaMemory(VP8Decoder* const dec) {
  224|  4.83k|  assert(dec != NULL);
  225|  4.83k|  dec->alpha_plane = NULL;
  226|  4.83k|  ALPHDelete(dec->alph_dec);
  227|       |  dec->alph_dec = NULL;
  228|  4.83k|}
alpha_dec.c:ALPHDelete:
   42|  4.83k|static void ALPHDelete(ALPHDecoder* const dec) {
   43|  4.83k|  if (dec != NULL) {
  ------------------
  |  Branch (43:7): [True: 0, False: 4.83k]
  ------------------
   44|      0|    VP8LDelete(dec->vp8l_dec);
   45|       |    dec->vp8l_dec = NULL;
   46|      0|    WebPSafeFree(dec);
   47|      0|  }
   48|  4.83k|}

IsValidColorspace:
   37|  7.54k|int IsValidColorspace(int webp_csp_mode) {
   38|  7.54k|  return (webp_csp_mode >= MODE_RGB && webp_csp_mode < MODE_LAST);
  ------------------
  |  Branch (38:11): [True: 7.54k, False: 0]
  |  Branch (38:40): [True: 7.54k, False: 0]
  ------------------
   39|  7.54k|}
WebPAllocateDecBuffer:
  181|  3.77k|                                    WebPDecBuffer* const buffer) {
  182|  3.77k|  VP8StatusCode status;
  183|  3.77k|  if (buffer == NULL || width <= 0 || height <= 0) {
  ------------------
  |  Branch (183:7): [True: 0, False: 3.77k]
  |  Branch (183:25): [True: 0, False: 3.77k]
  |  Branch (183:39): [True: 0, False: 3.77k]
  ------------------
  184|      0|    return VP8_STATUS_INVALID_PARAM;
  185|      0|  }
  186|  3.77k|  if (options != NULL) {  // First, apply options if there is any.
  ------------------
  |  Branch (186:7): [True: 0, False: 3.77k]
  ------------------
  187|      0|    if (options->use_cropping) {
  ------------------
  |  Branch (187:9): [True: 0, False: 0]
  ------------------
  188|      0|      const int cw = options->crop_width;
  189|      0|      const int ch = options->crop_height;
  190|      0|      const int x = options->crop_left & ~1;
  191|      0|      const int y = options->crop_top & ~1;
  192|      0|      if (!WebPCheckCropDimensions(width, height, x, y, cw, ch)) {
  ------------------
  |  Branch (192:11): [True: 0, False: 0]
  ------------------
  193|      0|        return VP8_STATUS_INVALID_PARAM;  // out of frame boundary.
  194|      0|      }
  195|      0|      width = cw;
  196|      0|      height = ch;
  197|      0|    }
  198|       |
  199|      0|    if (options->use_scaling) {
  ------------------
  |  Branch (199:9): [True: 0, False: 0]
  ------------------
  200|      0|#if !defined(WEBP_REDUCE_SIZE)
  201|      0|      int scaled_width = options->scaled_width;
  202|      0|      int scaled_height = options->scaled_height;
  203|      0|      if (!WebPRescalerGetScaledDimensions(width, height, &scaled_width,
  ------------------
  |  Branch (203:11): [True: 0, False: 0]
  ------------------
  204|      0|                                           &scaled_height)) {
  205|      0|        return VP8_STATUS_INVALID_PARAM;
  206|      0|      }
  207|      0|      width = scaled_width;
  208|      0|      height = scaled_height;
  209|       |#else
  210|       |      return VP8_STATUS_INVALID_PARAM;  // rescaling not supported
  211|       |#endif
  212|      0|    }
  213|      0|  }
  214|  3.77k|  buffer->width = width;
  215|  3.77k|  buffer->height = height;
  216|       |
  217|       |  // Then, allocate buffer for real.
  218|  3.77k|  status = AllocateBuffer(buffer);
  219|  3.77k|  if (status != VP8_STATUS_OK) return status;
  ------------------
  |  Branch (219:7): [True: 53, False: 3.71k]
  ------------------
  220|       |
  221|       |  // Use the stride trick if vertical flip is needed.
  222|  3.71k|  if (options != NULL && options->flip) {
  ------------------
  |  Branch (222:7): [True: 0, False: 3.71k]
  |  Branch (222:26): [True: 0, False: 0]
  ------------------
  223|      0|    status = WebPFlipBuffer(buffer);
  224|      0|  }
  225|  3.71k|  return status;
  226|  3.77k|}
WebPInitDecBufferInternal:
  231|  4.77k|int WebPInitDecBufferInternal(WebPDecBuffer* buffer, int version) {
  232|  4.77k|  if (WEBP_ABI_IS_INCOMPATIBLE(version, WEBP_DECODER_ABI_VERSION)) {
  ------------------
  |  |   84|  4.77k|#define WEBP_ABI_IS_INCOMPATIBLE(a, b) (((a) >> 8) != ((b) >> 8))
  |  |  ------------------
  |  |  |  Branch (84:40): [True: 0, False: 4.77k]
  |  |  ------------------
  ------------------
  233|      0|    return 0;  // version mismatch
  234|      0|  }
  235|  4.77k|  if (buffer == NULL) return 0;
  ------------------
  |  Branch (235:7): [True: 0, False: 4.77k]
  ------------------
  236|  4.77k|  WEBP_UNSAFE_MEMSET(buffer, 0, sizeof(*buffer));
  ------------------
  |  |  175|  4.77k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  237|  4.77k|  return 1;
  238|  4.77k|}
WebPFreeDecBuffer:
  240|  3.50k|void WebPFreeDecBuffer(WebPDecBuffer* buffer) {
  241|  3.50k|  if (buffer != NULL) {
  ------------------
  |  Branch (241:7): [True: 3.50k, False: 0]
  ------------------
  242|  3.50k|    if (buffer->is_external_memory <= 0) {
  ------------------
  |  Branch (242:9): [True: 1.87k, False: 1.63k]
  ------------------
  243|  1.87k|      WebPSafeFree(buffer->private_memory);
  244|  1.87k|    }
  245|       |    buffer->private_memory = NULL;
  246|  3.50k|  }
  247|  3.50k|}
WebPCopyDecBuffer:
  250|    108|                       WebPDecBuffer* const dst) {
  251|    108|  if (src != NULL && dst != NULL) {
  ------------------
  |  Branch (251:7): [True: 108, False: 0]
  |  Branch (251:22): [True: 108, False: 0]
  ------------------
  252|    108|    *dst = *src;
  253|    108|    if (src->private_memory != NULL) {
  ------------------
  |  Branch (253:9): [True: 108, False: 0]
  ------------------
  254|    108|      dst->is_external_memory = 1;  // dst buffer doesn't own the memory.
  255|       |      dst->private_memory = NULL;
  256|    108|    }
  257|    108|  }
  258|    108|}
buffer_dec.c:AllocateBuffer:
   89|  3.77k|static VP8StatusCode AllocateBuffer(WebPDecBuffer* const buffer) {
   90|  3.77k|  const int w = buffer->width;
   91|  3.77k|  const int h = buffer->height;
   92|  3.77k|  const WEBP_CSP_MODE mode = buffer->colorspace;
   93|       |
   94|  3.77k|  if (w <= 0 || h <= 0 || !IsValidColorspace(mode)) {
  ------------------
  |  Branch (94:7): [True: 0, False: 3.77k]
  |  Branch (94:17): [True: 0, False: 3.77k]
  |  Branch (94:27): [True: 0, False: 3.77k]
  ------------------
   95|      0|    return VP8_STATUS_INVALID_PARAM;
   96|      0|  }
   97|       |
   98|  3.77k|  if (buffer->is_external_memory <= 0 && buffer->private_memory == NULL) {
  ------------------
  |  Branch (98:7): [True: 2.08k, False: 1.68k]
  |  Branch (98:42): [True: 2.08k, False: 0]
  ------------------
   99|  2.08k|    uint8_t* output;
  100|  2.08k|    int uv_stride = 0, a_stride = 0;
  101|  2.08k|    uint64_t uv_size = 0, a_size = 0, total_size;
  102|       |    // We need memory and it hasn't been allocated yet.
  103|       |    // => initialize output buffer, now that dimensions are known.
  104|  2.08k|    int stride;
  105|  2.08k|    uint64_t size;
  106|       |
  107|  2.08k|    if ((uint64_t)w * kModeBpp[mode] >= (1ull << 31)) {
  ------------------
  |  Branch (107:9): [True: 0, False: 2.08k]
  ------------------
  108|      0|      return VP8_STATUS_INVALID_PARAM;
  109|      0|    }
  110|  2.08k|    stride = w * kModeBpp[mode];
  111|  2.08k|    size = (uint64_t)stride * h;
  112|  2.08k|    if (!WebPIsRGBMode(mode)) {
  ------------------
  |  Branch (112:9): [True: 293, False: 1.79k]
  ------------------
  113|    293|      uv_stride = (w + 1) / 2;
  114|    293|      uv_size = (uint64_t)uv_stride * ((h + 1) / 2);
  115|    293|      if (mode == MODE_YUVA) {
  ------------------
  |  Branch (115:11): [True: 0, False: 293]
  ------------------
  116|      0|        a_stride = w;
  117|      0|        a_size = (uint64_t)a_stride * h;
  118|      0|      }
  119|    293|    }
  120|  2.08k|    total_size = size + 2 * uv_size + a_size;
  121|       |
  122|  2.08k|    output = (uint8_t*)WebPSafeMalloc(total_size, sizeof(*output));
  123|  2.08k|    if (output == NULL) {
  ------------------
  |  Branch (123:9): [True: 0, False: 2.08k]
  ------------------
  124|      0|      return VP8_STATUS_OUT_OF_MEMORY;
  125|      0|    }
  126|  2.08k|    buffer->private_memory = output;
  127|       |
  128|  2.08k|    if (!WebPIsRGBMode(mode)) {  // YUVA initialization
  ------------------
  |  Branch (128:9): [True: 293, False: 1.79k]
  ------------------
  129|    293|      WebPYUVABuffer* const buf = &buffer->u.YUVA;
  130|    293|      buf->y = output;
  131|    293|      buf->y_stride = stride;
  132|    293|      buf->y_size = (size_t)size;
  133|    293|      buf->u = output + size;
  134|    293|      buf->u_stride = uv_stride;
  135|    293|      buf->u_size = (size_t)uv_size;
  136|    293|      buf->v = output + size + uv_size;
  137|    293|      buf->v_stride = uv_stride;
  138|    293|      buf->v_size = (size_t)uv_size;
  139|    293|      if (mode == MODE_YUVA) {
  ------------------
  |  Branch (139:11): [True: 0, False: 293]
  ------------------
  140|      0|        buf->a = output + size + 2 * uv_size;
  141|      0|      }
  142|    293|      buf->a_size = (size_t)a_size;
  143|    293|      buf->a_stride = a_stride;
  144|  1.79k|    } else {  // RGBA initialization
  145|  1.79k|      WebPRGBABuffer* const buf = &buffer->u.RGBA;
  146|  1.79k|      buf->rgba = output;
  147|  1.79k|      buf->stride = stride;
  148|  1.79k|      buf->size = (size_t)size;
  149|  1.79k|    }
  150|  2.08k|  }
  151|  3.77k|  return CheckDecBuffer(buffer);
  152|  3.77k|}
buffer_dec.c:CheckDecBuffer:
   48|  3.77k|static VP8StatusCode CheckDecBuffer(const WebPDecBuffer* const buffer) {
   49|  3.77k|  int ok = 1;
   50|  3.77k|  const WEBP_CSP_MODE mode = buffer->colorspace;
   51|  3.77k|  const int width = buffer->width;
   52|  3.77k|  const int height = buffer->height;
   53|  3.77k|  if (!IsValidColorspace(mode)) {
  ------------------
  |  Branch (53:7): [True: 0, False: 3.77k]
  ------------------
   54|      0|    ok = 0;
   55|  3.77k|  } else if (!WebPIsRGBMode(mode)) {  // YUV checks
  ------------------
  |  Branch (55:14): [True: 629, False: 3.14k]
  ------------------
   56|    629|    const WebPYUVABuffer* const buf = &buffer->u.YUVA;
   57|    629|    const int uv_width = (width + 1) / 2;
   58|    629|    const int uv_height = (height + 1) / 2;
   59|    629|    const uint64_t y_size = MIN_BUFFER_SIZE(width, height, buf->y_stride);
  ------------------
  |  |   44|    629|  ((uint64_t)((STRIDE) >= 0 ? (int64_t)(STRIDE) : -(int64_t)(STRIDE)) * \
  |  |  ------------------
  |  |  |  Branch (44:15): [True: 629, False: 0]
  |  |  ------------------
  |  |   45|    629|       ((HEIGHT) - 1) +                                                 \
  |  |   46|    629|   (WIDTH))
  ------------------
   60|    629|    const uint64_t u_size = MIN_BUFFER_SIZE(uv_width, uv_height, buf->u_stride);
  ------------------
  |  |   44|    629|  ((uint64_t)((STRIDE) >= 0 ? (int64_t)(STRIDE) : -(int64_t)(STRIDE)) * \
  |  |  ------------------
  |  |  |  Branch (44:15): [True: 629, False: 0]
  |  |  ------------------
  |  |   45|    629|       ((HEIGHT) - 1) +                                                 \
  |  |   46|    629|   (WIDTH))
  ------------------
   61|    629|    const uint64_t v_size = MIN_BUFFER_SIZE(uv_width, uv_height, buf->v_stride);
  ------------------
  |  |   44|    629|  ((uint64_t)((STRIDE) >= 0 ? (int64_t)(STRIDE) : -(int64_t)(STRIDE)) * \
  |  |  ------------------
  |  |  |  Branch (44:15): [True: 629, False: 0]
  |  |  ------------------
  |  |   45|    629|       ((HEIGHT) - 1) +                                                 \
  |  |   46|    629|   (WIDTH))
  ------------------
   62|    629|    const uint64_t a_size = MIN_BUFFER_SIZE(width, height, buf->a_stride);
  ------------------
  |  |   44|    629|  ((uint64_t)((STRIDE) >= 0 ? (int64_t)(STRIDE) : -(int64_t)(STRIDE)) * \
  |  |  ------------------
  |  |  |  Branch (44:15): [True: 629, False: 0]
  |  |  ------------------
  |  |   45|    629|       ((HEIGHT) - 1) +                                                 \
  |  |   46|    629|   (WIDTH))
  ------------------
   63|    629|    ok &= (y_size <= buf->y_size);
   64|    629|    ok &= (u_size <= buf->u_size);
   65|    629|    ok &= (v_size <= buf->v_size);
   66|    629|    ok &= CheckStride(buf->y_stride, 1, width);
   67|    629|    ok &= CheckStride(buf->u_stride, 1, uv_width);
   68|    629|    ok &= CheckStride(buf->v_stride, 1, uv_width);
   69|    629|    ok &= (buf->y != NULL);
   70|    629|    ok &= (buf->u != NULL);
   71|    629|    ok &= (buf->v != NULL);
   72|    629|    if (mode == MODE_YUVA) {
  ------------------
  |  Branch (72:9): [True: 0, False: 629]
  ------------------
   73|      0|      ok &= CheckStride(buf->a_stride, 1, width);
   74|      0|      ok &= (a_size <= buf->a_size);
   75|      0|      ok &= (buf->a != NULL);
   76|      0|    }
   77|  3.14k|  } else {  // RGB checks
   78|  3.14k|    const WebPRGBABuffer* const buf = &buffer->u.RGBA;
   79|  3.14k|    const uint64_t size =
   80|  3.14k|        MIN_BUFFER_SIZE((uint64_t)width * kModeBpp[mode], height, buf->stride);
  ------------------
  |  |   44|  3.14k|  ((uint64_t)((STRIDE) >= 0 ? (int64_t)(STRIDE) : -(int64_t)(STRIDE)) * \
  |  |  ------------------
  |  |  |  Branch (44:15): [True: 3.14k, False: 0]
  |  |  ------------------
  |  |   45|  3.14k|       ((HEIGHT) - 1) +                                                 \
  |  |   46|  3.14k|   (WIDTH))
  ------------------
   81|  3.14k|    ok &= (size <= buf->size);
   82|  3.14k|    ok &= CheckStride(buf->stride, kModeBpp[mode], width);
   83|  3.14k|    ok &= (buf->rgba != NULL);
   84|  3.14k|  }
   85|  3.77k|  return ok ? VP8_STATUS_OK : VP8_STATUS_INVALID_PARAM;
  ------------------
  |  Branch (85:10): [True: 3.71k, False: 53]
  ------------------
   86|  3.77k|}

VP8InitDithering:
  345|  2.48k|                      VP8Decoder* const dec) {
  346|  2.48k|  assert(dec != NULL);
  347|  2.48k|  if (options != NULL) {
  ------------------
  |  Branch (347:7): [True: 0, False: 2.48k]
  ------------------
  348|      0|    const int d = options->dithering_strength;
  349|      0|    const int max_amp = (1 << VP8_RANDOM_DITHER_FIX) - 1;
  ------------------
  |  |   29|      0|#define VP8_RANDOM_DITHER_FIX 8  // fixed-point precision for dithering
  ------------------
  350|      0|    const int f = (d < 0) ? 0 : (d > 100) ? max_amp : (d * max_amp / 100);
  ------------------
  |  Branch (350:19): [True: 0, False: 0]
  |  Branch (350:33): [True: 0, False: 0]
  ------------------
  351|      0|    if (f > 0) {
  ------------------
  |  Branch (351:9): [True: 0, False: 0]
  ------------------
  352|      0|      int s;
  353|      0|      int all_amp = 0;
  354|      0|      for (s = 0; s < NUM_MB_SEGMENTS; ++s) {
  ------------------
  |  Branch (354:19): [True: 0, False: 0]
  ------------------
  355|      0|        VP8QuantMatrix* const dqm = &dec->dqm[s];
  356|      0|        if (dqm->uv_quant < DITHER_AMP_TAB_SIZE) {
  ------------------
  |  |  339|      0|#define DITHER_AMP_TAB_SIZE 12
  ------------------
  |  Branch (356:13): [True: 0, False: 0]
  ------------------
  357|      0|          const int idx = (dqm->uv_quant < 0) ? 0 : dqm->uv_quant;
  ------------------
  |  Branch (357:27): [True: 0, False: 0]
  ------------------
  358|      0|          dqm->dither = (f * kQuantToDitherAmp[idx]) >> 3;
  359|      0|        }
  360|      0|        all_amp |= dqm->dither;
  361|      0|      }
  362|      0|      if (all_amp != 0) {
  ------------------
  |  Branch (362:11): [True: 0, False: 0]
  ------------------
  363|      0|        VP8InitRandom(&dec->dithering_rg, 1.0f);
  364|      0|        dec->dither = 1;
  365|      0|      }
  366|      0|    }
  367|       |    // potentially allow alpha dithering
  368|      0|    if (dec->alpha_data != NULL && dec->alpha_data_size > ALPHA_HEADER_LEN &&
  ------------------
  |  |   74|      0|#define ALPHA_HEADER_LEN 1
  ------------------
  |  Branch (368:9): [True: 0, False: 0]
  |  Branch (368:36): [True: 0, False: 0]
  ------------------
  369|      0|        ((dec->alpha_data[0] >> 4) & 0x03) == ALPHA_PREPROCESSED_LEVELS) {
  ------------------
  |  |   77|      0|#define ALPHA_PREPROCESSED_LEVELS 1
  ------------------
  |  Branch (369:9): [True: 0, False: 0]
  ------------------
  370|      0|      dec->alpha_dithering = options->alpha_dithering_strength;
  371|      0|      if (dec->alpha_dithering > 100) {
  ------------------
  |  Branch (371:11): [True: 0, False: 0]
  ------------------
  372|      0|        dec->alpha_dithering = 100;
  373|      0|      } else if (dec->alpha_dithering < 0) {
  ------------------
  |  Branch (373:18): [True: 0, False: 0]
  ------------------
  374|      0|        dec->alpha_dithering = 0;
  375|      0|      }
  376|      0|    } else {
  377|      0|      dec->alpha_dithering = 0;
  378|      0|    }
  379|      0|  }
  380|  2.48k|}
VP8ProcessRow:
  527|  32.5k|int VP8ProcessRow(VP8Decoder* const dec, VP8Io* const io) {
  528|  32.5k|  int ok = 1;
  529|  32.5k|  VP8ThreadContext* const ctx = &dec->thread_ctx;
  530|  32.5k|  const int filter_row = (dec->filter_type > 0) &&
  ------------------
  |  Branch (530:26): [True: 31.6k, False: 926]
  ------------------
  531|  31.6k|                         (dec->mb_y >= dec->tl_mb_y) &&
  ------------------
  |  Branch (531:26): [True: 31.6k, False: 0]
  ------------------
  532|  31.6k|                         (dec->mb_y <= dec->br_mb_y);
  ------------------
  |  Branch (532:26): [True: 31.6k, False: 0]
  ------------------
  533|  32.5k|  if (dec->mt_method == 0) {
  ------------------
  |  Branch (533:7): [True: 32.5k, False: 0]
  ------------------
  534|       |    // ctx->id and ctx->f_info are already set
  535|  32.5k|    ctx->mb_y = dec->mb_y;
  536|  32.5k|    ctx->filter_row = filter_row;
  537|  32.5k|    ReconstructRow(dec, ctx);
  538|  32.5k|    ok = FinishRow(dec, io);
  539|  32.5k|  } else {
  540|      0|    WebPWorker* const worker = &dec->worker;
  541|       |    // Finish previous job *before* updating context
  542|      0|    ok &= WebPGetWorkerInterface()->Sync(worker);
  543|      0|    assert(worker->status == OK);
  544|      0|    if (ok) {  // spawn a new deblocking/output job
  ------------------
  |  Branch (544:9): [True: 0, False: 0]
  ------------------
  545|      0|      ctx->io = *io;
  546|      0|      ctx->id = dec->cache_id;
  547|      0|      ctx->mb_y = dec->mb_y;
  548|      0|      ctx->filter_row = filter_row;
  549|      0|      if (dec->mt_method == 2) {  // swap macroblock data
  ------------------
  |  Branch (549:11): [True: 0, False: 0]
  ------------------
  550|      0|        VP8MBData* const tmp = ctx->mb_data;
  551|      0|        ctx->mb_data = dec->mb_data;
  552|      0|        dec->mb_data = tmp;
  553|      0|      } else {
  554|       |        // perform reconstruction directly in main thread
  555|      0|        ReconstructRow(dec, ctx);
  556|      0|      }
  557|      0|      if (filter_row) {  // swap filter info
  ------------------
  |  Branch (557:11): [True: 0, False: 0]
  ------------------
  558|      0|        VP8FInfo* const tmp = ctx->f_info;
  559|      0|        ctx->f_info = dec->f_info;
  560|      0|        dec->f_info = tmp;
  561|      0|      }
  562|       |      // (reconstruct)+filter in parallel
  563|      0|      WebPGetWorkerInterface()->Launch(worker);
  564|      0|      if (++dec->cache_id == dec->num_caches) {
  ------------------
  |  Branch (564:11): [True: 0, False: 0]
  ------------------
  565|      0|        dec->cache_id = 0;
  566|      0|      }
  567|      0|    }
  568|      0|  }
  569|  32.5k|  return ok;
  570|  32.5k|}
VP8EnterCritical:
  575|  2.48k|VP8StatusCode VP8EnterCritical(VP8Decoder* const dec, VP8Io* const io) {
  576|       |  // Call setup() first. This may trigger additional decoding features on 'io'.
  577|       |  // Note: Afterward, we must call teardown() no matter what.
  578|       |  // A more precise reason is reported in WebPDecParams::status.
  579|  2.48k|  if (io->setup != NULL && !io->setup(io)) {
  ------------------
  |  Branch (579:7): [True: 2.48k, False: 0]
  |  Branch (579:28): [True: 0, False: 2.48k]
  ------------------
  580|      0|    VP8SetError(dec, VP8_STATUS_INVALID_PARAM, "Frame setup failed");
  581|      0|    return dec->status;
  582|      0|  }
  583|       |
  584|       |  // Disable filtering per user request
  585|  2.48k|  if (io->bypass_filtering) {
  ------------------
  |  Branch (585:7): [True: 0, False: 2.48k]
  ------------------
  586|      0|    dec->filter_type = 0;
  587|      0|  }
  588|       |
  589|       |  // Define the area where we can skip in-loop filtering, in case of cropping.
  590|       |  //
  591|       |  // 'Simple' filter reads two luma samples outside of the macroblock
  592|       |  // and filters one. It doesn't filter the chroma samples. Hence, we can
  593|       |  // avoid doing the in-loop filtering before crop_top/crop_left position.
  594|       |  // For the 'Complex' filter, 3 samples are read and up to 3 are filtered.
  595|       |  // Means: there's a dependency chain that goes all the way up to the
  596|       |  // top-left corner of the picture (MB #0). We must filter all the previous
  597|       |  // macroblocks.
  598|  2.48k|  {
  599|  2.48k|    const int extra_pixels = kFilterExtraRows[dec->filter_type];
  600|  2.48k|    if (dec->filter_type == 2) {
  ------------------
  |  Branch (600:9): [True: 1.26k, False: 1.22k]
  ------------------
  601|       |      // For complex filter, we need to preserve the dependency chain.
  602|  1.26k|      dec->tl_mb_x = 0;
  603|  1.26k|      dec->tl_mb_y = 0;
  604|  1.26k|    } else {
  605|       |      // For simple filter, we can filter only the cropped region.
  606|       |      // We include 'extra_pixels' on the other side of the boundary, since
  607|       |      // vertical or horizontal filtering of the previous macroblock can
  608|       |      // modify some abutting pixels.
  609|  1.22k|      dec->tl_mb_x = (io->crop_left - extra_pixels) >> 4;
  610|  1.22k|      dec->tl_mb_y = (io->crop_top - extra_pixels) >> 4;
  611|  1.22k|      if (dec->tl_mb_x < 0) dec->tl_mb_x = 0;
  ------------------
  |  Branch (611:11): [True: 1.07k, False: 146]
  ------------------
  612|  1.22k|      if (dec->tl_mb_y < 0) dec->tl_mb_y = 0;
  ------------------
  |  Branch (612:11): [True: 1.07k, False: 146]
  ------------------
  613|  1.22k|    }
  614|       |    // We need some 'extra' pixels on the right/bottom.
  615|  2.48k|    dec->br_mb_y = (io->crop_bottom + 15 + extra_pixels) >> 4;
  616|  2.48k|    dec->br_mb_x = (io->crop_right + 15 + extra_pixels) >> 4;
  617|  2.48k|    if (dec->br_mb_x > dec->mb_w) {
  ------------------
  |  Branch (617:9): [True: 376, False: 2.10k]
  ------------------
  618|    376|      dec->br_mb_x = dec->mb_w;
  619|    376|    }
  620|  2.48k|    if (dec->br_mb_y > dec->mb_h) {
  ------------------
  |  Branch (620:9): [True: 622, False: 1.86k]
  ------------------
  621|    622|      dec->br_mb_y = dec->mb_h;
  622|    622|    }
  623|  2.48k|  }
  624|  2.48k|  PrecomputeFilterStrengths(dec);
  625|  2.48k|  return VP8_STATUS_OK;
  626|  2.48k|}
VP8ExitCritical:
  628|  2.48k|int VP8ExitCritical(VP8Decoder* const dec, VP8Io* const io) {
  629|  2.48k|  int ok = 1;
  630|  2.48k|  if (dec->mt_method > 0) {
  ------------------
  |  Branch (630:7): [True: 0, False: 2.48k]
  ------------------
  631|      0|    ok = WebPGetWorkerInterface()->Sync(&dec->worker);
  632|      0|    if (!ok) VP8SetError(dec, VP8_STATUS_USER_ABORT, "Output aborted.");
  ------------------
  |  Branch (632:9): [True: 0, False: 0]
  ------------------
  633|      0|  }
  634|       |
  635|  2.48k|  if (io->teardown != NULL) {
  ------------------
  |  Branch (635:7): [True: 2.48k, False: 0]
  ------------------
  636|  2.48k|    io->teardown(io);
  637|  2.48k|  }
  638|  2.48k|  return ok;
  639|  2.48k|}
VP8GetThreadMethod:
  690|  2.48k|                       int height) {
  691|  2.48k|  if (options == NULL || options->use_threads == 0) {
  ------------------
  |  Branch (691:7): [True: 2.48k, False: 0]
  |  Branch (691:26): [True: 0, False: 0]
  ------------------
  692|  2.48k|    return 0;
  693|  2.48k|  }
  694|      0|  (void)headers;
  695|      0|  (void)width;
  696|      0|  (void)height;
  697|      0|  assert(headers == NULL || !headers->is_lossless);
  698|      0|#if defined(WEBP_USE_THREAD)
  699|      0|  if (width >= MIN_WIDTH_FOR_THREADS) return 2;
  ------------------
  |  |   72|      0|#define MIN_WIDTH_FOR_THREADS 512
  ------------------
  |  Branch (699:7): [True: 0, False: 0]
  ------------------
  700|      0|#endif
  701|      0|  return 0;
  702|      0|}
VP8InitFrame:
  827|  2.48k|int VP8InitFrame(VP8Decoder* const dec, VP8Io* const io) {
  828|  2.48k|  if (!InitThreadContext(dec)) return 0;  // call first. Sets dec->num_caches.
  ------------------
  |  Branch (828:7): [True: 0, False: 2.48k]
  ------------------
  829|  2.48k|  if (!AllocateMemory(dec, io)) return 0;
  ------------------
  |  Branch (829:7): [True: 0, False: 2.48k]
  ------------------
  830|  2.48k|  InitIo(dec, io);
  831|  2.48k|  VP8DspInit();  // Init critical function pointers and look-up tables.
  832|  2.48k|  return 1;
  833|  2.48k|}
frame_dec.c:ReconstructRow:
   86|  32.5k|                           const VP8ThreadContext* ctx) {
   87|  32.5k|  int j;
   88|  32.5k|  int mb_x;
   89|  32.5k|  const int mb_y = ctx->mb_y;
   90|  32.5k|  const int cache_id = ctx->id;
   91|  32.5k|  uint8_t* const y_dst = dec->yuv_b + Y_OFF;
  ------------------
  |  |   67|  32.5k|#define Y_OFF (BPS * 1 + 8)
  |  |  ------------------
  |  |  |  |   33|  32.5k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
   92|  32.5k|  uint8_t* const u_dst = dec->yuv_b + U_OFF;
  ------------------
  |  |   68|  32.5k|#define U_OFF (Y_OFF + BPS * 16 + BPS)
  |  |  ------------------
  |  |  |  |   67|  32.5k|#define Y_OFF (BPS * 1 + 8)
  |  |  |  |  ------------------
  |  |  |  |  |  |   33|  32.5k|#define BPS 32  // this is the common stride for enc/dec
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define U_OFF (Y_OFF + BPS * 16 + BPS)
  |  |  ------------------
  |  |  |  |   33|  32.5k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  |  |               #define U_OFF (Y_OFF + BPS * 16 + BPS)
  |  |  ------------------
  |  |  |  |   33|  32.5k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
   93|  32.5k|  uint8_t* const v_dst = dec->yuv_b + V_OFF;
  ------------------
  |  |   69|  32.5k|#define V_OFF (U_OFF + 16)
  |  |  ------------------
  |  |  |  |   68|  32.5k|#define U_OFF (Y_OFF + BPS * 16 + BPS)
  |  |  |  |  ------------------
  |  |  |  |  |  |   67|  32.5k|#define Y_OFF (BPS * 1 + 8)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   33|  32.5k|#define BPS 32  // this is the common stride for enc/dec
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define U_OFF (Y_OFF + BPS * 16 + BPS)
  |  |  |  |  ------------------
  |  |  |  |  |  |   33|  32.5k|#define BPS 32  // this is the common stride for enc/dec
  |  |  |  |  ------------------
  |  |  |  |               #define U_OFF (Y_OFF + BPS * 16 + BPS)
  |  |  |  |  ------------------
  |  |  |  |  |  |   33|  32.5k|#define BPS 32  // this is the common stride for enc/dec
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   94|       |
   95|       |  // Initialize left-most block.
   96|   554k|  for (j = 0; j < 16; ++j) {
  ------------------
  |  Branch (96:15): [True: 521k, False: 32.5k]
  ------------------
   97|   521k|    y_dst[j * BPS - 1] = 129;
  ------------------
  |  |   33|   521k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
   98|   521k|  }
   99|   293k|  for (j = 0; j < 8; ++j) {
  ------------------
  |  Branch (99:15): [True: 260k, False: 32.5k]
  ------------------
  100|   260k|    u_dst[j * BPS - 1] = 129;
  ------------------
  |  |   33|   260k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  101|   260k|    v_dst[j * BPS - 1] = 129;
  ------------------
  |  |   33|   260k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  102|   260k|  }
  103|       |
  104|       |  // Init top-left sample on left column too.
  105|  32.5k|  if (mb_y > 0) {
  ------------------
  |  Branch (105:7): [True: 30.8k, False: 1.78k]
  ------------------
  106|  30.8k|    y_dst[-1 - BPS] = u_dst[-1 - BPS] = v_dst[-1 - BPS] = 129;
  ------------------
  |  |   33|  30.8k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
                  y_dst[-1 - BPS] = u_dst[-1 - BPS] = v_dst[-1 - BPS] = 129;
  ------------------
  |  |   33|  30.8k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
                  y_dst[-1 - BPS] = u_dst[-1 - BPS] = v_dst[-1 - BPS] = 129;
  ------------------
  |  |   33|  30.8k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  107|  30.8k|  } else {
  108|       |    // we only need to do this init once at block (0,0).
  109|       |    // Afterward, it remains valid for the whole topmost row.
  110|  1.78k|    WEBP_UNSAFE_MEMSET(y_dst - BPS - 1, 127, 16 + 4 + 1);
  ------------------
  |  |  175|  1.78k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  111|  1.78k|    WEBP_UNSAFE_MEMSET(u_dst - BPS - 1, 127, 8 + 1);
  ------------------
  |  |  175|  1.78k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  112|  1.78k|    WEBP_UNSAFE_MEMSET(v_dst - BPS - 1, 127, 8 + 1);
  ------------------
  |  |  175|  1.78k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  113|  1.78k|  }
  114|       |
  115|       |  // Reconstruct one row.
  116|  85.1k|  for (mb_x = 0; mb_x < dec->mb_w; ++mb_x) {
  ------------------
  |  Branch (116:18): [True: 52.5k, False: 32.5k]
  ------------------
  117|  52.5k|    const VP8MBData* const block = ctx->mb_data + mb_x;
  118|       |
  119|       |    // Rotate in the left samples from previously decoded block. We move four
  120|       |    // pixels at a time for alignment reason, and because of in-loop filter.
  121|  52.5k|    if (mb_x > 0) {
  ------------------
  |  Branch (121:9): [True: 19.9k, False: 32.5k]
  ------------------
  122|   359k|      for (j = -1; j < 16; ++j) {
  ------------------
  |  Branch (122:20): [True: 339k, False: 19.9k]
  ------------------
  123|   339k|        Copy32b(&y_dst[j * BPS - 4], &y_dst[j * BPS + 12]);
  ------------------
  |  |   33|   339k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
                      Copy32b(&y_dst[j * BPS - 4], &y_dst[j * BPS + 12]);
  ------------------
  |  |   33|   339k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  124|   339k|      }
  125|   199k|      for (j = -1; j < 8; ++j) {
  ------------------
  |  Branch (125:20): [True: 179k, False: 19.9k]
  ------------------
  126|   179k|        Copy32b(&u_dst[j * BPS - 4], &u_dst[j * BPS + 4]);
  ------------------
  |  |   33|   179k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
                      Copy32b(&u_dst[j * BPS - 4], &u_dst[j * BPS + 4]);
  ------------------
  |  |   33|   179k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  127|   179k|        Copy32b(&v_dst[j * BPS - 4], &v_dst[j * BPS + 4]);
  ------------------
  |  |   33|   179k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
                      Copy32b(&v_dst[j * BPS - 4], &v_dst[j * BPS + 4]);
  ------------------
  |  |   33|   179k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  128|   179k|      }
  129|  19.9k|    }
  130|  52.5k|    {
  131|       |      // bring top samples into the cache
  132|  52.5k|      VP8TopSamples* const top_yuv = dec->yuv_t + mb_x;
  133|  52.5k|      const int16_t* const coeffs = block->coeffs;
  134|  52.5k|      uint32_t bits = block->non_zero_y;
  135|  52.5k|      int n;
  136|       |
  137|  52.5k|      if (mb_y > 0) {
  ------------------
  |  Branch (137:11): [True: 32.8k, False: 19.6k]
  ------------------
  138|  32.8k|        WEBP_UNSAFE_MEMCPY(y_dst - BPS, top_yuv[0].y, 16);
  ------------------
  |  |  174|  32.8k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
  139|  32.8k|        WEBP_UNSAFE_MEMCPY(u_dst - BPS, top_yuv[0].u, 8);
  ------------------
  |  |  174|  32.8k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
  140|  32.8k|        WEBP_UNSAFE_MEMCPY(v_dst - BPS, top_yuv[0].v, 8);
  ------------------
  |  |  174|  32.8k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
  141|  32.8k|      }
  142|       |
  143|       |      // predict and add residuals
  144|  52.5k|      if (block->is_i4x4) {  // 4x4
  ------------------
  |  Branch (144:11): [True: 19.1k, False: 33.4k]
  ------------------
  145|  19.1k|        uint32_t* const top_right = (uint32_t*)(y_dst - BPS + 16);
  ------------------
  |  |   33|  19.1k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  146|       |
  147|  19.1k|        if (mb_y > 0) {
  ------------------
  |  Branch (147:13): [True: 11.3k, False: 7.76k]
  ------------------
  148|  11.3k|          if (mb_x >= dec->mb_w - 1) {  // on rightmost border
  ------------------
  |  Branch (148:15): [True: 10.6k, False: 645]
  ------------------
  149|  10.6k|            WEBP_UNSAFE_MEMSET(top_right, top_yuv[0].y[15], sizeof(*top_right));
  ------------------
  |  |  175|  10.6k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  150|  10.6k|          } else {
  151|    645|            WEBP_UNSAFE_MEMCPY(top_right, top_yuv[1].y, sizeof(*top_right));
  ------------------
  |  |  174|    645|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
  152|    645|          }
  153|  11.3k|        }
  154|       |        // replicate the top-right pixels below
  155|  19.1k|        top_right[BPS] = top_right[2 * BPS] = top_right[3 * BPS] = top_right[0];
  ------------------
  |  |   33|  19.1k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
                      top_right[BPS] = top_right[2 * BPS] = top_right[3 * BPS] = top_right[0];
  ------------------
  |  |   33|  19.1k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
                      top_right[BPS] = top_right[2 * BPS] = top_right[3 * BPS] = top_right[0];
  ------------------
  |  |   33|  19.1k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  156|       |
  157|       |        // predict and add residuals for all 4x4 blocks in turn.
  158|   324k|        for (n = 0; n < 16; ++n, bits <<= 2) {
  ------------------
  |  Branch (158:21): [True: 305k, False: 19.1k]
  ------------------
  159|   305k|          uint8_t* const dst = y_dst + kScan[n];
  160|   305k|          VP8PredLuma4[block->imodes[n]](dst);
  161|   305k|          DoTransform(bits, coeffs + n * 16, dst);
  162|   305k|        }
  163|  33.4k|      } else {  // 16x16
  164|  33.4k|        const int pred_func = CheckMode(mb_x, mb_y, block->imodes[0]);
  165|  33.4k|        VP8PredLuma16[pred_func](y_dst);
  166|  33.4k|        if (bits != 0) {
  ------------------
  |  Branch (166:13): [True: 7.47k, False: 26.0k]
  ------------------
  167|   127k|          for (n = 0; n < 16; ++n, bits <<= 2) {
  ------------------
  |  Branch (167:23): [True: 119k, False: 7.47k]
  ------------------
  168|   119k|            DoTransform(bits, coeffs + n * 16, y_dst + kScan[n]);
  169|   119k|          }
  170|  7.47k|        }
  171|  33.4k|      }
  172|  52.5k|      {
  173|       |        // Chroma
  174|  52.5k|        const uint32_t bits_uv = block->non_zero_uv;
  175|  52.5k|        const int pred_func = CheckMode(mb_x, mb_y, block->uvmode);
  176|  52.5k|        VP8PredChroma8[pred_func](u_dst);
  177|  52.5k|        VP8PredChroma8[pred_func](v_dst);
  178|  52.5k|        DoUVTransform(bits_uv >> 0, coeffs + 16 * 16, u_dst);
  179|  52.5k|        DoUVTransform(bits_uv >> 8, coeffs + 20 * 16, v_dst);
  180|  52.5k|      }
  181|       |
  182|       |      // stash away top samples for next block
  183|  52.5k|      if (mb_y < dec->mb_h - 1) {
  ------------------
  |  Branch (183:11): [True: 35.2k, False: 17.3k]
  ------------------
  184|  35.2k|        WEBP_UNSAFE_MEMCPY(top_yuv[0].y, y_dst + 15 * BPS, 16);
  ------------------
  |  |  174|  35.2k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
  185|  35.2k|        WEBP_UNSAFE_MEMCPY(top_yuv[0].u, u_dst + 7 * BPS, 8);
  ------------------
  |  |  174|  35.2k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
  186|  35.2k|        WEBP_UNSAFE_MEMCPY(top_yuv[0].v, v_dst + 7 * BPS, 8);
  ------------------
  |  |  174|  35.2k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
  187|  35.2k|      }
  188|  52.5k|    }
  189|       |    // Transfer reconstructed samples from yuv_b cache to final destination.
  190|  52.5k|    {
  191|  52.5k|      const int y_offset = cache_id * 16 * dec->cache_y_stride;
  192|  52.5k|      const int uv_offset = cache_id * 8 * dec->cache_uv_stride;
  193|  52.5k|      uint8_t* const y_out = dec->cache_y + mb_x * 16 + y_offset;
  194|  52.5k|      uint8_t* const u_out = dec->cache_u + mb_x * 8 + uv_offset;
  195|  52.5k|      uint8_t* const v_out = dec->cache_v + mb_x * 8 + uv_offset;
  196|   893k|      for (j = 0; j < 16; ++j) {
  ------------------
  |  Branch (196:19): [True: 841k, False: 52.5k]
  ------------------
  197|   841k|        WEBP_UNSAFE_MEMCPY(y_out + j * dec->cache_y_stride, y_dst + j * BPS,
  ------------------
  |  |  174|   841k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
  198|   841k|                           16);
  199|   841k|      }
  200|   473k|      for (j = 0; j < 8; ++j) {
  ------------------
  |  Branch (200:19): [True: 420k, False: 52.5k]
  ------------------
  201|   420k|        WEBP_UNSAFE_MEMCPY(u_out + j * dec->cache_uv_stride, u_dst + j * BPS,
  ------------------
  |  |  174|   420k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
  202|   420k|                           8);
  203|   420k|        WEBP_UNSAFE_MEMCPY(v_out + j * dec->cache_uv_stride, v_dst + j * BPS,
  ------------------
  |  |  174|   420k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
  204|   420k|                           8);
  205|   420k|      }
  206|  52.5k|    }
  207|  52.5k|  }
  208|  32.5k|}
frame_dec.c:Copy32b:
   53|   699k|static void Copy32b(uint8_t* const dst, const uint8_t* const src) {
   54|   699k|  WEBP_UNSAFE_MEMCPY(dst, src, 4);
  ------------------
  |  |  174|   699k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
   55|   699k|}
frame_dec.c:DoTransform:
   58|   425k|                                    uint8_t* const dst) {
   59|   425k|  switch (bits >> 30) {
   60|  14.9k|    case 3:
  ------------------
  |  Branch (60:5): [True: 14.9k, False: 410k]
  ------------------
   61|  14.9k|      VP8Transform(src, dst, 0);
   62|  14.9k|      break;
   63|  18.5k|    case 2:
  ------------------
  |  Branch (63:5): [True: 18.5k, False: 406k]
  ------------------
   64|  18.5k|      VP8TransformAC3(src, dst);
   65|  18.5k|      break;
   66|  86.1k|    case 1:
  ------------------
  |  Branch (66:5): [True: 86.1k, False: 339k]
  ------------------
   67|  86.1k|      VP8TransformDC(src, dst);
   68|  86.1k|      break;
   69|   305k|    default:
  ------------------
  |  Branch (69:5): [True: 305k, False: 119k]
  ------------------
   70|   305k|      break;
   71|   425k|  }
   72|   425k|}
frame_dec.c:CheckMode:
   42|  86.0k|static int CheckMode(int mb_x, int mb_y, int mode) {
   43|  86.0k|  if (mode == B_DC_PRED) {
  ------------------
  |  Branch (43:7): [True: 43.6k, False: 42.4k]
  ------------------
   44|  43.6k|    if (mb_x == 0) {
  ------------------
  |  Branch (44:9): [True: 25.8k, False: 17.8k]
  ------------------
   45|  25.8k|      return (mb_y == 0) ? B_DC_PRED_NOTOPLEFT : B_DC_PRED_NOLEFT;
  ------------------
  |  Branch (45:14): [True: 1.64k, False: 24.1k]
  ------------------
   46|  25.8k|    } else {
   47|  17.8k|      return (mb_y == 0) ? B_DC_PRED_NOTOP : B_DC_PRED;
  ------------------
  |  Branch (47:14): [True: 16.1k, False: 1.67k]
  ------------------
   48|  17.8k|    }
   49|  43.6k|  }
   50|  42.4k|  return mode;
   51|  86.0k|}
frame_dec.c:DoUVTransform:
   75|   105k|                          uint8_t* const dst) {
   76|   105k|  if (bits & 0xff) {             // any non-zero coeff at all?
  ------------------
  |  Branch (76:7): [True: 23.6k, False: 81.5k]
  ------------------
   77|  23.6k|    if (bits & 0xaa) {           // any non-zero AC coefficient?
  ------------------
  |  Branch (77:9): [True: 12.7k, False: 10.8k]
  ------------------
   78|  12.7k|      VP8TransformUV(src, dst);  // note we don't use the AC3 variant for U/V
   79|  12.7k|    } else {
   80|  10.8k|      VP8TransformDCUV(src, dst);
   81|  10.8k|    }
   82|  23.6k|  }
   83|   105k|}
frame_dec.c:FinishRow:
  423|  32.5k|WEBP_NODISCARD static int FinishRow(void* arg1, void* arg2) {
  424|  32.5k|  VP8Decoder* const dec = (VP8Decoder*)arg1;
  425|  32.5k|  VP8Io* const io = (VP8Io*)arg2;
  426|  32.5k|  int ok = 1;
  427|  32.5k|  const VP8ThreadContext* const ctx = &dec->thread_ctx;
  428|  32.5k|  const int cache_id = ctx->id;
  429|  32.5k|  const int extra_y_rows = kFilterExtraRows[dec->filter_type];
  430|  32.5k|  const int ysize = extra_y_rows * dec->cache_y_stride;
  431|  32.5k|  const int uvsize = (extra_y_rows / 2) * dec->cache_uv_stride;
  432|  32.5k|  const int y_offset = cache_id * 16 * dec->cache_y_stride;
  433|  32.5k|  const int uv_offset = cache_id * 8 * dec->cache_uv_stride;
  434|  32.5k|  uint8_t* const ydst = dec->cache_y - ysize + y_offset;
  435|  32.5k|  uint8_t* const udst = dec->cache_u - uvsize + uv_offset;
  436|  32.5k|  uint8_t* const vdst = dec->cache_v - uvsize + uv_offset;
  437|  32.5k|  const int mb_y = ctx->mb_y;
  438|  32.5k|  const int is_first_row = (mb_y == 0);
  439|  32.5k|  const int is_last_row = (mb_y >= dec->br_mb_y - 1);
  440|       |
  441|  32.5k|  if (dec->mt_method == 2) {
  ------------------
  |  Branch (441:7): [True: 0, False: 32.5k]
  ------------------
  442|      0|    ReconstructRow(dec, ctx);
  443|      0|  }
  444|       |
  445|  32.5k|  if (ctx->filter_row) {
  ------------------
  |  Branch (445:7): [True: 31.6k, False: 926]
  ------------------
  446|  31.6k|    FilterRow(dec);
  447|  31.6k|  }
  448|       |
  449|  32.5k|  if (dec->dither) {
  ------------------
  |  Branch (449:7): [True: 0, False: 32.5k]
  ------------------
  450|      0|    DitherRow(dec);
  451|      0|  }
  452|       |
  453|  32.5k|  if (io->put != NULL) {
  ------------------
  |  Branch (453:7): [True: 32.5k, False: 0]
  ------------------
  454|  32.5k|    int y_start = MACROBLOCK_VPOS(mb_y);
  ------------------
  |  |  420|  32.5k|#define MACROBLOCK_VPOS(mb_y) ((mb_y) * 16)  // vertical position of a MB
  ------------------
  455|  32.5k|    int y_end = MACROBLOCK_VPOS(mb_y + 1);
  ------------------
  |  |  420|  32.5k|#define MACROBLOCK_VPOS(mb_y) ((mb_y) * 16)  // vertical position of a MB
  ------------------
  456|  32.5k|    if (!is_first_row) {
  ------------------
  |  Branch (456:9): [True: 30.8k, False: 1.78k]
  ------------------
  457|  30.8k|      y_start -= extra_y_rows;
  458|  30.8k|      io->y = ydst;
  459|  30.8k|      io->u = udst;
  460|  30.8k|      io->v = vdst;
  461|  30.8k|    } else {
  462|  1.78k|      io->y = dec->cache_y + y_offset;
  463|  1.78k|      io->u = dec->cache_u + uv_offset;
  464|  1.78k|      io->v = dec->cache_v + uv_offset;
  465|  1.78k|    }
  466|       |
  467|  32.5k|    if (!is_last_row) {
  ------------------
  |  Branch (467:9): [True: 32.2k, False: 321]
  ------------------
  468|  32.2k|      y_end -= extra_y_rows;
  469|  32.2k|    }
  470|  32.5k|    if (y_end > io->crop_bottom) {
  ------------------
  |  Branch (470:9): [True: 296, False: 32.2k]
  ------------------
  471|    296|      y_end = io->crop_bottom;  // make sure we don't overflow on last row.
  472|    296|    }
  473|       |    // If dec->alpha_data is not NULL, we have some alpha plane present.
  474|  32.5k|    io->a = NULL;
  475|  32.5k|    if (dec->alpha_data != NULL && y_start < y_end) {
  ------------------
  |  Branch (475:9): [True: 0, False: 32.5k]
  |  Branch (475:36): [True: 0, False: 0]
  ------------------
  476|      0|      io->a = VP8DecompressAlphaRows(dec, io, y_start, y_end - y_start);
  477|      0|      if (io->a == NULL) {
  ------------------
  |  Branch (477:11): [True: 0, False: 0]
  ------------------
  478|      0|        return VP8SetError(dec, VP8_STATUS_BITSTREAM_ERROR,
  479|      0|                           "Could not decode alpha data.");
  480|      0|      }
  481|      0|    }
  482|  32.5k|    if (y_start < io->crop_top) {
  ------------------
  |  Branch (482:9): [True: 0, False: 32.5k]
  ------------------
  483|      0|      const int delta_y = io->crop_top - y_start;
  484|      0|      y_start = io->crop_top;
  485|      0|      assert(!(delta_y & 1));
  486|      0|      if (y_start < y_end) {
  ------------------
  |  Branch (486:11): [True: 0, False: 0]
  ------------------
  487|      0|        io->y += dec->cache_y_stride * delta_y;
  488|      0|        io->u += dec->cache_uv_stride * (delta_y >> 1);
  489|      0|        io->v += dec->cache_uv_stride * (delta_y >> 1);
  490|      0|        if (io->a != NULL) {
  ------------------
  |  Branch (490:13): [True: 0, False: 0]
  ------------------
  491|      0|          io->a += (ptrdiff_t)io->width * delta_y;
  492|      0|        }
  493|      0|      }
  494|      0|    }
  495|  32.5k|    if (y_start < y_end) {
  ------------------
  |  Branch (495:9): [True: 32.5k, False: 0]
  ------------------
  496|  32.5k|      io->y += io->crop_left;
  497|  32.5k|      io->u += io->crop_left >> 1;
  498|  32.5k|      io->v += io->crop_left >> 1;
  499|  32.5k|      if (io->a != NULL) {
  ------------------
  |  Branch (499:11): [True: 0, False: 32.5k]
  ------------------
  500|      0|        io->a += io->crop_left;
  501|      0|      }
  502|  32.5k|      io->mb_y = y_start - io->crop_top;
  503|  32.5k|      io->mb_w = io->crop_right - io->crop_left;
  504|  32.5k|      io->mb_h = y_end - y_start;
  505|  32.5k|      ok = io->put(io);
  506|  32.5k|    }
  507|  32.5k|  }
  508|       |  // rotate top samples if needed
  509|  32.5k|  if (cache_id + 1 == dec->num_caches) {
  ------------------
  |  Branch (509:7): [True: 32.5k, False: 0]
  ------------------
  510|  32.5k|    if (!is_last_row) {
  ------------------
  |  Branch (510:9): [True: 32.2k, False: 321]
  ------------------
  511|  32.2k|      WEBP_UNSAFE_MEMCPY(dec->cache_y - ysize, ydst + 16 * dec->cache_y_stride,
  ------------------
  |  |  174|  32.2k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
  512|  32.2k|                         ysize);
  513|  32.2k|      WEBP_UNSAFE_MEMCPY(dec->cache_u - uvsize, udst + 8 * dec->cache_uv_stride,
  ------------------
  |  |  174|  32.2k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
  514|  32.2k|                         uvsize);
  515|  32.2k|      WEBP_UNSAFE_MEMCPY(dec->cache_v - uvsize, vdst + 8 * dec->cache_uv_stride,
  ------------------
  |  |  174|  32.2k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
  516|  32.2k|                         uvsize);
  517|  32.2k|    }
  518|  32.5k|  }
  519|       |
  520|  32.5k|  return ok;
  521|  32.5k|}
frame_dec.c:FilterRow:
  270|  31.6k|static void FilterRow(const VP8Decoder* const dec) {
  271|  31.6k|  int mb_x;
  272|  31.6k|  const int mb_y = dec->thread_ctx.mb_y;
  273|  31.6k|  assert(dec->thread_ctx.filter_row);
  274|  83.0k|  for (mb_x = dec->tl_mb_x; mb_x < dec->br_mb_x; ++mb_x) {
  ------------------
  |  Branch (274:29): [True: 51.3k, False: 31.6k]
  ------------------
  275|  51.3k|    DoFilter(dec, mb_x, mb_y);
  276|  51.3k|  }
  277|  31.6k|}
frame_dec.c:DoFilter:
  220|  51.3k|static void DoFilter(const VP8Decoder* const dec, int mb_x, int mb_y) {
  221|  51.3k|  const VP8ThreadContext* const ctx = &dec->thread_ctx;
  222|  51.3k|  const int cache_id = ctx->id;
  223|  51.3k|  const int y_bps = dec->cache_y_stride;
  224|  51.3k|  const VP8FInfo* const f_info = ctx->f_info + mb_x;
  225|  51.3k|  uint8_t* const y_dst = dec->cache_y + cache_id * 16 * y_bps + mb_x * 16;
  226|  51.3k|  const int ilevel = f_info->f_ilevel;
  227|  51.3k|  const int limit = f_info->f_limit;
  228|  51.3k|  if (limit == 0) {
  ------------------
  |  Branch (228:7): [True: 10.3k, False: 40.9k]
  ------------------
  229|  10.3k|    return;
  230|  10.3k|  }
  231|  51.3k|  assert(limit >= 3);
  232|  40.9k|  if (dec->filter_type == 1) {  // simple
  ------------------
  |  Branch (232:7): [True: 13.5k, False: 27.4k]
  ------------------
  233|  13.5k|    if (mb_x > 0) {
  ------------------
  |  Branch (233:9): [True: 5.25k, False: 8.27k]
  ------------------
  234|  5.25k|      VP8SimpleHFilter16(y_dst, y_bps, limit + 4);
  235|  5.25k|    }
  236|  13.5k|    if (f_info->f_inner) {
  ------------------
  |  Branch (236:9): [True: 8.36k, False: 5.16k]
  ------------------
  237|  8.36k|      VP8SimpleHFilter16i(y_dst, y_bps, limit);
  238|  8.36k|    }
  239|  13.5k|    if (mb_y > 0) {
  ------------------
  |  Branch (239:9): [True: 8.00k, False: 5.52k]
  ------------------
  240|  8.00k|      VP8SimpleVFilter16(y_dst, y_bps, limit + 4);
  241|  8.00k|    }
  242|  13.5k|    if (f_info->f_inner) {
  ------------------
  |  Branch (242:9): [True: 8.36k, False: 5.16k]
  ------------------
  243|  8.36k|      VP8SimpleVFilter16i(y_dst, y_bps, limit);
  244|  8.36k|    }
  245|  27.4k|  } else {  // complex
  246|  27.4k|    const int uv_bps = dec->cache_uv_stride;
  247|  27.4k|    uint8_t* const u_dst = dec->cache_u + cache_id * 8 * uv_bps + mb_x * 8;
  248|  27.4k|    uint8_t* const v_dst = dec->cache_v + cache_id * 8 * uv_bps + mb_x * 8;
  249|  27.4k|    const int hev_thresh = f_info->hev_thresh;
  250|  27.4k|    if (mb_x > 0) {
  ------------------
  |  Branch (250:9): [True: 8.72k, False: 18.7k]
  ------------------
  251|  8.72k|      VP8HFilter16(y_dst, y_bps, limit + 4, ilevel, hev_thresh);
  252|  8.72k|      VP8HFilter8(u_dst, v_dst, uv_bps, limit + 4, ilevel, hev_thresh);
  253|  8.72k|    }
  254|  27.4k|    if (f_info->f_inner) {
  ------------------
  |  Branch (254:9): [True: 17.4k, False: 9.99k]
  ------------------
  255|  17.4k|      VP8HFilter16i(y_dst, y_bps, limit, ilevel, hev_thresh);
  256|  17.4k|      VP8HFilter8i(u_dst, v_dst, uv_bps, limit, ilevel, hev_thresh);
  257|  17.4k|    }
  258|  27.4k|    if (mb_y > 0) {
  ------------------
  |  Branch (258:9): [True: 18.8k, False: 8.56k]
  ------------------
  259|  18.8k|      VP8VFilter16(y_dst, y_bps, limit + 4, ilevel, hev_thresh);
  260|  18.8k|      VP8VFilter8(u_dst, v_dst, uv_bps, limit + 4, ilevel, hev_thresh);
  261|  18.8k|    }
  262|  27.4k|    if (f_info->f_inner) {
  ------------------
  |  Branch (262:9): [True: 17.4k, False: 9.99k]
  ------------------
  263|  17.4k|      VP8VFilter16i(y_dst, y_bps, limit, ilevel, hev_thresh);
  264|  17.4k|      VP8VFilter8i(u_dst, v_dst, uv_bps, limit, ilevel, hev_thresh);
  265|  17.4k|    }
  266|  27.4k|  }
  267|  40.9k|}
frame_dec.c:PrecomputeFilterStrengths:
  282|  2.48k|static void PrecomputeFilterStrengths(VP8Decoder* const dec) {
  283|  2.48k|  if (dec->filter_type > 0) {
  ------------------
  |  Branch (283:7): [True: 2.33k, False: 146]
  ------------------
  284|  2.33k|    int s;
  285|  2.33k|    const VP8FilterHeader* const hdr = &dec->filter_hdr;
  286|  11.6k|    for (s = 0; s < NUM_MB_SEGMENTS; ++s) {
  ------------------
  |  Branch (286:17): [True: 9.34k, False: 2.33k]
  ------------------
  287|  9.34k|      int i4x4;
  288|       |      // First, compute the initial level
  289|  9.34k|      int base_level;
  290|  9.34k|      if (dec->segment_hdr.use_segment) {
  ------------------
  |  Branch (290:11): [True: 1.32k, False: 8.02k]
  ------------------
  291|  1.32k|        base_level = dec->segment_hdr.filter_strength[s];
  292|  1.32k|        if (!dec->segment_hdr.absolute_delta) {
  ------------------
  |  Branch (292:13): [True: 368, False: 960]
  ------------------
  293|    368|          base_level += hdr->level;
  294|    368|        }
  295|  8.02k|      } else {
  296|  8.02k|        base_level = hdr->level;
  297|  8.02k|      }
  298|  28.0k|      for (i4x4 = 0; i4x4 <= 1; ++i4x4) {
  ------------------
  |  Branch (298:22): [True: 18.6k, False: 9.34k]
  ------------------
  299|  18.6k|        VP8FInfo* const info = &dec->fstrengths[s][i4x4];
  300|  18.6k|        int level = base_level;
  301|  18.6k|        if (hdr->use_lf_delta) {
  ------------------
  |  Branch (301:13): [True: 2.52k, False: 16.1k]
  ------------------
  302|  2.52k|          level += hdr->ref_lf_delta[0];
  303|  2.52k|          if (i4x4) {
  ------------------
  |  Branch (303:15): [True: 1.26k, False: 1.26k]
  ------------------
  304|  1.26k|            level += hdr->mode_lf_delta[0];
  305|  1.26k|          }
  306|  2.52k|        }
  307|  18.6k|        level = (level < 0) ? 0 : (level > 63) ? 63 : level;
  ------------------
  |  Branch (307:17): [True: 653, False: 18.0k]
  |  Branch (307:35): [True: 134, False: 17.9k]
  ------------------
  308|  18.6k|        if (level > 0) {
  ------------------
  |  Branch (308:13): [True: 16.7k, False: 1.94k]
  ------------------
  309|  16.7k|          int ilevel = level;
  310|  16.7k|          if (hdr->sharpness > 0) {
  ------------------
  |  Branch (310:15): [True: 11.7k, False: 5.01k]
  ------------------
  311|  11.7k|            if (hdr->sharpness > 4) {
  ------------------
  |  Branch (311:17): [True: 3.61k, False: 8.12k]
  ------------------
  312|  3.61k|              ilevel >>= 2;
  313|  8.12k|            } else {
  314|  8.12k|              ilevel >>= 1;
  315|  8.12k|            }
  316|  11.7k|            if (ilevel > 9 - hdr->sharpness) {
  ------------------
  |  Branch (316:17): [True: 9.14k, False: 2.59k]
  ------------------
  317|  9.14k|              ilevel = 9 - hdr->sharpness;
  318|  9.14k|            }
  319|  11.7k|          }
  320|  16.7k|          if (ilevel < 1) ilevel = 1;
  ------------------
  |  Branch (320:15): [True: 470, False: 16.2k]
  ------------------
  321|  16.7k|          info->f_ilevel = ilevel;
  322|  16.7k|          info->f_limit = 2 * level + ilevel;
  323|  16.7k|          info->hev_thresh = (level >= 40) ? 2 : (level >= 15) ? 1 : 0;
  ------------------
  |  Branch (323:30): [True: 5.09k, False: 11.6k]
  |  Branch (323:50): [True: 7.01k, False: 4.64k]
  ------------------
  324|  16.7k|        } else {
  325|  1.94k|          info->f_limit = 0;  // no filtering
  326|  1.94k|        }
  327|  18.6k|        info->f_inner = i4x4;
  328|  18.6k|      }
  329|  9.34k|    }
  330|  2.33k|  }
  331|  2.48k|}
frame_dec.c:InitThreadContext:
  669|  2.48k|WEBP_NODISCARD static int InitThreadContext(VP8Decoder* const dec) {
  670|  2.48k|  dec->cache_id = 0;
  671|  2.48k|  if (dec->mt_method > 0) {
  ------------------
  |  Branch (671:7): [True: 0, False: 2.48k]
  ------------------
  672|      0|    WebPWorker* const worker = &dec->worker;
  673|      0|    if (!WebPGetWorkerInterface()->Reset(worker)) {
  ------------------
  |  Branch (673:9): [True: 0, False: 0]
  ------------------
  674|      0|      return VP8SetError(dec, VP8_STATUS_OUT_OF_MEMORY,
  675|      0|                         "thread initialization failed.");
  676|      0|    }
  677|      0|    worker->data1 = dec;
  678|      0|    worker->data2 = (void*)&dec->thread_ctx.io;
  679|      0|    worker->hook = FinishRow;
  680|      0|    dec->num_caches =
  681|      0|        (dec->filter_type > 0) ? MT_CACHE_LINES : MT_CACHE_LINES - 1;
  ------------------
  |  |  665|      0|#define MT_CACHE_LINES 3
  ------------------
                      (dec->filter_type > 0) ? MT_CACHE_LINES : MT_CACHE_LINES - 1;
  ------------------
  |  |  665|      0|#define MT_CACHE_LINES 3
  ------------------
  |  Branch (681:9): [True: 0, False: 0]
  ------------------
  682|  2.48k|  } else {
  683|  2.48k|    dec->num_caches = ST_CACHE_LINES;
  ------------------
  |  |  666|  2.48k|#define ST_CACHE_LINES 1  // 1 cache row only for single-threaded case
  ------------------
  684|  2.48k|  }
  685|  2.48k|  return 1;
  686|  2.48k|}
frame_dec.c:AllocateMemory:
  711|  2.48k|                                         const VP8Io* const io) {
  712|  2.48k|  const int num_caches = dec->num_caches;
  713|  2.48k|  const int mb_w = dec->mb_w;
  714|       |  // Note: we use 'size_t' when there's no overflow risk, uint64_t otherwise.
  715|  2.48k|  const size_t intra_pred_mode_size = 4 * mb_w * sizeof(uint8_t);
  716|  2.48k|  const size_t top_size = sizeof(VP8TopSamples) * mb_w;
  717|  2.48k|  const size_t mb_info_size = (mb_w + 1) * sizeof(VP8MB);
  718|  2.48k|  const size_t f_info_size =
  719|  2.48k|      (dec->filter_type > 0)
  ------------------
  |  Branch (719:7): [True: 2.33k, False: 146]
  ------------------
  720|  2.48k|          ? mb_w * (dec->mt_method > 0 ? 2 : 1) * sizeof(VP8FInfo)
  ------------------
  |  Branch (720:21): [True: 0, False: 2.33k]
  ------------------
  721|  2.48k|          : 0;
  722|  2.48k|  const size_t yuv_size = YUV_SIZE * sizeof(*dec->yuv_b);
  ------------------
  |  |   66|  2.48k|#define YUV_SIZE (BPS * 17 + BPS * 9)
  |  |  ------------------
  |  |  |  |   33|  2.48k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  |  |               #define YUV_SIZE (BPS * 17 + BPS * 9)
  |  |  ------------------
  |  |  |  |   33|  2.48k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
  723|  2.48k|  const size_t mb_data_size =
  724|  2.48k|      (dec->mt_method == 2 ? 2 : 1) * mb_w * sizeof(*dec->mb_data);
  ------------------
  |  Branch (724:8): [True: 0, False: 2.48k]
  ------------------
  725|  2.48k|  const int cache_y_stride = 16 * mb_w;
  726|  2.48k|  const size_t cache_height =
  727|  2.48k|      (16 * num_caches + kFilterExtraRows[dec->filter_type]) * 3 / 2;
  728|  2.48k|  const size_t cache_size = (size_t)cache_y_stride * cache_height;
  729|       |  // alpha_size is the only one that may scale with height.
  730|  2.48k|  const uint64_t alpha_size =
  731|  2.48k|      (uint64_t)dec->pic_hdr.width * WebPGetAlphaWindowRows(dec, io);
  732|  2.48k|  const uint64_t needed = (uint64_t)intra_pred_mode_size + top_size +
  733|  2.48k|                          mb_info_size + f_info_size + yuv_size + mb_data_size +
  734|  2.48k|                          cache_size + alpha_size + WEBP_ALIGN_CST;
  ------------------
  |  |   70|  2.48k|#define WEBP_ALIGN_CST 31
  ------------------
  735|  2.48k|  uint8_t* mem;
  736|       |
  737|  2.48k|  if (!CheckSizeOverflow(needed)) {
  ------------------
  |  Branch (737:7): [True: 0, False: 2.48k]
  ------------------
  738|      0|    return VP8SetError(dec, VP8_STATUS_OUT_OF_MEMORY,
  739|      0|                       "frame memory size overflow.");
  740|      0|  }
  741|  2.48k|  if (needed > dec->mem_size) {
  ------------------
  |  Branch (741:7): [True: 2.48k, False: 0]
  ------------------
  742|  2.48k|    WebPSafeFree(dec->mem);
  743|  2.48k|    dec->mem_size = 0;
  744|  2.48k|    dec->mem = WebPSafeMalloc(needed, sizeof(uint8_t));
  745|  2.48k|    if (dec->mem == NULL) {
  ------------------
  |  Branch (745:9): [True: 0, False: 2.48k]
  ------------------
  746|      0|      return VP8SetError(dec, VP8_STATUS_OUT_OF_MEMORY,
  747|      0|                         "no memory during frame initialization.");
  748|      0|    }
  749|       |    // down-cast is ok, thanks to WebPSafeMalloc() above.
  750|  2.48k|    dec->mem_size = (size_t)needed;
  751|  2.48k|  }
  752|       |
  753|  2.48k|  mem = (uint8_t*)dec->mem;
  754|  2.48k|  dec->intra_t = mem;
  755|  2.48k|  mem += intra_pred_mode_size;
  756|       |
  757|  2.48k|  dec->yuv_t = (VP8TopSamples*)mem;
  758|  2.48k|  mem += top_size;
  759|       |
  760|  2.48k|  dec->mb_info = ((VP8MB*)mem) + 1;
  761|  2.48k|  mem += mb_info_size;
  762|       |
  763|  2.48k|  dec->f_info = f_info_size ? (VP8FInfo*)mem : NULL;
  ------------------
  |  Branch (763:17): [True: 2.33k, False: 146]
  ------------------
  764|  2.48k|  mem += f_info_size;
  765|  2.48k|  dec->thread_ctx.id = 0;
  766|  2.48k|  dec->thread_ctx.f_info = dec->f_info;
  767|  2.48k|  if (dec->filter_type > 0 && dec->mt_method > 0) {
  ------------------
  |  Branch (767:7): [True: 2.33k, False: 146]
  |  Branch (767:31): [True: 0, False: 2.33k]
  ------------------
  768|       |    // secondary cache line. The deblocking process need to make use of the
  769|       |    // filtering strength from previous macroblock row, while the new ones
  770|       |    // are being decoded in parallel. We'll just swap the pointers.
  771|      0|    dec->thread_ctx.f_info += mb_w;
  772|      0|  }
  773|       |
  774|  2.48k|  mem = (uint8_t*)WEBP_ALIGN(mem);
  ------------------
  |  |   72|  2.48k|  (((uintptr_t)(PTR) + WEBP_ALIGN_CST) & ~(uintptr_t)WEBP_ALIGN_CST)
  |  |  ------------------
  |  |  |  |   70|  2.48k|#define WEBP_ALIGN_CST 31
  |  |  ------------------
  |  |                 (((uintptr_t)(PTR) + WEBP_ALIGN_CST) & ~(uintptr_t)WEBP_ALIGN_CST)
  |  |  ------------------
  |  |  |  |   70|  2.48k|#define WEBP_ALIGN_CST 31
  |  |  ------------------
  ------------------
  775|  2.48k|  assert((yuv_size & WEBP_ALIGN_CST) == 0);
  776|  2.48k|  dec->yuv_b = mem;
  777|  2.48k|  mem += yuv_size;
  778|       |
  779|  2.48k|  dec->mb_data = (VP8MBData*)mem;
  780|  2.48k|  dec->thread_ctx.mb_data = (VP8MBData*)mem;
  781|  2.48k|  if (dec->mt_method == 2) {
  ------------------
  |  Branch (781:7): [True: 0, False: 2.48k]
  ------------------
  782|      0|    dec->thread_ctx.mb_data += mb_w;
  783|      0|  }
  784|  2.48k|  mem += mb_data_size;
  785|       |
  786|  2.48k|  dec->cache_y_stride = cache_y_stride;
  787|  2.48k|  dec->cache_uv_stride = 8 * mb_w;
  788|  2.48k|  {
  789|  2.48k|    const int extra_rows = kFilterExtraRows[dec->filter_type];
  790|  2.48k|    const int extra_y = extra_rows * dec->cache_y_stride;
  791|  2.48k|    const int extra_uv = (extra_rows / 2) * dec->cache_uv_stride;
  792|  2.48k|    dec->cache_y = mem + extra_y;
  793|  2.48k|    dec->cache_u =
  794|  2.48k|        dec->cache_y + 16 * num_caches * dec->cache_y_stride + extra_uv;
  795|  2.48k|    dec->cache_v =
  796|  2.48k|        dec->cache_u + 8 * num_caches * dec->cache_uv_stride + extra_uv;
  797|  2.48k|    dec->cache_id = 0;
  798|  2.48k|  }
  799|  2.48k|  mem += cache_size;
  800|       |
  801|       |  // alpha plane
  802|  2.48k|  dec->alpha_plane = alpha_size ? mem : NULL;
  ------------------
  |  Branch (802:22): [True: 0, False: 2.48k]
  ------------------
  803|  2.48k|  mem += alpha_size;
  804|  2.48k|  assert(mem <= (uint8_t*)dec->mem + dec->mem_size);
  805|       |
  806|       |  // note: left/top-info is initialized once for all.
  807|  2.48k|  WEBP_UNSAFE_MEMSET(dec->mb_info - 1, 0, mb_info_size);
  ------------------
  |  |  175|  2.48k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  808|  2.48k|  VP8InitScanline(dec);  // initialize left too.
  809|       |
  810|       |  // initialize top
  811|  2.48k|  WEBP_UNSAFE_MEMSET(dec->intra_t, B_DC_PRED, intra_pred_mode_size);
  ------------------
  |  |  175|  2.48k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  812|       |
  813|  2.48k|  return 1;
  814|  2.48k|}
frame_dec.c:InitIo:
  816|  2.48k|static void InitIo(VP8Decoder* const dec, VP8Io* io) {
  817|       |  // prepare 'io'
  818|  2.48k|  io->mb_y = 0;
  819|  2.48k|  io->y = dec->cache_y;
  820|  2.48k|  io->u = dec->cache_u;
  821|  2.48k|  io->v = dec->cache_v;
  822|  2.48k|  io->y_stride = dec->cache_y_stride;
  823|  2.48k|  io->uv_stride = dec->cache_uv_stride;
  824|       |  io->a = NULL;
  825|  2.48k|}

WebPInitCustomIo:
  709|  4.73k|void WebPInitCustomIo(WebPDecParams* const params, VP8Io* const io) {
  710|  4.73k|  io->put = CustomPut;
  711|  4.73k|  io->setup = CustomSetup;
  712|  4.73k|  io->teardown = CustomTeardown;
  713|  4.73k|  io->opaque = params;
  714|  4.73k|}
io_dec.c:CustomPut:
  680|  32.5k|WEBP_NODISCARD static int CustomPut(const VP8Io* io) {
  681|  32.5k|  WebPDecParams* const p = (WebPDecParams*)io->opaque;
  682|  32.5k|  const int mb_w = io->mb_w;
  683|  32.5k|  const int mb_h = io->mb_h;
  684|  32.5k|  int num_lines_out;
  685|  32.5k|  assert(!(io->mb_y & 1));
  686|       |
  687|  32.5k|  if (mb_w <= 0 || mb_h <= 0) {
  ------------------
  |  Branch (687:7): [True: 0, False: 32.5k]
  |  Branch (687:20): [True: 0, False: 32.5k]
  ------------------
  688|      0|    return 0;
  689|      0|  }
  690|  32.5k|  num_lines_out = p->emit(io, p);
  691|  32.5k|  if (p->emit_alpha != NULL) {
  ------------------
  |  Branch (691:7): [True: 16.3k, False: 16.2k]
  ------------------
  692|  16.3k|    p->emit_alpha(io, p, num_lines_out);
  693|  16.3k|  }
  694|  32.5k|  p->last_y += num_lines_out;
  695|  32.5k|  return 1;
  696|  32.5k|}
io_dec.c:CustomSetup:
  610|  2.48k|WEBP_NODISCARD static int CustomSetup(VP8Io* io) {
  611|  2.48k|  WebPDecParams* const p = (WebPDecParams*)io->opaque;
  612|  2.48k|  const WEBP_CSP_MODE colorspace = p->output->colorspace;
  613|  2.48k|  const int is_rgb = WebPIsRGBMode(colorspace);
  614|  2.48k|  const int is_alpha = WebPIsAlphaMode(colorspace);
  615|       |
  616|  2.48k|  p->memory = NULL;
  617|  2.48k|  p->status = VP8_STATUS_OK;
  618|  2.48k|  p->emit = NULL;
  619|  2.48k|  p->emit_alpha = NULL;
  620|  2.48k|  p->emit_alpha_row = NULL;
  621|       |  // Note: WebPIoInitFromOptions() does not distinguish between MODE_YUV and
  622|       |  // MODE_YUVA, only RGB vs YUV.
  623|  2.48k|  if (!WebPIoInitFromOptions(p->options, io, /*src_colorspace=*/MODE_YUV)) {
  ------------------
  |  Branch (623:7): [True: 0, False: 2.48k]
  ------------------
  624|      0|    return 0;
  625|      0|  }
  626|  2.48k|  if (is_alpha && WebPIsPremultipliedMode(colorspace)) {
  ------------------
  |  Branch (626:7): [True: 1.20k, False: 1.28k]
  |  Branch (626:19): [True: 0, False: 1.20k]
  ------------------
  627|      0|    WebPInitUpsamplers();
  628|      0|  }
  629|  2.48k|  if (io->use_scaling) {
  ------------------
  |  Branch (629:7): [True: 0, False: 2.48k]
  ------------------
  630|      0|#if !defined(WEBP_REDUCE_SIZE)
  631|      0|    const int ok = is_rgb ? InitRGBRescaler(io, p) : InitYUVRescaler(io, p);
  ------------------
  |  Branch (631:20): [True: 0, False: 0]
  ------------------
  632|      0|    if (!ok) {
  ------------------
  |  Branch (632:9): [True: 0, False: 0]
  ------------------
  633|      0|      WebPSafeFree(p->memory);
  634|      0|      p->memory = NULL;
  635|      0|      p->status = VP8_STATUS_OUT_OF_MEMORY;
  636|      0|      return 0;  // memory error
  637|      0|    }
  638|       |#else
  639|       |    return 0;  // rescaling support not compiled
  640|       |#endif
  641|  2.48k|  } else {
  642|  2.48k|    if (is_rgb) {
  ------------------
  |  Branch (642:9): [True: 2.15k, False: 329]
  ------------------
  643|  2.15k|      WebPInitSamplers();
  644|  2.15k|      p->emit = EmitSampledRGB;  // default
  645|  2.15k|      if (io->fancy_upsampling) {
  ------------------
  |  Branch (645:11): [True: 2.15k, False: 0]
  ------------------
  646|  2.15k|#ifdef FANCY_UPSAMPLING
  647|  2.15k|        const int uv_width = (io->mb_w + 1) >> 1;
  648|  2.15k|        p->memory = WebPSafeMalloc(1ULL, (size_t)(io->mb_w + 2 * uv_width));
  649|  2.15k|        if (p->memory == NULL) {
  ------------------
  |  Branch (649:13): [True: 0, False: 2.15k]
  ------------------
  650|      0|          p->status = VP8_STATUS_OUT_OF_MEMORY;
  651|      0|          return 0;  // memory error.
  652|      0|        }
  653|  2.15k|        p->tmp_y = (uint8_t*)p->memory;
  654|  2.15k|        p->tmp_u = p->tmp_y + io->mb_w;
  655|  2.15k|        p->tmp_v = p->tmp_u + uv_width;
  656|  2.15k|        p->emit = EmitFancyRGB;
  657|  2.15k|        WebPInitUpsamplers();
  658|  2.15k|#endif
  659|  2.15k|      }
  660|  2.15k|    } else {
  661|    329|      p->emit = EmitYUV;
  662|    329|    }
  663|  2.48k|    if (is_alpha) {  // need transparency output
  ------------------
  |  Branch (663:9): [True: 1.20k, False: 1.28k]
  ------------------
  664|  1.20k|      p->emit_alpha =
  665|  1.20k|          (colorspace == MODE_RGBA_4444 || colorspace == MODE_rgbA_4444)
  ------------------
  |  Branch (665:12): [True: 0, False: 1.20k]
  |  Branch (665:44): [True: 0, False: 1.20k]
  ------------------
  666|  1.20k|              ? EmitAlphaRGBA4444
  667|  1.20k|          : is_rgb ? EmitAlphaRGB
  ------------------
  |  Branch (667:13): [True: 1.20k, False: 0]
  ------------------
  668|  1.20k|                   : EmitAlphaYUV;
  669|  1.20k|      if (is_rgb) {
  ------------------
  |  Branch (669:11): [True: 1.20k, False: 0]
  ------------------
  670|  1.20k|        WebPInitAlphaProcessing();
  671|  1.20k|      }
  672|  1.20k|    }
  673|  2.48k|  }
  674|       |
  675|  2.48k|  return 1;
  676|  2.48k|}
io_dec.c:EmitFancyRGB:
   66|  27.7k|static int EmitFancyRGB(const VP8Io* const io, WebPDecParams* const p) {
   67|  27.7k|  int num_lines_out = io->mb_h;  // a priori guess
   68|  27.7k|  const WebPRGBABuffer* const buf = &p->output->u.RGBA;
   69|  27.7k|  uint8_t* dst = buf->rgba + (ptrdiff_t)io->mb_y * buf->stride;
   70|  27.7k|  WebPUpsampleLinePairFunc upsample = WebPUpsamplers[p->output->colorspace];
   71|  27.7k|  const uint8_t* cur_y = io->y;
   72|  27.7k|  const uint8_t* cur_u = io->u;
   73|  27.7k|  const uint8_t* cur_v = io->v;
   74|  27.7k|  const uint8_t* top_u = p->tmp_u;
   75|  27.7k|  const uint8_t* top_v = p->tmp_v;
   76|  27.7k|  int y = io->mb_y;
   77|  27.7k|  const int y_end = io->mb_y + io->mb_h;
   78|  27.7k|  const int mb_w = io->mb_w;
   79|  27.7k|  const int uv_w = (mb_w + 1) / 2;
   80|       |
   81|  27.7k|  if (y == 0) {
  ------------------
  |  Branch (81:7): [True: 1.60k, False: 26.1k]
  ------------------
   82|       |    // First line is special cased. We mirror the u/v samples at boundary.
   83|  1.60k|    upsample(cur_y, NULL, cur_u, cur_v, cur_u, cur_v, dst, NULL, mb_w);
   84|  26.1k|  } else {
   85|       |    // We can finish the left-over line from previous call.
   86|  26.1k|    upsample(p->tmp_y, cur_y, top_u, top_v, cur_u, cur_v, dst - buf->stride,
   87|  26.1k|             dst, mb_w);
   88|  26.1k|    ++num_lines_out;
   89|  26.1k|  }
   90|       |  // Loop over each output pairs of row.
   91|   217k|  for (; y + 2 < y_end; y += 2) {
  ------------------
  |  Branch (91:10): [True: 189k, False: 27.7k]
  ------------------
   92|   189k|    top_u = cur_u;
   93|   189k|    top_v = cur_v;
   94|   189k|    cur_u += io->uv_stride;
   95|   189k|    cur_v += io->uv_stride;
   96|   189k|    dst += 2 * (ptrdiff_t)buf->stride;
   97|   189k|    cur_y += 2 * (ptrdiff_t)io->y_stride;
   98|   189k|    upsample(cur_y - io->y_stride, cur_y, top_u, top_v, cur_u, cur_v,
   99|   189k|             dst - buf->stride, dst, mb_w);
  100|   189k|  }
  101|       |  // move to last row
  102|  27.7k|  cur_y += io->y_stride;
  103|  27.7k|  if (io->crop_top + y_end < io->crop_bottom) {
  ------------------
  |  Branch (103:7): [True: 27.4k, False: 303]
  ------------------
  104|       |    // Save the unfinished samples for next call (as we're not done yet).
  105|  27.4k|    WEBP_UNSAFE_MEMCPY(p->tmp_y, cur_y, mb_w * sizeof(*p->tmp_y));
  ------------------
  |  |  174|  27.4k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
  106|  27.4k|    WEBP_UNSAFE_MEMCPY(p->tmp_u, cur_u, uv_w * sizeof(*p->tmp_u));
  ------------------
  |  |  174|  27.4k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
  107|  27.4k|    WEBP_UNSAFE_MEMCPY(p->tmp_v, cur_v, uv_w * sizeof(*p->tmp_v));
  ------------------
  |  |  174|  27.4k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
  108|       |    // The fancy upsampler leaves a row unfinished behind
  109|       |    // (except for the very last row)
  110|  27.4k|    num_lines_out--;
  111|  27.4k|  } else {
  112|       |    // Process the very last row of even-sized picture
  113|    303|    if (!(y_end & 1)) {
  ------------------
  |  Branch (113:9): [True: 131, False: 172]
  ------------------
  114|    131|      upsample(cur_y, NULL, cur_u, cur_v, cur_u, cur_v, dst + buf->stride, NULL,
  115|    131|               mb_w);
  116|    131|    }
  117|    303|  }
  118|  27.7k|  return num_lines_out;
  119|  27.7k|}
io_dec.c:EmitYUV:
   35|  4.85k|static int EmitYUV(const VP8Io* const io, WebPDecParams* const p) {
   36|  4.85k|  WebPDecBuffer* output = p->output;
   37|  4.85k|  const WebPYUVABuffer* const buf = &output->u.YUVA;
   38|  4.85k|  uint8_t* const y_dst = buf->y + (ptrdiff_t)io->mb_y * buf->y_stride;
   39|  4.85k|  uint8_t* const u_dst = buf->u + (ptrdiff_t)(io->mb_y >> 1) * buf->u_stride;
   40|  4.85k|  uint8_t* const v_dst = buf->v + (ptrdiff_t)(io->mb_y >> 1) * buf->v_stride;
   41|  4.85k|  const int mb_w = io->mb_w;
   42|  4.85k|  const int mb_h = io->mb_h;
   43|  4.85k|  const int uv_w = (mb_w + 1) / 2;
   44|  4.85k|  const int uv_h = (mb_h + 1) / 2;
   45|  4.85k|  WebPCopyPlane(io->y, io->y_stride, y_dst, buf->y_stride, mb_w, mb_h);
   46|  4.85k|  WebPCopyPlane(io->u, io->uv_stride, u_dst, buf->u_stride, uv_w, uv_h);
   47|  4.85k|  WebPCopyPlane(io->v, io->uv_stride, v_dst, buf->v_stride, uv_w, uv_h);
   48|  4.85k|  return io->mb_h;
   49|  4.85k|}
io_dec.c:EmitAlphaRGB:
  183|  16.3k|                        int expected_num_lines_out) {
  184|  16.3k|  const uint8_t* alpha = io->a;
  185|  16.3k|  if (alpha != NULL) {
  ------------------
  |  Branch (185:7): [True: 0, False: 16.3k]
  ------------------
  186|      0|    const int mb_w = io->mb_w;
  187|      0|    const WEBP_CSP_MODE colorspace = p->output->colorspace;
  188|      0|    const int alpha_first =
  189|      0|        (colorspace == MODE_ARGB || colorspace == MODE_Argb);
  ------------------
  |  Branch (189:10): [True: 0, False: 0]
  |  Branch (189:37): [True: 0, False: 0]
  ------------------
  190|      0|    const WebPRGBABuffer* const buf = &p->output->u.RGBA;
  191|      0|    int num_rows;
  192|      0|    const int start_y = GetAlphaSourceRow(io, &alpha, &num_rows);
  193|      0|    uint8_t* const base_rgba = buf->rgba + (ptrdiff_t)start_y * buf->stride;
  194|      0|    uint8_t* const dst = base_rgba + (alpha_first ? 0 : 3);
  ------------------
  |  Branch (194:39): [True: 0, False: 0]
  ------------------
  195|      0|    const int has_alpha =
  196|      0|        WebPDispatchAlpha(alpha, io->width, mb_w, num_rows, dst, buf->stride);
  197|      0|    (void)expected_num_lines_out;
  198|      0|    assert(expected_num_lines_out == num_rows);
  199|       |    // has_alpha is true if there's non-trivial alpha to premultiply with.
  200|      0|    if (has_alpha && WebPIsPremultipliedMode(colorspace)) {
  ------------------
  |  Branch (200:9): [True: 0, False: 0]
  |  Branch (200:22): [True: 0, False: 0]
  ------------------
  201|      0|      WebPApplyAlphaMultiply(base_rgba, alpha_first, mb_w, num_rows,
  202|      0|                             buf->stride);
  203|      0|    }
  204|      0|  }
  205|  16.3k|  return 0;
  206|  16.3k|}
io_dec.c:CustomTeardown:
  700|  2.48k|static void CustomTeardown(const VP8Io* io) {
  701|  2.48k|  WebPDecParams* const p = (WebPDecParams*)io->opaque;
  702|  2.48k|  WebPSafeFree(p->memory);
  703|       |  p->memory = NULL;
  704|  2.48k|}

VP8ParseQuant:
   50|  2.51k|void VP8ParseQuant(VP8Decoder* const dec) {
   51|  2.51k|  VP8BitReader* const br = &dec->br;
   52|  2.51k|  const int base_q0 = VP8GetValue(br, 7, "global-header");
  ------------------
  |  |   43|  2.51k|#define VP8GetValue(BR, N, L) VP8GetValue(BR, N)
  ------------------
   53|  2.51k|  const int dqy1_dc = VP8Get(br, "global-header")
  ------------------
  |  |   44|  2.51k|#define VP8Get(BR, L) VP8GetValue(BR, 1, L)
  |  |  ------------------
  |  |  |  |   43|  2.51k|#define VP8GetValue(BR, N, L) VP8GetValue(BR, N)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (43:31): [True: 744, False: 1.77k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   54|  2.51k|                          ? VP8GetSignedValue(br, 4, "global-header")
  ------------------
  |  |   45|    744|#define VP8GetSignedValue(BR, N, L) VP8GetSignedValue(BR, N)
  ------------------
   55|  2.51k|                          : 0;
   56|  2.51k|  const int dqy2_dc = VP8Get(br, "global-header")
  ------------------
  |  |   44|  2.51k|#define VP8Get(BR, L) VP8GetValue(BR, 1, L)
  |  |  ------------------
  |  |  |  |   43|  2.51k|#define VP8GetValue(BR, N, L) VP8GetValue(BR, N)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (43:31): [True: 394, False: 2.12k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   57|  2.51k|                          ? VP8GetSignedValue(br, 4, "global-header")
  ------------------
  |  |   45|    394|#define VP8GetSignedValue(BR, N, L) VP8GetSignedValue(BR, N)
  ------------------
   58|  2.51k|                          : 0;
   59|  2.51k|  const int dqy2_ac = VP8Get(br, "global-header")
  ------------------
  |  |   44|  2.51k|#define VP8Get(BR, L) VP8GetValue(BR, 1, L)
  |  |  ------------------
  |  |  |  |   43|  2.51k|#define VP8GetValue(BR, N, L) VP8GetValue(BR, N)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (43:31): [True: 454, False: 2.06k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   60|  2.51k|                          ? VP8GetSignedValue(br, 4, "global-header")
  ------------------
  |  |   45|    454|#define VP8GetSignedValue(BR, N, L) VP8GetSignedValue(BR, N)
  ------------------
   61|  2.51k|                          : 0;
   62|  2.51k|  const int dquv_dc = VP8Get(br, "global-header")
  ------------------
  |  |   44|  2.51k|#define VP8Get(BR, L) VP8GetValue(BR, 1, L)
  |  |  ------------------
  |  |  |  |   43|  2.51k|#define VP8GetValue(BR, N, L) VP8GetValue(BR, N)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (43:31): [True: 313, False: 2.20k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   63|  2.51k|                          ? VP8GetSignedValue(br, 4, "global-header")
  ------------------
  |  |   45|    313|#define VP8GetSignedValue(BR, N, L) VP8GetSignedValue(BR, N)
  ------------------
   64|  2.51k|                          : 0;
   65|  2.51k|  const int dquv_ac = VP8Get(br, "global-header")
  ------------------
  |  |   44|  2.51k|#define VP8Get(BR, L) VP8GetValue(BR, 1, L)
  |  |  ------------------
  |  |  |  |   43|  2.51k|#define VP8GetValue(BR, N, L) VP8GetValue(BR, N)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (43:31): [True: 496, False: 2.01k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   66|  2.51k|                          ? VP8GetSignedValue(br, 4, "global-header")
  ------------------
  |  |   45|    496|#define VP8GetSignedValue(BR, N, L) VP8GetSignedValue(BR, N)
  ------------------
   67|  2.51k|                          : 0;
   68|       |
   69|  2.51k|  const VP8SegmentHeader* const hdr = &dec->segment_hdr;
   70|  2.51k|  int i;
   71|       |
   72|  12.5k|  for (i = 0; i < NUM_MB_SEGMENTS; ++i) {
  ------------------
  |  Branch (72:15): [True: 10.0k, False: 2.51k]
  ------------------
   73|  10.0k|    int q;
   74|  10.0k|    if (hdr->use_segment) {
  ------------------
  |  Branch (74:9): [True: 1.42k, False: 8.62k]
  ------------------
   75|  1.42k|      q = hdr->quantizer[i];
   76|  1.42k|      if (!hdr->absolute_delta) {
  ------------------
  |  Branch (76:11): [True: 412, False: 1.01k]
  ------------------
   77|    412|        q += base_q0;
   78|    412|      }
   79|  8.62k|    } else {
   80|  8.62k|      if (i > 0) {
  ------------------
  |  Branch (80:11): [True: 6.47k, False: 2.15k]
  ------------------
   81|  6.47k|        dec->dqm[i] = dec->dqm[0];
   82|  6.47k|        continue;
   83|  6.47k|      } else {
   84|  2.15k|        q = base_q0;
   85|  2.15k|      }
   86|  8.62k|    }
   87|  3.58k|    {
   88|  3.58k|      VP8QuantMatrix* const m = &dec->dqm[i];
   89|  3.58k|      m->y1_mat[0] = kDcTable[clip(q + dqy1_dc, 127)];
   90|  3.58k|      m->y1_mat[1] = kAcTable[clip(q + 0, 127)];
   91|       |
   92|  3.58k|      m->y2_mat[0] = kDcTable[clip(q + dqy2_dc, 127)] * 2;
   93|       |      // For all x in [0..284], x*155/100 is bitwise equal to (x*101581) >> 16.
   94|       |      // The smallest precision for that is '(x*6349) >> 12' but 16 is a good
   95|       |      // word size.
   96|  3.58k|      m->y2_mat[1] = (kAcTable[clip(q + dqy2_ac, 127)] * 101581) >> 16;
   97|  3.58k|      if (m->y2_mat[1] < 8) m->y2_mat[1] = 8;
  ------------------
  |  Branch (97:11): [True: 1.10k, False: 2.47k]
  ------------------
   98|       |
   99|  3.58k|      m->uv_mat[0] = kDcTable[clip(q + dquv_dc, 117)];
  100|  3.58k|      m->uv_mat[1] = kAcTable[clip(q + dquv_ac, 127)];
  101|       |
  102|  3.58k|      m->uv_quant = q + dquv_ac;  // for dithering strength evaluation
  103|  3.58k|    }
  104|  3.58k|  }
  105|  2.51k|}
quant_dec.c:clip:
   22|  21.5k|static WEBP_INLINE int clip(int v, int M) { return v < 0 ? 0 : v > M ? M : v; }
  ------------------
  |  Branch (22:52): [True: 2.44k, False: 19.0k]
  |  Branch (22:64): [True: 873, False: 18.1k]
  ------------------

VP8ResetProba:
  251|  2.67k|void VP8ResetProba(VP8Proba* const proba) {
  252|  2.67k|  WEBP_UNSAFE_MEMSET(proba->segments, 255u, sizeof(proba->segments));
  ------------------
  |  |  175|  2.67k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  253|       |  // proba->bands[][] is initialized later
  254|  2.67k|}
VP8ParseIntraModeRow:
  333|  34.7k|int VP8ParseIntraModeRow(VP8BitReader* const br, VP8Decoder* const dec) {
  334|  34.7k|  int mb_x;
  335|   171k|  for (mb_x = 0; mb_x < dec->mb_w; ++mb_x) {
  ------------------
  |  Branch (335:18): [True: 136k, False: 34.7k]
  ------------------
  336|   136k|    ParseIntraMode(br, dec, mb_x);
  337|   136k|  }
  338|  34.7k|  return !dec->br.eof;
  339|  34.7k|}
VP8ParseProba:
  450|  2.51k|void VP8ParseProba(VP8BitReader* const br, VP8Decoder* const dec) {
  451|  2.51k|  VP8Proba* const proba = &dec->proba;
  452|  2.51k|  int t, b, c, p;
  453|  12.5k|  for (t = 0; t < NUM_TYPES; ++t) {
  ------------------
  |  Branch (453:15): [True: 10.0k, False: 2.51k]
  ------------------
  454|  90.5k|    for (b = 0; b < NUM_BANDS; ++b) {
  ------------------
  |  Branch (454:17): [True: 80.4k, False: 10.0k]
  ------------------
  455|   321k|      for (c = 0; c < NUM_CTX; ++c) {
  ------------------
  |  Branch (455:19): [True: 241k, False: 80.4k]
  ------------------
  456|  2.89M|        for (p = 0; p < NUM_PROBAS; ++p) {
  ------------------
  |  Branch (456:21): [True: 2.65M, False: 241k]
  ------------------
  457|  2.65M|          const int v =
  458|  2.65M|              VP8GetBit(br, CoeffsUpdateProba[t][b][c][p], "global-header")
  ------------------
  |  |   46|  2.65M|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  |  |  ------------------
  |  |  |  Branch (46:29): [True: 44.5k, False: 2.61M]
  |  |  ------------------
  ------------------
  459|  2.65M|                  ? VP8GetValue(br, 8, "global-header")
  ------------------
  |  |   43|  44.5k|#define VP8GetValue(BR, N, L) VP8GetValue(BR, N)
  ------------------
  460|  2.65M|                  : CoeffsProba0[t][b][c][p];
  461|  2.65M|          proba->bands[t][b].probas[c][p] = v;
  462|  2.65M|        }
  463|   241k|      }
  464|  80.4k|    }
  465|   181k|    for (b = 0; b < 16 + 1; ++b) {
  ------------------
  |  Branch (465:17): [True: 170k, False: 10.0k]
  ------------------
  466|   170k|      proba->bands_ptr[t][b] = &proba->bands[t][kBands[b]];
  467|   170k|    }
  468|  10.0k|  }
  469|  2.51k|  dec->use_skip_proba = VP8Get(br, "global-header");
  ------------------
  |  |   44|  2.51k|#define VP8Get(BR, L) VP8GetValue(BR, 1, L)
  |  |  ------------------
  |  |  |  |   43|  2.51k|#define VP8GetValue(BR, N, L) VP8GetValue(BR, N)
  |  |  ------------------
  ------------------
  470|  2.51k|  if (dec->use_skip_proba) {
  ------------------
  |  Branch (470:7): [True: 521, False: 1.99k]
  ------------------
  471|    521|    dec->skip_p = VP8GetValue(br, 8, "global-header");
  ------------------
  |  |   43|    521|#define VP8GetValue(BR, N, L) VP8GetValue(BR, N)
  ------------------
  472|    521|  }
  473|  2.51k|}
tree_dec.c:ParseIntraMode:
  257|   136k|                           int mb_x) {
  258|   136k|  uint8_t* const top = dec->intra_t + 4 * mb_x;
  259|   136k|  uint8_t* const left = dec->intra_l;
  260|   136k|  VP8MBData* const block = dec->mb_data + mb_x;
  261|       |
  262|       |  // Note: we don't save segment map (yet), as we don't expect
  263|       |  // to decode more than 1 keyframe.
  264|   136k|  if (dec->segment_hdr.update_map) {
  ------------------
  |  Branch (264:7): [True: 64.9k, False: 72.0k]
  ------------------
  265|       |    // Hardcoded tree parsing
  266|  64.9k|    block->segment =
  267|  64.9k|        !VP8GetBit(br, dec->proba.segments[0], "segments")
  ------------------
  |  |   46|  64.9k|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  ------------------
  |  Branch (267:9): [True: 48.5k, False: 16.4k]
  ------------------
  268|  64.9k|            ? VP8GetBit(br, dec->proba.segments[1], "segments")
  ------------------
  |  |   46|  48.5k|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  ------------------
  269|  64.9k|            : VP8GetBit(br, dec->proba.segments[2], "segments") + 2;
  ------------------
  |  |   46|  16.4k|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  ------------------
  270|  72.0k|  } else {
  271|  72.0k|    block->segment = 0;  // default for intra
  272|  72.0k|  }
  273|   136k|  if (dec->use_skip_proba) block->skip = VP8GetBit(br, dec->skip_p, "skip");
  ------------------
  |  |   46|  71.3k|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  ------------------
  |  Branch (273:7): [True: 71.3k, False: 65.5k]
  ------------------
  274|       |
  275|   136k|  block->is_i4x4 = !VP8GetBit(br, 145, "block-size");
  ------------------
  |  |   46|   136k|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  ------------------
  276|   136k|  if (!block->is_i4x4) {
  ------------------
  |  Branch (276:7): [True: 47.1k, False: 89.7k]
  ------------------
  277|       |    // Hardcoded 16x16 intra-mode decision tree.
  278|  47.1k|    const int ymode =
  279|  47.1k|        VP8GetBit(br, 156, "pred-modes")
  ------------------
  |  |   46|  47.1k|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  |  |  ------------------
  |  |  |  Branch (46:29): [True: 24.9k, False: 22.1k]
  |  |  ------------------
  ------------------
  280|  47.1k|            ? (VP8GetBit(br, 128, "pred-modes") ? TM_PRED : H_PRED)
  ------------------
  |  |   46|  24.9k|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  |  |  ------------------
  |  |  |  Branch (46:29): [True: 18.8k, False: 6.12k]
  |  |  ------------------
  ------------------
  281|  47.1k|            : (VP8GetBit(br, 163, "pred-modes") ? V_PRED : DC_PRED);
  ------------------
  |  |   46|  22.1k|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  |  |  ------------------
  |  |  |  Branch (46:29): [True: 6.28k, False: 15.8k]
  |  |  ------------------
  ------------------
  282|  47.1k|    block->imodes[0] = ymode;
  283|  47.1k|    WEBP_UNSAFE_MEMSET(top, ymode, 4 * sizeof(*top));
  ------------------
  |  |  175|  47.1k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  284|  47.1k|    WEBP_UNSAFE_MEMSET(left, ymode, 4 * sizeof(*left));
  ------------------
  |  |  175|  47.1k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  285|  89.7k|  } else {
  286|  89.7k|    uint8_t* modes = block->imodes;
  287|  89.7k|    int y;
  288|   448k|    for (y = 0; y < 4; ++y) {
  ------------------
  |  Branch (288:17): [True: 359k, False: 89.7k]
  ------------------
  289|   359k|      int ymode = left[y];
  290|   359k|      int x;
  291|  1.79M|      for (x = 0; x < 4; ++x) {
  ------------------
  |  Branch (291:19): [True: 1.43M, False: 359k]
  ------------------
  292|  1.43M|        const uint8_t* const prob = kBModesProba[top[x]][ymode];
  293|  1.43M|#if (USE_GENERIC_TREE == 1)
  294|       |        // Generic tree-parsing
  295|  1.43M|        int i = kYModesIntra4[VP8GetBit(br, prob[0], "pred-modes")];
  ------------------
  |  |   46|  1.43M|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  ------------------
  296|  1.65M|        while (i > 0) {
  ------------------
  |  Branch (296:16): [True: 219k, False: 1.43M]
  ------------------
  297|   219k|          i = kYModesIntra4[2 * i + VP8GetBit(br, prob[i], "pred-modes")];
  ------------------
  |  |   46|   219k|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  ------------------
  298|   219k|        }
  299|  1.43M|        ymode = -i;
  300|       |#else
  301|       |        // Hardcoded tree parsing
  302|       |        ymode =
  303|       |            !VP8GetBit(br, prob[0], "pred-modes")   ? B_DC_PRED
  304|       |            : !VP8GetBit(br, prob[1], "pred-modes") ? B_TM_PRED
  305|       |            : !VP8GetBit(br, prob[2], "pred-modes") ? B_VE_PRED
  306|       |            : !VP8GetBit(br, prob[3], "pred-modes")
  307|       |                ? (!VP8GetBit(br, prob[4], "pred-modes")
  308|       |                       ? B_HE_PRED
  309|       |                       : (!VP8GetBit(br, prob[5], "pred-modes") ? B_RD_PRED
  310|       |                                                                : B_VR_PRED))
  311|       |                : (!VP8GetBit(br, prob[6], "pred-modes")
  312|       |                       ? B_LD_PRED
  313|       |                       : (!VP8GetBit(br, prob[7], "pred-modes")
  314|       |                              ? B_VL_PRED
  315|       |                              : (!VP8GetBit(br, prob[8], "pred-modes")
  316|       |                                     ? B_HD_PRED
  317|       |                                     : B_HU_PRED)));
  318|       |#endif  // USE_GENERIC_TREE
  319|  1.43M|        top[x] = ymode;
  320|  1.43M|      }
  321|   359k|      WEBP_UNSAFE_MEMCPY(modes, top, 4 * sizeof(*top));
  ------------------
  |  |  174|   359k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
  322|   359k|      modes += 4;
  323|   359k|      left[y] = ymode;
  324|   359k|    }
  325|  89.7k|  }
  326|       |  // Hardcoded UVMode decision tree
  327|   136k|  block->uvmode = !VP8GetBit(br, 142, "pred-modes-uv")   ? DC_PRED
  ------------------
  |  |   46|   136k|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  ------------------
  |  Branch (327:19): [True: 101k, False: 35.1k]
  ------------------
  328|   136k|                  : !VP8GetBit(br, 114, "pred-modes-uv") ? V_PRED
  ------------------
  |  |   46|  35.1k|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  ------------------
  |  Branch (328:21): [True: 10.3k, False: 24.7k]
  ------------------
  329|  35.1k|                  : VP8GetBit(br, 183, "pred-modes-uv")  ? TM_PRED
  ------------------
  |  |   46|  24.7k|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  |  |  ------------------
  |  |  |  Branch (46:29): [True: 15.7k, False: 9.03k]
  |  |  ------------------
  ------------------
  330|  24.7k|                                                         : H_PRED;
  331|   136k|}

VP8InitIoInternal:
   61|  4.73k|int VP8InitIoInternal(VP8Io* const io, int version) {
   62|  4.73k|  if (WEBP_ABI_IS_INCOMPATIBLE(version, WEBP_DECODER_ABI_VERSION)) {
  ------------------
  |  |   84|  4.73k|#define WEBP_ABI_IS_INCOMPATIBLE(a, b) (((a) >> 8) != ((b) >> 8))
  |  |  ------------------
  |  |  |  Branch (84:40): [True: 0, False: 4.73k]
  |  |  ------------------
  ------------------
   63|      0|    return 0;  // mismatch error
   64|      0|  }
   65|  4.73k|  if (io != NULL) {
  ------------------
  |  Branch (65:7): [True: 4.73k, False: 0]
  ------------------
   66|  4.73k|    WEBP_UNSAFE_MEMSET(io, 0, sizeof(*io));
  ------------------
  |  |  175|  4.73k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
   67|  4.73k|  }
   68|  4.73k|  return 1;
   69|  4.73k|}
VP8New:
   71|  2.67k|VP8Decoder* VP8New(void) {
   72|  2.67k|  VP8Decoder* const dec = (VP8Decoder*)WebPSafeCalloc(1ULL, sizeof(*dec));
   73|  2.67k|  if (dec != NULL) {
  ------------------
  |  Branch (73:7): [True: 2.67k, False: 0]
  ------------------
   74|  2.67k|    SetOk(dec);
   75|  2.67k|    WebPGetWorkerInterface()->Init(&dec->worker);
   76|  2.67k|    dec->ready = 0;
   77|  2.67k|    dec->num_parts_minus_one = 0;
   78|  2.67k|    InitGetCoeffs();
   79|  2.67k|  }
   80|  2.67k|  return dec;
   81|  2.67k|}
VP8Delete:
   94|  2.67k|void VP8Delete(VP8Decoder* const dec) {
   95|  2.67k|  if (dec != NULL) {
  ------------------
  |  Branch (95:7): [True: 2.67k, False: 0]
  ------------------
   96|  2.67k|    VP8Clear(dec);
   97|  2.67k|    WebPSafeFree(dec);
   98|  2.67k|  }
   99|  2.67k|}
VP8SetError:
  102|  2.32k|                const char* const msg) {
  103|       |  // VP8_STATUS_SUSPENDED is only meaningful in incremental decoding.
  104|  2.32k|  assert(dec->incremental || error != VP8_STATUS_SUSPENDED);
  105|       |  // The oldest error reported takes precedence over the new one.
  106|  2.32k|  if (dec->status == VP8_STATUS_OK) {
  ------------------
  |  Branch (106:7): [True: 2.32k, False: 0]
  ------------------
  107|  2.32k|    dec->status = error;
  108|  2.32k|    dec->error_msg = msg;
  109|  2.32k|    dec->ready = 0;
  110|  2.32k|  }
  111|  2.32k|  return 0;
  112|  2.32k|}
VP8CheckSignature:
  117|  9.63k|                      size_t data_size) {
  118|  9.63k|  return (data_size >= 3 && data[0] == 0x9d && data[1] == 0x01 &&
  ------------------
  |  Branch (118:11): [True: 9.63k, False: 0]
  |  Branch (118:29): [True: 9.58k, False: 48]
  |  Branch (118:48): [True: 9.58k, False: 1]
  ------------------
  119|  9.58k|          data[2] == 0x2a);
  ------------------
  |  Branch (119:11): [True: 9.58k, False: 4]
  ------------------
  120|  9.63k|}
VP8GetInfo:
  123|  6.95k|               size_t chunk_size, int* const width, int* const height) {
  124|  6.95k|  if (data == NULL || data_size < VP8_FRAME_HEADER_SIZE) {
  ------------------
  |  |   24|  6.95k|#define VP8_FRAME_HEADER_SIZE 10  // Size of the frame header within VP8 data.
  ------------------
  |  Branch (124:7): [True: 0, False: 6.95k]
  |  Branch (124:23): [True: 0, False: 6.95k]
  ------------------
  125|      0|    return 0;  // not enough data
  126|      0|  }
  127|       |  // check signature
  128|  6.95k|  if (!VP8CheckSignature(data + 3, data_size - 3)) {
  ------------------
  |  Branch (128:7): [True: 53, False: 6.90k]
  ------------------
  129|     53|    return 0;  // Wrong signature.
  130|  6.90k|  } else {
  131|  6.90k|    const uint32_t bits = data[0] | (data[1] << 8) | (data[2] << 16);
  132|  6.90k|    const int key_frame = !(bits & 1);
  133|  6.90k|    const int w = ((data[7] << 8) | data[6]) & 0x3fff;
  134|  6.90k|    const int h = ((data[9] << 8) | data[8]) & 0x3fff;
  135|       |
  136|  6.90k|    if (!key_frame) {  // Not a keyframe.
  ------------------
  |  Branch (136:9): [True: 1, False: 6.90k]
  ------------------
  137|      1|      return 0;
  138|      1|    }
  139|       |
  140|  6.90k|    if (((bits >> 1) & 7) > 3) {
  ------------------
  |  Branch (140:9): [True: 1, False: 6.90k]
  ------------------
  141|      1|      return 0;  // unknown profile
  142|      1|    }
  143|  6.90k|    if (!((bits >> 4) & 1)) {
  ------------------
  |  Branch (143:9): [True: 1, False: 6.90k]
  ------------------
  144|      1|      return 0;  // first frame is invisible!
  145|      1|    }
  146|  6.90k|    if (((bits >> 5)) >= chunk_size) {  // partition_length
  ------------------
  |  Branch (146:9): [True: 13, False: 6.89k]
  ------------------
  147|     13|      return 0;                         // inconsistent size information.
  148|     13|    }
  149|  6.89k|    if (w == 0 || h == 0) {
  ------------------
  |  Branch (149:9): [True: 1, False: 6.88k]
  |  Branch (149:19): [True: 1, False: 6.88k]
  ------------------
  150|      2|      return 0;  // We don't support a zero width or height.
  151|      2|    }
  152|       |
  153|  6.88k|    if (width) {
  ------------------
  |  Branch (153:9): [True: 6.88k, False: 0]
  ------------------
  154|  6.88k|      *width = w;
  155|  6.88k|    }
  156|  6.88k|    if (height) {
  ------------------
  |  Branch (156:9): [True: 6.88k, False: 0]
  ------------------
  157|  6.88k|      *height = h;
  158|  6.88k|    }
  159|       |
  160|  6.88k|    return 1;
  161|  6.89k|  }
  162|  6.95k|}
VP8GetHeaders:
  285|  2.67k|int VP8GetHeaders(VP8Decoder* const dec, VP8Io* const io) {
  286|  2.67k|  size_t buf_size;
  287|  2.67k|  const uint8_t* WEBP_COUNTED_BY(buf_size) buf;
  288|  2.67k|  VP8FrameHeader* frm_hdr;
  289|  2.67k|  VP8PictureHeader* pic_hdr;
  290|  2.67k|  VP8BitReader* br;
  291|  2.67k|  VP8StatusCode status;
  292|       |
  293|  2.67k|  if (dec == NULL) {
  ------------------
  |  Branch (293:7): [True: 0, False: 2.67k]
  ------------------
  294|      0|    return 0;
  295|      0|  }
  296|  2.67k|  SetOk(dec);
  297|  2.67k|  if (io == NULL) {
  ------------------
  |  Branch (297:7): [True: 0, False: 2.67k]
  ------------------
  298|      0|    return VP8SetError(dec, VP8_STATUS_INVALID_PARAM,
  299|      0|                       "null VP8Io passed to VP8GetHeaders()");
  300|      0|  }
  301|  2.67k|  buf_size = io->data_size;
  302|  2.67k|  buf =
  303|  2.67k|      WEBP_UNSAFE_FORGE_BIDI_INDEXABLE(const uint8_t*, io->data, io->data_size);
  ------------------
  |  |  180|  2.67k|#define WEBP_UNSAFE_FORGE_BIDI_INDEXABLE(typ, ptr, size) ((typ)(ptr))
  ------------------
  304|  2.67k|  if (buf_size < 4) {
  ------------------
  |  Branch (304:7): [True: 0, False: 2.67k]
  ------------------
  305|      0|    return VP8SetError(dec, VP8_STATUS_NOT_ENOUGH_DATA, "Truncated header.");
  306|      0|  }
  307|       |
  308|       |  // Paragraph 9.1
  309|  2.67k|  {
  310|  2.67k|    const uint32_t bits = buf[0] | (buf[1] << 8) | (buf[2] << 16);
  311|  2.67k|    frm_hdr = &dec->frm_hdr;
  312|  2.67k|    frm_hdr->key_frame = !(bits & 1);
  313|  2.67k|    frm_hdr->profile = (bits >> 1) & 7;
  314|  2.67k|    frm_hdr->show = (bits >> 4) & 1;
  315|  2.67k|    frm_hdr->partition_length = (bits >> 5);
  316|  2.67k|    if (frm_hdr->profile > 3) {
  ------------------
  |  Branch (316:9): [True: 0, False: 2.67k]
  ------------------
  317|      0|      return VP8SetError(dec, VP8_STATUS_BITSTREAM_ERROR,
  318|      0|                         "Incorrect keyframe parameters.");
  319|      0|    }
  320|  2.67k|    if (!frm_hdr->show) {
  ------------------
  |  Branch (320:9): [True: 0, False: 2.67k]
  ------------------
  321|      0|      return VP8SetError(dec, VP8_STATUS_UNSUPPORTED_FEATURE,
  322|      0|                         "Frame not displayable.");
  323|      0|    }
  324|  2.67k|    buf += 3;
  325|  2.67k|    buf_size -= 3;
  326|  2.67k|  }
  327|       |
  328|      0|  pic_hdr = &dec->pic_hdr;
  329|  2.67k|  if (frm_hdr->key_frame) {
  ------------------
  |  Branch (329:7): [True: 2.67k, False: 0]
  ------------------
  330|       |    // Paragraph 9.2
  331|  2.67k|    if (buf_size < 7) {
  ------------------
  |  Branch (331:9): [True: 0, False: 2.67k]
  ------------------
  332|      0|      return VP8SetError(dec, VP8_STATUS_NOT_ENOUGH_DATA,
  333|      0|                         "cannot parse picture header");
  334|      0|    }
  335|  2.67k|    if (!VP8CheckSignature(buf, buf_size)) {
  ------------------
  |  Branch (335:9): [True: 0, False: 2.67k]
  ------------------
  336|      0|      return VP8SetError(dec, VP8_STATUS_BITSTREAM_ERROR, "Bad code word");
  337|      0|    }
  338|  2.67k|    pic_hdr->width = ((buf[4] << 8) | buf[3]) & 0x3fff;
  339|  2.67k|    pic_hdr->xscale = buf[4] >> 6;  // ratio: 1, 5/4 5/3 or 2
  340|  2.67k|    pic_hdr->height = ((buf[6] << 8) | buf[5]) & 0x3fff;
  341|  2.67k|    pic_hdr->yscale = buf[6] >> 6;
  342|  2.67k|    buf += 7;
  343|  2.67k|    buf_size -= 7;
  344|       |
  345|  2.67k|    dec->mb_w = (pic_hdr->width + 15) >> 4;
  346|  2.67k|    dec->mb_h = (pic_hdr->height + 15) >> 4;
  347|       |
  348|       |    // Setup default output area (can be later modified during io->setup())
  349|  2.67k|    io->width = pic_hdr->width;
  350|  2.67k|    io->height = pic_hdr->height;
  351|       |    // IMPORTANT! use some sane dimensions in crop* and scaled* fields.
  352|       |    // So they can be used interchangeably without always testing for
  353|       |    // 'use_cropping'.
  354|  2.67k|    io->use_cropping = 0;
  355|  2.67k|    io->crop_top = 0;
  356|  2.67k|    io->crop_left = 0;
  357|  2.67k|    io->crop_right = io->width;
  358|  2.67k|    io->crop_bottom = io->height;
  359|  2.67k|    io->use_scaling = 0;
  360|  2.67k|    io->scaled_width = io->width;
  361|  2.67k|    io->scaled_height = io->height;
  362|       |
  363|  2.67k|    io->mb_w = io->width;   // for soundness
  364|  2.67k|    io->mb_h = io->height;  // ditto
  365|       |
  366|  2.67k|    VP8ResetProba(&dec->proba);
  367|  2.67k|    ResetSegmentHeader(&dec->segment_hdr);
  368|  2.67k|  }
  369|       |
  370|       |  // Check if we have all the partition #0 available, and initialize dec->br
  371|       |  // to read this partition (and this partition only).
  372|  2.67k|  if (frm_hdr->partition_length > buf_size) {
  ------------------
  |  Branch (372:7): [True: 5, False: 2.67k]
  ------------------
  373|      5|    return VP8SetError(dec, VP8_STATUS_NOT_ENOUGH_DATA, "bad partition length");
  374|      5|  }
  375|       |
  376|  2.67k|  br = &dec->br;
  377|  2.67k|  VP8InitBitReader(br, buf, frm_hdr->partition_length);
  378|  2.67k|  buf += frm_hdr->partition_length;
  379|  2.67k|  buf_size -= frm_hdr->partition_length;
  380|       |
  381|  2.67k|  if (frm_hdr->key_frame) {
  ------------------
  |  Branch (381:7): [True: 2.67k, False: 0]
  ------------------
  382|  2.67k|    pic_hdr->colorspace = VP8Get(br, "global-header");
  ------------------
  |  |   44|  2.67k|#define VP8Get(BR, L) VP8GetValue(BR, 1, L)
  |  |  ------------------
  |  |  |  |   43|  2.67k|#define VP8GetValue(BR, N, L) VP8GetValue(BR, N)
  |  |  ------------------
  ------------------
  383|  2.67k|    pic_hdr->clamp_type = VP8Get(br, "global-header");
  ------------------
  |  |   44|  2.67k|#define VP8Get(BR, L) VP8GetValue(BR, 1, L)
  |  |  ------------------
  |  |  |  |   43|  2.67k|#define VP8GetValue(BR, N, L) VP8GetValue(BR, N)
  |  |  ------------------
  ------------------
  384|  2.67k|  }
  385|  2.67k|  if (!ParseSegmentHeader(br, &dec->segment_hdr, &dec->proba)) {
  ------------------
  |  Branch (385:7): [True: 67, False: 2.60k]
  ------------------
  386|     67|    return VP8SetError(dec, VP8_STATUS_BITSTREAM_ERROR,
  387|     67|                       "cannot parse segment header");
  388|     67|  }
  389|       |  // Filter specs
  390|  2.60k|  if (!ParseFilterHeader(br, dec)) {
  ------------------
  |  Branch (390:7): [True: 22, False: 2.58k]
  ------------------
  391|     22|    return VP8SetError(dec, VP8_STATUS_BITSTREAM_ERROR,
  392|     22|                       "cannot parse filter header");
  393|     22|  }
  394|  2.58k|  status = ParsePartitions(dec, buf, buf_size);
  395|  2.58k|  if (status != VP8_STATUS_OK) {
  ------------------
  |  Branch (395:7): [True: 69, False: 2.51k]
  ------------------
  396|     69|    return VP8SetError(dec, status, "cannot parse partitions");
  397|     69|  }
  398|       |
  399|       |  // quantizer change
  400|  2.51k|  VP8ParseQuant(dec);
  401|       |
  402|       |  // Frame buffer marking
  403|  2.51k|  if (!frm_hdr->key_frame) {
  ------------------
  |  Branch (403:7): [True: 0, False: 2.51k]
  ------------------
  404|      0|    return VP8SetError(dec, VP8_STATUS_UNSUPPORTED_FEATURE, "Not a key frame.");
  405|      0|  }
  406|       |
  407|  2.51k|  VP8Get(br, "global-header");  // ignore the value of 'update_proba'
  ------------------
  |  |   44|  2.51k|#define VP8Get(BR, L) VP8GetValue(BR, 1, L)
  |  |  ------------------
  |  |  |  |   43|  2.51k|#define VP8GetValue(BR, N, L) VP8GetValue(BR, N)
  |  |  ------------------
  ------------------
  408|       |
  409|  2.51k|  VP8ParseProba(br, dec);
  410|       |
  411|       |  // sanitized state
  412|  2.51k|  dec->ready = 1;
  413|  2.51k|  return 1;
  414|  2.51k|}
VP8DecodeMB:
  629|  53.6k|int VP8DecodeMB(VP8Decoder* const dec, VP8BitReader* const token_br) {
  630|  53.6k|  VP8MB* const left = dec->mb_info - 1;
  631|  53.6k|  VP8MB* const mb = dec->mb_info + dec->mb_x;
  632|  53.6k|  VP8MBData* const block = dec->mb_data + dec->mb_x;
  633|  53.6k|  int skip = dec->use_skip_proba ? block->skip : 0;
  ------------------
  |  Branch (633:14): [True: 34.8k, False: 18.7k]
  ------------------
  634|       |
  635|  53.6k|  if (!skip) {
  ------------------
  |  Branch (635:7): [True: 22.9k, False: 30.6k]
  ------------------
  636|  22.9k|    skip = ParseResiduals(dec, mb, token_br);
  637|  30.6k|  } else {
  638|  30.6k|    left->nz = mb->nz = 0;
  639|  30.6k|    if (!block->is_i4x4) {
  ------------------
  |  Branch (639:9): [True: 21.0k, False: 9.56k]
  ------------------
  640|  21.0k|      left->nz_dc = mb->nz_dc = 0;
  641|  21.0k|    }
  642|  30.6k|    block->non_zero_y = 0;
  643|  30.6k|    block->non_zero_uv = 0;
  644|  30.6k|    block->dither = 0;
  645|  30.6k|  }
  646|       |
  647|  53.6k|  if (dec->filter_type > 0) {  // store filter info
  ------------------
  |  Branch (647:7): [True: 52.3k, False: 1.25k]
  ------------------
  648|  52.3k|    VP8FInfo* const finfo = dec->f_info + dec->mb_x;
  649|  52.3k|    *finfo = dec->fstrengths[block->segment][block->is_i4x4];
  650|  52.3k|    finfo->f_inner |= !skip;
  651|  52.3k|  }
  652|       |
  653|  53.6k|  return !token_br->eof;
  654|  53.6k|}
VP8InitScanline:
  656|  35.0k|void VP8InitScanline(VP8Decoder* const dec) {
  657|  35.0k|  VP8MB* const left = dec->mb_info - 1;
  658|  35.0k|  left->nz = 0;
  659|  35.0k|  left->nz_dc = 0;
  660|  35.0k|  WEBP_UNSAFE_MEMSET(dec->intra_l, B_DC_PRED, sizeof(dec->intra_l));
  ------------------
  |  |  175|  35.0k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  661|  35.0k|  dec->mb_x = 0;
  662|  35.0k|}
VP8Decode:
  697|  2.48k|int VP8Decode(VP8Decoder* const dec, VP8Io* const io) {
  698|  2.48k|  int ok = 0;
  699|  2.48k|  if (dec == NULL) {
  ------------------
  |  Branch (699:7): [True: 0, False: 2.48k]
  ------------------
  700|      0|    return 0;
  701|      0|  }
  702|  2.48k|  if (io == NULL) {
  ------------------
  |  Branch (702:7): [True: 0, False: 2.48k]
  ------------------
  703|      0|    return VP8SetError(dec, VP8_STATUS_INVALID_PARAM,
  704|      0|                       "NULL VP8Io parameter in VP8Decode().");
  705|      0|  }
  706|       |
  707|  2.48k|  if (!dec->ready) {
  ------------------
  |  Branch (707:7): [True: 0, False: 2.48k]
  ------------------
  708|      0|    if (!VP8GetHeaders(dec, io)) {
  ------------------
  |  Branch (708:9): [True: 0, False: 0]
  ------------------
  709|      0|      return 0;
  710|      0|    }
  711|      0|  }
  712|  2.48k|  assert(dec->ready);
  713|       |
  714|       |  // Finish setting up the decoding parameter. Will call io->setup().
  715|  2.48k|  ok = (VP8EnterCritical(dec, io) == VP8_STATUS_OK);
  716|  2.48k|  if (ok) {  // good to go.
  ------------------
  |  Branch (716:7): [True: 2.48k, False: 0]
  ------------------
  717|       |    // Will allocate memory and prepare everything.
  718|  2.48k|    ok = VP8InitFrame(dec, io);
  719|       |
  720|       |    // Main decoding loop
  721|  2.48k|    if (ok) ok = ParseFrame(dec, io);
  ------------------
  |  Branch (721:9): [True: 2.48k, False: 0]
  ------------------
  722|       |
  723|       |    // Exit.
  724|  2.48k|    ok &= VP8ExitCritical(dec, io);
  725|  2.48k|  }
  726|       |
  727|  2.48k|  if (!ok) {
  ------------------
  |  Branch (727:7): [True: 2.16k, False: 321]
  ------------------
  728|  2.16k|    VP8Clear(dec);
  729|  2.16k|    return 0;
  730|  2.16k|  }
  731|       |
  732|    321|  dec->ready = 0;
  733|    321|  return ok;
  734|  2.48k|}
VP8Clear:
  736|  4.83k|void VP8Clear(VP8Decoder* const dec) {
  737|  4.83k|  if (dec == NULL) {
  ------------------
  |  Branch (737:7): [True: 0, False: 4.83k]
  ------------------
  738|      0|    return;
  739|      0|  }
  740|  4.83k|  WebPGetWorkerInterface()->End(&dec->worker);
  741|  4.83k|  WebPDeallocateAlphaMemory(dec);
  742|  4.83k|  WebPSafeFree(dec->mem);
  743|  4.83k|  dec->mem = NULL;
  744|  4.83k|  dec->mem_size = 0;
  745|  4.83k|  WEBP_UNSAFE_MEMSET(&dec->br, 0, sizeof(dec->br));
  ------------------
  |  |  175|  4.83k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  746|  4.83k|  dec->ready = 0;
  747|  4.83k|}
vp8_dec.c:SetOk:
   56|  5.35k|static void SetOk(VP8Decoder* const dec) {
   57|  5.35k|  dec->status = VP8_STATUS_OK;
   58|  5.35k|  dec->error_msg = "OK";
   59|  5.35k|}
vp8_dec.c:ResetSegmentHeader:
  167|  2.67k|static void ResetSegmentHeader(VP8SegmentHeader* const hdr) {
  168|  2.67k|  assert(hdr != NULL);
  169|  2.67k|  hdr->use_segment = 0;
  170|  2.67k|  hdr->update_map = 0;
  171|  2.67k|  hdr->absolute_delta = 1;
  172|  2.67k|  WEBP_UNSAFE_MEMSET(hdr->quantizer, 0, sizeof(hdr->quantizer));
  ------------------
  |  |  175|  2.67k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  173|  2.67k|  WEBP_UNSAFE_MEMSET(hdr->filter_strength, 0, sizeof(hdr->filter_strength));
  ------------------
  |  |  175|  2.67k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  174|  2.67k|}
vp8_dec.c:ParseSegmentHeader:
  179|  2.67k|                                             VP8Proba* proba) {
  180|  2.67k|  assert(br != NULL);
  181|  2.67k|  assert(hdr != NULL);
  182|  2.67k|  hdr->use_segment = VP8Get(br, "global-header");
  ------------------
  |  |   44|  2.67k|#define VP8Get(BR, L) VP8GetValue(BR, 1, L)
  |  |  ------------------
  |  |  |  |   43|  2.67k|#define VP8GetValue(BR, N, L) VP8GetValue(BR, N)
  |  |  ------------------
  ------------------
  183|  2.67k|  if (hdr->use_segment) {
  ------------------
  |  Branch (183:7): [True: 449, False: 2.22k]
  ------------------
  184|    449|    hdr->update_map = VP8Get(br, "global-header");
  ------------------
  |  |   44|    449|#define VP8Get(BR, L) VP8GetValue(BR, 1, L)
  |  |  ------------------
  |  |  |  |   43|    449|#define VP8GetValue(BR, N, L) VP8GetValue(BR, N)
  |  |  ------------------
  ------------------
  185|    449|    if (VP8Get(br, "global-header")) {  // update data
  ------------------
  |  |   44|    449|#define VP8Get(BR, L) VP8GetValue(BR, 1, L)
  |  |  ------------------
  |  |  |  |   43|    449|#define VP8GetValue(BR, N, L) VP8GetValue(BR, N)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (43:31): [True: 311, False: 138]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  186|    311|      int s;
  187|    311|      hdr->absolute_delta = VP8Get(br, "global-header");
  ------------------
  |  |   44|    311|#define VP8Get(BR, L) VP8GetValue(BR, 1, L)
  |  |  ------------------
  |  |  |  |   43|    311|#define VP8GetValue(BR, N, L) VP8GetValue(BR, N)
  |  |  ------------------
  ------------------
  188|  1.55k|      for (s = 0; s < NUM_MB_SEGMENTS; ++s) {
  ------------------
  |  Branch (188:19): [True: 1.24k, False: 311]
  ------------------
  189|  1.24k|        hdr->quantizer[s] = VP8Get(br, "global-header")
  ------------------
  |  |   44|  1.24k|#define VP8Get(BR, L) VP8GetValue(BR, 1, L)
  |  |  ------------------
  |  |  |  |   43|  1.24k|#define VP8GetValue(BR, N, L) VP8GetValue(BR, N)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (43:31): [True: 650, False: 594]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  190|  1.24k|                                ? VP8GetSignedValue(br, 7, "global-header")
  ------------------
  |  |   45|    650|#define VP8GetSignedValue(BR, N, L) VP8GetSignedValue(BR, N)
  ------------------
  191|  1.24k|                                : 0;
  192|  1.24k|      }
  193|  1.55k|      for (s = 0; s < NUM_MB_SEGMENTS; ++s) {
  ------------------
  |  Branch (193:19): [True: 1.24k, False: 311]
  ------------------
  194|  1.24k|        hdr->filter_strength[s] =
  195|  1.24k|            VP8Get(br, "global-header")
  ------------------
  |  |   44|  1.24k|#define VP8Get(BR, L) VP8GetValue(BR, 1, L)
  |  |  ------------------
  |  |  |  |   43|  1.24k|#define VP8GetValue(BR, N, L) VP8GetValue(BR, N)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (43:31): [True: 635, False: 609]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  196|  1.24k|                ? VP8GetSignedValue(br, 6, "global-header")
  ------------------
  |  |   45|    635|#define VP8GetSignedValue(BR, N, L) VP8GetSignedValue(BR, N)
  ------------------
  197|  1.24k|                : 0;
  198|  1.24k|      }
  199|    311|    }
  200|    449|    if (hdr->update_map) {
  ------------------
  |  Branch (200:9): [True: 280, False: 169]
  ------------------
  201|    280|      int s;
  202|  1.12k|      for (s = 0; s < MB_FEATURE_TREE_PROBS; ++s) {
  ------------------
  |  Branch (202:19): [True: 840, False: 280]
  ------------------
  203|    840|        proba->segments[s] = VP8Get(br, "global-header")
  ------------------
  |  |   44|    840|#define VP8Get(BR, L) VP8GetValue(BR, 1, L)
  |  |  ------------------
  |  |  |  |   43|    840|#define VP8GetValue(BR, N, L) VP8GetValue(BR, N)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (43:31): [True: 467, False: 373]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  204|    840|                                 ? VP8GetValue(br, 8, "global-header")
  ------------------
  |  |   43|    467|#define VP8GetValue(BR, N, L) VP8GetValue(BR, N)
  ------------------
  205|    840|                                 : 255u;
  206|    840|      }
  207|    280|    }
  208|  2.22k|  } else {
  209|  2.22k|    hdr->update_map = 0;
  210|  2.22k|  }
  211|  2.67k|  return !br->eof;
  212|  2.67k|}
vp8_dec.c:ParseFilterHeader:
  259|  2.60k|                                            VP8Decoder* const dec) {
  260|  2.60k|  VP8FilterHeader* const hdr = &dec->filter_hdr;
  261|  2.60k|  hdr->simple = VP8Get(br, "global-header");
  ------------------
  |  |   44|  2.60k|#define VP8Get(BR, L) VP8GetValue(BR, 1, L)
  |  |  ------------------
  |  |  |  |   43|  2.60k|#define VP8GetValue(BR, N, L) VP8GetValue(BR, N)
  |  |  ------------------
  ------------------
  262|  2.60k|  hdr->level = VP8GetValue(br, 6, "global-header");
  ------------------
  |  |   43|  2.60k|#define VP8GetValue(BR, N, L) VP8GetValue(BR, N)
  ------------------
  263|  2.60k|  hdr->sharpness = VP8GetValue(br, 3, "global-header");
  ------------------
  |  |   43|  2.60k|#define VP8GetValue(BR, N, L) VP8GetValue(BR, N)
  ------------------
  264|  2.60k|  hdr->use_lf_delta = VP8Get(br, "global-header");
  ------------------
  |  |   44|  2.60k|#define VP8Get(BR, L) VP8GetValue(BR, 1, L)
  |  |  ------------------
  |  |  |  |   43|  2.60k|#define VP8GetValue(BR, N, L) VP8GetValue(BR, N)
  |  |  ------------------
  ------------------
  265|  2.60k|  if (hdr->use_lf_delta) {
  ------------------
  |  Branch (265:7): [True: 398, False: 2.20k]
  ------------------
  266|    398|    if (VP8Get(br, "global-header")) {  // update lf-delta?
  ------------------
  |  |   44|    398|#define VP8Get(BR, L) VP8GetValue(BR, 1, L)
  |  |  ------------------
  |  |  |  |   43|    398|#define VP8GetValue(BR, N, L) VP8GetValue(BR, N)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (43:31): [True: 139, False: 259]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  267|    139|      int i;
  268|    695|      for (i = 0; i < NUM_REF_LF_DELTAS; ++i) {
  ------------------
  |  Branch (268:19): [True: 556, False: 139]
  ------------------
  269|    556|        if (VP8Get(br, "global-header")) {
  ------------------
  |  |   44|    556|#define VP8Get(BR, L) VP8GetValue(BR, 1, L)
  |  |  ------------------
  |  |  |  |   43|    556|#define VP8GetValue(BR, N, L) VP8GetValue(BR, N)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (43:31): [True: 361, False: 195]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  270|    361|          hdr->ref_lf_delta[i] = VP8GetSignedValue(br, 6, "global-header");
  ------------------
  |  |   45|    361|#define VP8GetSignedValue(BR, N, L) VP8GetSignedValue(BR, N)
  ------------------
  271|    361|        }
  272|    556|      }
  273|    695|      for (i = 0; i < NUM_MODE_LF_DELTAS; ++i) {
  ------------------
  |  Branch (273:19): [True: 556, False: 139]
  ------------------
  274|    556|        if (VP8Get(br, "global-header")) {
  ------------------
  |  |   44|    556|#define VP8Get(BR, L) VP8GetValue(BR, 1, L)
  |  |  ------------------
  |  |  |  |   43|    556|#define VP8GetValue(BR, N, L) VP8GetValue(BR, N)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (43:31): [True: 331, False: 225]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  275|    331|          hdr->mode_lf_delta[i] = VP8GetSignedValue(br, 6, "global-header");
  ------------------
  |  |   45|    331|#define VP8GetSignedValue(BR, N, L) VP8GetSignedValue(BR, N)
  ------------------
  276|    331|        }
  277|    556|      }
  278|    139|    }
  279|    398|  }
  280|  2.60k|  dec->filter_type = (hdr->level == 0) ? 0 : hdr->simple ? 1 : 2;
  ------------------
  |  Branch (280:22): [True: 155, False: 2.45k]
  |  Branch (280:46): [True: 1.12k, False: 1.32k]
  ------------------
  281|  2.60k|  return !br->eof;
  282|  2.60k|}
vp8_dec.c:ParsePartitions:
  225|  2.58k|                                     size_t size) {
  226|  2.58k|  VP8BitReader* const br = &dec->br;
  227|  2.58k|  const uint8_t* WEBP_BIDI_INDEXABLE sz = buf;
  228|  2.58k|  const uint8_t* buf_end = buf + size;
  229|  2.58k|  const uint8_t* WEBP_BIDI_INDEXABLE part_start;
  230|  2.58k|  size_t size_left = size;
  231|  2.58k|  size_t last_part;
  232|  2.58k|  size_t p;
  233|       |
  234|  2.58k|  dec->num_parts_minus_one = (1 << VP8GetValue(br, 2, "global-header")) - 1;
  ------------------
  |  |   43|  2.58k|#define VP8GetValue(BR, N, L) VP8GetValue(BR, N)
  ------------------
  235|  2.58k|  last_part = dec->num_parts_minus_one;
  236|  2.58k|  if (size < 3 * last_part) {
  ------------------
  |  Branch (236:7): [True: 8, False: 2.57k]
  ------------------
  237|       |    // we can't even read the sizes with sz[]! That's a failure.
  238|      8|    return VP8_STATUS_NOT_ENOUGH_DATA;
  239|      8|  }
  240|  2.57k|  part_start = buf + last_part * 3;
  241|  2.57k|  size_left -= last_part * 3;
  242|  3.01k|  for (p = 0; p < last_part; ++p) {
  ------------------
  |  Branch (242:15): [True: 439, False: 2.57k]
  ------------------
  243|    439|    size_t psize = sz[0] | (sz[1] << 8) | (sz[2] << 16);
  244|    439|    if (psize > size_left) psize = size_left;
  ------------------
  |  Branch (244:9): [True: 92, False: 347]
  ------------------
  245|    439|    VP8InitBitReader(dec->parts + p, part_start, psize);
  246|    439|    part_start += psize;
  247|    439|    size_left -= psize;
  248|    439|    sz += 3;
  249|    439|  }
  250|  2.57k|  VP8InitBitReader(dec->parts + last_part, part_start, size_left);
  251|  2.57k|  if (part_start < buf_end) return VP8_STATUS_OK;
  ------------------
  |  Branch (251:7): [True: 2.51k, False: 61]
  ------------------
  252|     61|  return dec->incremental
  ------------------
  |  Branch (252:10): [True: 0, False: 61]
  ------------------
  253|     61|             ? VP8_STATUS_SUSPENDED  // Init is ok, but there's not enough data
  254|     61|             : VP8_STATUS_NOT_ENOUGH_DATA;
  255|  2.57k|}
vp8_dec.c:InitGetCoeffs_body:
  521|      1|WEBP_DSP_INIT_FUNC(InitGetCoeffs) {
  522|      1|  if (VP8GetCPUInfo != NULL && VP8GetCPUInfo(kSlowSSSE3)) {
  ------------------
  |  Branch (522:7): [True: 1, False: 0]
  |  Branch (522:32): [True: 0, False: 1]
  ------------------
  523|      0|    GetCoeffs = GetCoeffsAlt;
  524|      1|  } else {
  525|      1|    GetCoeffs = GetCoeffsFast;
  526|      1|  }
  527|      1|}
vp8_dec.c:GetLargeValue:
  429|  77.0k|static int GetLargeValue(VP8BitReader* const br, const uint8_t* const p) {
  430|  77.0k|  int v;
  431|  77.0k|  if (!VP8GetBit(br, p[3], "coeffs")) {
  ------------------
  |  |   46|  77.0k|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  ------------------
  |  Branch (431:7): [True: 18.1k, False: 58.8k]
  ------------------
  432|  18.1k|    if (!VP8GetBit(br, p[4], "coeffs")) {
  ------------------
  |  |   46|  18.1k|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  ------------------
  |  Branch (432:9): [True: 12.6k, False: 5.53k]
  ------------------
  433|  12.6k|      v = 2;
  434|  12.6k|    } else {
  435|  5.53k|      v = 3 + VP8GetBit(br, p[5], "coeffs");
  ------------------
  |  |   46|  5.53k|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  ------------------
  436|  5.53k|    }
  437|  58.8k|  } else {
  438|  58.8k|    if (!VP8GetBit(br, p[6], "coeffs")) {
  ------------------
  |  |   46|  58.8k|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  ------------------
  |  Branch (438:9): [True: 9.66k, False: 49.2k]
  ------------------
  439|  9.66k|      if (!VP8GetBit(br, p[7], "coeffs")) {
  ------------------
  |  |   46|  9.66k|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  ------------------
  |  Branch (439:11): [True: 3.81k, False: 5.85k]
  ------------------
  440|  3.81k|        v = 5 + VP8GetBit(br, 159, "coeffs");
  ------------------
  |  |   46|  3.81k|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  ------------------
  441|  5.85k|      } else {
  442|  5.85k|        v = 7 + 2 * VP8GetBit(br, 165, "coeffs");
  ------------------
  |  |   46|  5.85k|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  ------------------
  443|  5.85k|        v += VP8GetBit(br, 145, "coeffs");
  ------------------
  |  |   46|  5.85k|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  ------------------
  444|  5.85k|      }
  445|  49.2k|    } else {
  446|  49.2k|      const uint8_t* tab;
  447|  49.2k|      const int bit1 = VP8GetBit(br, p[8], "coeffs");
  ------------------
  |  |   46|  49.2k|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  ------------------
  448|  49.2k|      const int bit0 = VP8GetBit(br, p[9 + bit1], "coeffs");
  ------------------
  |  |   46|  49.2k|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  ------------------
  449|  49.2k|      const int cat = 2 * bit1 + bit0;
  450|  49.2k|      v = 0;
  451|   584k|      for (tab = kCat3456[cat]; *tab; ++tab) {
  ------------------
  |  Branch (451:33): [True: 535k, False: 49.2k]
  ------------------
  452|   535k|        v += v + VP8GetBit(br, *tab, "coeffs");
  ------------------
  |  |   46|   535k|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  ------------------
  453|   535k|      }
  454|  49.2k|      v += 3 + (8 << cat);
  455|  49.2k|    }
  456|  58.8k|  }
  457|  77.0k|  return v;
  458|  77.0k|}
vp8_dec.c:GetCoeffsFast:
  463|   563k|                         const quant_t dq, int n, int16_t* out) {
  464|   563k|  const uint8_t* p = prob[n]->probas[ctx];
  465|   762k|  for (; n < 16; ++n) {
  ------------------
  |  Branch (465:10): [True: 758k, False: 3.83k]
  ------------------
  466|   758k|    if (!VP8GetBit(br, p[0], "coeffs")) {
  ------------------
  |  |   46|   758k|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  ------------------
  |  Branch (466:9): [True: 559k, False: 198k]
  ------------------
  467|   559k|      return n;  // previous coeff was last non-zero coeff
  468|   559k|    }
  469|   308k|    while (!VP8GetBit(br, p[1], "coeffs")) {  // sequence of zero coeffs
  ------------------
  |  |   46|   308k|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  ------------------
  |  Branch (469:12): [True: 110k, False: 198k]
  ------------------
  470|   110k|      p = prob[++n]->probas[0];
  471|   110k|      if (n == 16) return 16;
  ------------------
  |  Branch (471:11): [True: 408, False: 109k]
  ------------------
  472|   110k|    }
  473|   198k|    {  // non zero coeff
  474|   198k|      const VP8ProbaArray* const p_ctx = &prob[n + 1]->probas[0];
  475|   198k|      int v;
  476|   198k|      if (!VP8GetBit(br, p[2], "coeffs")) {
  ------------------
  |  |   46|   198k|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  ------------------
  |  Branch (476:11): [True: 121k, False: 77.0k]
  ------------------
  477|   121k|        v = 1;
  478|   121k|        p = p_ctx[1];
  479|   121k|      } else {
  480|  77.0k|        v = GetLargeValue(br, p);
  481|  77.0k|        p = p_ctx[2];
  482|  77.0k|      }
  483|   198k|      out[kZigzag[n]] = VP8GetSigned(br, v, "coeffs") * dq[n > 0];
  ------------------
  |  |   48|   198k|#define VP8GetSigned(BR, V, L) VP8GetSigned(BR, V)
  ------------------
  484|   198k|    }
  485|   198k|  }
  486|  3.83k|  return 16;
  487|   563k|}
vp8_dec.c:ParseResiduals:
  536|  22.9k|                                         VP8BitReader* const token_br) {
  537|  22.9k|  const VP8BandProbas*(*const bands)[16 + 1] = dec->proba.bands_ptr;
  538|  22.9k|  const VP8BandProbas* const* ac_proba;
  539|  22.9k|  VP8MBData* const block = dec->mb_data + dec->mb_x;
  540|  22.9k|  const VP8QuantMatrix* const q = &dec->dqm[block->segment];
  541|  22.9k|  int16_t* dst = block->coeffs;
  542|  22.9k|  VP8MB* const left_mb = dec->mb_info - 1;
  543|  22.9k|  uint8_t tnz, lnz;
  544|  22.9k|  uint32_t non_zero_y = 0;
  545|  22.9k|  uint32_t non_zero_uv = 0;
  546|  22.9k|  int x, y, ch;
  547|  22.9k|  uint32_t out_t_nz, out_l_nz;
  548|  22.9k|  int first;
  549|       |
  550|  22.9k|  WEBP_UNSAFE_MEMSET(dst, 0, 384 * sizeof(*dst));
  ------------------
  |  |  175|  22.9k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  551|  22.9k|  if (!block->is_i4x4) {  // parse DC
  ------------------
  |  Branch (551:7): [True: 12.9k, False: 9.96k]
  ------------------
  552|  12.9k|    int16_t dc[16] = {0};
  553|  12.9k|    const int ctx = mb->nz_dc + left_mb->nz_dc;
  554|  12.9k|    const int nz = GetCoeffs(token_br, bands[1], ctx, q->y2_mat, 0, dc);
  555|  12.9k|    mb->nz_dc = left_mb->nz_dc = (nz > 0);
  556|  12.9k|    if (nz > 1) {  // more than just the DC -> perform the full transform
  ------------------
  |  Branch (556:9): [True: 2.56k, False: 10.4k]
  ------------------
  557|  2.56k|      VP8TransformWHT(dc, dst);
  558|  10.4k|    } else {  // only DC is non-zero -> inlined simplified transform
  559|  10.4k|      int i;
  560|  10.4k|      const int dc0 = (dc[0] + 3) >> 3;
  561|   177k|      for (i = 0; i < 16 * 16; i += 16) dst[i] = dc0;
  ------------------
  |  Branch (561:19): [True: 166k, False: 10.4k]
  ------------------
  562|  10.4k|    }
  563|  12.9k|    first = 1;
  564|  12.9k|    ac_proba = bands[0];
  565|  12.9k|  } else {
  566|  9.96k|    first = 0;
  567|  9.96k|    ac_proba = bands[3];
  568|  9.96k|  }
  569|       |
  570|  22.9k|  tnz = mb->nz & 0x0f;
  571|  22.9k|  lnz = left_mb->nz & 0x0f;
  572|   114k|  for (y = 0; y < 4; ++y) {
  ------------------
  |  Branch (572:15): [True: 91.7k, False: 22.9k]
  ------------------
  573|  91.7k|    int l = lnz & 1;
  574|  91.7k|    uint32_t nz_coeffs = 0;
  575|   458k|    for (x = 0; x < 4; ++x) {
  ------------------
  |  Branch (575:17): [True: 367k, False: 91.7k]
  ------------------
  576|   367k|      const int ctx = l + (tnz & 1);
  577|   367k|      const int nz = GetCoeffs(token_br, ac_proba, ctx, q->y1_mat, first, dst);
  578|   367k|      l = (nz > first);
  579|   367k|      tnz = (tnz >> 1) | (l << 7);
  580|   367k|      nz_coeffs = NzCodeBits(nz_coeffs, nz, dst[0] != 0);
  581|   367k|      dst += 16;
  582|   367k|    }
  583|  91.7k|    tnz >>= 4;
  584|  91.7k|    lnz = (lnz >> 1) | (l << 7);
  585|  91.7k|    non_zero_y = (non_zero_y << 8) | nz_coeffs;
  586|  91.7k|  }
  587|  22.9k|  out_t_nz = tnz;
  588|  22.9k|  out_l_nz = lnz >> 4;
  589|       |
  590|  68.8k|  for (ch = 0; ch < 4; ch += 2) {
  ------------------
  |  Branch (590:16): [True: 45.8k, False: 22.9k]
  ------------------
  591|  45.8k|    uint32_t nz_coeffs = 0;
  592|  45.8k|    tnz = mb->nz >> (4 + ch);
  593|  45.8k|    lnz = left_mb->nz >> (4 + ch);
  594|   137k|    for (y = 0; y < 2; ++y) {
  ------------------
  |  Branch (594:17): [True: 91.7k, False: 45.8k]
  ------------------
  595|  91.7k|      int l = lnz & 1;
  596|   275k|      for (x = 0; x < 2; ++x) {
  ------------------
  |  Branch (596:19): [True: 183k, False: 91.7k]
  ------------------
  597|   183k|        const int ctx = l + (tnz & 1);
  598|   183k|        const int nz = GetCoeffs(token_br, bands[2], ctx, q->uv_mat, 0, dst);
  599|   183k|        l = (nz > 0);
  600|   183k|        tnz = (tnz >> 1) | (l << 3);
  601|   183k|        nz_coeffs = NzCodeBits(nz_coeffs, nz, dst[0] != 0);
  602|   183k|        dst += 16;
  603|   183k|      }
  604|  91.7k|      tnz >>= 2;
  605|  91.7k|      lnz = (lnz >> 1) | (l << 5);
  606|  91.7k|    }
  607|       |    // Note: we don't really need the per-4x4 details for U/V blocks.
  608|  45.8k|    non_zero_uv |= nz_coeffs << (4 * ch);
  609|  45.8k|    out_t_nz |= (tnz << 4) << ch;
  610|  45.8k|    out_l_nz |= (lnz & 0xf0) << ch;
  611|  45.8k|  }
  612|  22.9k|  mb->nz = out_t_nz;
  613|  22.9k|  left_mb->nz = out_l_nz;
  614|       |
  615|  22.9k|  block->non_zero_y = non_zero_y;
  616|  22.9k|  block->non_zero_uv = non_zero_uv;
  617|       |
  618|       |  // We look at the mode-code of each block and check if some blocks have less
  619|       |  // than three non-zero coeffs (code < 2). This is to avoid dithering flat and
  620|       |  // empty blocks.
  621|  22.9k|  block->dither = (non_zero_uv & 0xaaaa) ? 0 : q->dither;
  ------------------
  |  Branch (621:19): [True: 8.73k, False: 14.2k]
  ------------------
  622|       |
  623|  22.9k|  return !(non_zero_y | non_zero_uv);  // will be used for further optimization
  624|  22.9k|}
vp8_dec.c:NzCodeBits:
  529|   550k|static WEBP_INLINE uint32_t NzCodeBits(uint32_t nz_coeffs, int nz, int dc_nz) {
  530|   550k|  nz_coeffs <<= 2;
  531|   550k|  nz_coeffs |= (nz > 3) ? 3 : (nz > 1) ? 2 : dc_nz;
  ------------------
  |  Branch (531:16): [True: 24.8k, False: 525k]
  |  Branch (531:31): [True: 32.9k, False: 492k]
  ------------------
  532|   550k|  return nz_coeffs;
  533|   550k|}
vp8_dec.c:ParseFrame:
  664|  2.48k|WEBP_NODISCARD static int ParseFrame(VP8Decoder* const dec, VP8Io* io) {
  665|  35.0k|  for (dec->mb_y = 0; dec->mb_y < dec->br_mb_y; ++dec->mb_y) {
  ------------------
  |  Branch (665:23): [True: 34.7k, False: 321]
  ------------------
  666|       |    // Parse bitstream for this row.
  667|  34.7k|    VP8BitReader* const token_br =
  668|  34.7k|        &dec->parts[dec->mb_y & dec->num_parts_minus_one];
  669|  34.7k|    if (!VP8ParseIntraModeRow(&dec->br, dec)) {
  ------------------
  |  Branch (669:9): [True: 1.19k, False: 33.5k]
  ------------------
  670|  1.19k|      return VP8SetError(dec, VP8_STATUS_NOT_ENOUGH_DATA,
  671|  1.19k|                         "Premature end-of-partition0 encountered.");
  672|  1.19k|    }
  673|  86.1k|    for (; dec->mb_x < dec->mb_w; ++dec->mb_x) {
  ------------------
  |  Branch (673:12): [True: 53.6k, False: 32.5k]
  ------------------
  674|  53.6k|      if (!VP8DecodeMB(dec, token_br)) {
  ------------------
  |  Branch (674:11): [True: 970, False: 52.6k]
  ------------------
  675|    970|        return VP8SetError(dec, VP8_STATUS_NOT_ENOUGH_DATA,
  676|    970|                           "Premature end-of-file encountered.");
  677|    970|      }
  678|  53.6k|    }
  679|  32.5k|    VP8InitScanline(dec);  // Prepare for next scanline
  680|       |
  681|       |    // Reconstruct, filter and emit the row.
  682|  32.5k|    if (!VP8ProcessRow(dec, io)) {
  ------------------
  |  Branch (682:9): [True: 0, False: 32.5k]
  ------------------
  683|      0|      return VP8SetError(dec, VP8_STATUS_USER_ABORT, "Output aborted.");
  684|      0|    }
  685|  32.5k|  }
  686|    321|  if (dec->mt_method > 0) {
  ------------------
  |  Branch (686:7): [True: 0, False: 321]
  ------------------
  687|       |    // Collect the last row's put(), which may have aborted.
  688|      0|    if (!WebPGetWorkerInterface()->Sync(&dec->worker)) {
  ------------------
  |  Branch (688:9): [True: 0, False: 0]
  ------------------
  689|      0|      return VP8SetError(dec, VP8_STATUS_USER_ABORT, "Output aborted.");
  690|      0|    }
  691|      0|  }
  692|       |
  693|    321|  return 1;
  694|    321|}

webp_dec.c:VP8InitIo:
  134|  4.73k|WEBP_NODISCARD static WEBP_INLINE int VP8InitIo(VP8Io* const io) {
  135|  4.73k|  return VP8InitIoInternal(io, WEBP_DECODER_ABI_VERSION);
  ------------------
  |  |   27|  4.73k|#define WEBP_DECODER_ABI_VERSION 0x0210  // MAJOR(8b) + MINOR(8b)
  ------------------
  136|  4.73k|}

VP8LCheckSignature:
  107|  17.3k|                       size_t size) {
  108|  17.3k|  return (size >= VP8L_FRAME_HEADER_SIZE && data[0] == VP8L_MAGIC_BYTE &&
  ------------------
  |  |   33|  34.6k|#define VP8L_FRAME_HEADER_SIZE 5  // Size of the VP8L frame header.
  ------------------
                return (size >= VP8L_FRAME_HEADER_SIZE && data[0] == VP8L_MAGIC_BYTE &&
  ------------------
  |  |   28|  34.6k|#define VP8L_MAGIC_BYTE 0x2f   // VP8L signature byte.
  ------------------
  |  Branch (108:11): [True: 17.3k, False: 0]
  |  Branch (108:45): [True: 10.3k, False: 6.95k]
  ------------------
  109|  10.3k|          (data[4] >> 5) == 0);  // version
  ------------------
  |  Branch (109:11): [True: 10.3k, False: 13]
  ------------------
  110|  17.3k|}
VP8LGetInfo:
  125|  5.24k|                int* const has_alpha) {
  126|  5.24k|  if (data == NULL || data_size < VP8L_FRAME_HEADER_SIZE) {
  ------------------
  |  |   33|  5.24k|#define VP8L_FRAME_HEADER_SIZE 5  // Size of the VP8L frame header.
  ------------------
  |  Branch (126:7): [True: 0, False: 5.24k]
  |  Branch (126:23): [True: 0, False: 5.24k]
  ------------------
  127|      0|    return 0;  // not enough data
  128|  5.24k|  } else if (!VP8LCheckSignature(data, data_size)) {
  ------------------
  |  Branch (128:14): [True: 7, False: 5.23k]
  ------------------
  129|      7|    return 0;  // bad signature
  130|  5.23k|  } else {
  131|  5.23k|    int w, h, a;
  132|  5.23k|    VP8LBitReader br;
  133|  5.23k|    VP8LInitBitReader(&br, data, data_size);
  134|  5.23k|    if (!ReadImageInfo(&br, &w, &h, &a)) {
  ------------------
  |  Branch (134:9): [True: 0, False: 5.23k]
  ------------------
  135|      0|      return 0;
  136|      0|    }
  137|  5.23k|    if (width != NULL) *width = w;
  ------------------
  |  Branch (137:9): [True: 5.23k, False: 0]
  ------------------
  138|  5.23k|    if (height != NULL) *height = h;
  ------------------
  |  Branch (138:9): [True: 5.23k, False: 0]
  ------------------
  139|  5.23k|    if (has_alpha != NULL) *has_alpha = a;
  ------------------
  |  Branch (139:9): [True: 3.17k, False: 2.06k]
  ------------------
  140|  5.23k|    return 1;
  141|  5.23k|  }
  142|  5.24k|}
ReadHuffmanCodesHelper:
  480|  3.24k|                           HTreeGroup** const htree_groups) {
  481|  3.24k|  int i, j, ok = 0;
  482|  3.24k|  const int max_alphabet_size =
  483|  3.24k|      kAlphabetSize[0] + ((color_cache_bits > 0) ? 1 << color_cache_bits : 0);
  ------------------
  |  Branch (483:27): [True: 610, False: 2.63k]
  ------------------
  484|  3.24k|  const int table_size = kTableSize[color_cache_bits];
  485|  3.24k|  int* code_lengths = NULL;
  486|  3.24k|  int total_huffman_table_size;
  487|       |
  488|  3.24k|  *htree_groups = NULL;
  489|  3.24k|  if ((mapping == NULL && num_htree_groups != num_htree_groups_max) ||
  ------------------
  |  Branch (489:8): [True: 3.08k, False: 166]
  |  Branch (489:27): [True: 0, False: 3.08k]
  ------------------
  490|  3.24k|      num_htree_groups > num_htree_groups_max) {
  ------------------
  |  Branch (490:7): [True: 0, False: 3.24k]
  ------------------
  491|      0|    VP8LSetError(dec, VP8_STATUS_BITSTREAM_ERROR);
  492|      0|    goto Error;
  493|      0|  }
  494|       |  // Each Huffman group has 5 trees, each requiring at least 4 bits in the
  495|       |  // bitstream (20 bits per group).
  496|  3.24k|  if ((uint64_t)(dec->br.len - dec->br.pos) * 8 + VP8L_LBITS <
  ------------------
  |  |  146|  3.24k|#define VP8L_LBITS 64  // Number of bits prefetched (= bit-size of vp8l_val_t).
  ------------------
  |  Branch (496:7): [True: 116, False: 3.13k]
  ------------------
  497|  3.24k|      (uint64_t)num_htree_groups_max * 20) {
  498|    116|    VP8LSetError(dec, VP8_STATUS_BITSTREAM_ERROR);
  499|    116|    goto Error;
  500|    116|  }
  501|       |
  502|  3.13k|  code_lengths =
  503|  3.13k|      (int*)WebPSafeCalloc((uint64_t)max_alphabet_size, sizeof(*code_lengths));
  504|  3.13k|  *htree_groups = VP8LHtreeGroupsNew(num_htree_groups);
  505|       |
  506|       |  // Cap the segment chunk size to ~320 KB (16 * table_size) for a small number
  507|       |  // of groups, or ~1 MB (52 * table_size) when there are many groups.
  508|  3.13k|  {
  509|  3.13k|    const int max_groups_per_chunk = (num_htree_groups > 256) ? 52 : 16;
  ------------------
  |  Branch (509:38): [True: 0, False: 3.13k]
  ------------------
  510|  3.13k|    total_huffman_table_size =
  511|  3.13k|        (num_htree_groups > max_groups_per_chunk ? max_groups_per_chunk
  ------------------
  |  Branch (511:10): [True: 95, False: 3.03k]
  ------------------
  512|  3.13k|                                                 : num_htree_groups) *
  513|  3.13k|        table_size;
  514|  3.13k|  }
  515|  3.13k|  if (*htree_groups == NULL || code_lengths == NULL ||
  ------------------
  |  Branch (515:7): [True: 0, False: 3.13k]
  |  Branch (515:32): [True: 0, False: 3.13k]
  ------------------
  516|  3.13k|      !VP8LHuffmanTablesAllocate(total_huffman_table_size, huffman_tables)) {
  ------------------
  |  Branch (516:7): [True: 0, False: 3.13k]
  ------------------
  517|      0|    VP8LSetError(dec, VP8_STATUS_OUT_OF_MEMORY);
  518|      0|    goto Error;
  519|      0|  }
  520|       |
  521|  33.2k|  for (i = 0; i < num_htree_groups_max; ++i) {
  ------------------
  |  Branch (521:15): [True: 30.7k, False: 2.52k]
  ------------------
  522|       |    // If the index "i" is unused in the Huffman image, just make sure the
  523|       |    // coefficients are valid but do not store them.
  524|  30.7k|    if (mapping != NULL && mapping[i] == -1) {
  ------------------
  |  Branch (524:9): [True: 21.8k, False: 8.88k]
  |  Branch (524:28): [True: 21.3k, False: 480]
  ------------------
  525|   128k|      for (j = 0; j < HUFFMAN_CODES_PER_META_CODE; ++j) {
  ------------------
  |  |   37|   128k|#define HUFFMAN_CODES_PER_META_CODE 5
  ------------------
  |  Branch (525:19): [True: 106k, False: 21.3k]
  ------------------
  526|   106k|        int alphabet_size = kAlphabetSize[j];
  527|   106k|        if (j == 0 && color_cache_bits > 0) {
  ------------------
  |  Branch (527:13): [True: 21.3k, False: 85.4k]
  |  Branch (527:23): [True: 21.0k, False: 327]
  ------------------
  528|  21.0k|          alphabet_size += (1 << color_cache_bits);
  529|  21.0k|        }
  530|       |        // Passing in NULL so that nothing gets filled.
  531|   106k|        if (!ReadHuffmanCode(alphabet_size, dec, code_lengths, NULL)) {
  ------------------
  |  Branch (531:13): [True: 34, False: 106k]
  ------------------
  532|     34|          goto Error;
  533|     34|        }
  534|   106k|      }
  535|  21.3k|    } else {
  536|  9.36k|      HTreeGroup* const htree_group =
  537|  9.36k|          &(*htree_groups)[(mapping == NULL) ? i : mapping[i]];
  ------------------
  |  Branch (537:28): [True: 8.88k, False: 480]
  ------------------
  538|  9.36k|      HuffmanCode** const htrees = htree_group->htrees;
  539|  9.36k|      int size;
  540|  9.36k|      int total_size = 0;
  541|  9.36k|      int is_trivial_literal = 1;
  542|  9.36k|      int max_bits = 0;
  543|  54.0k|      for (j = 0; j < HUFFMAN_CODES_PER_META_CODE; ++j) {
  ------------------
  |  |   37|  54.0k|#define HUFFMAN_CODES_PER_META_CODE 5
  ------------------
  |  Branch (543:19): [True: 45.2k, False: 8.78k]
  ------------------
  544|  45.2k|        int alphabet_size = kAlphabetSize[j];
  545|  45.2k|        if (j == 0 && color_cache_bits > 0) {
  ------------------
  |  Branch (545:13): [True: 9.36k, False: 35.8k]
  |  Branch (545:23): [True: 1.60k, False: 7.75k]
  ------------------
  546|  1.60k|          alphabet_size += (1 << color_cache_bits);
  547|  1.60k|        }
  548|  45.2k|        size =
  549|  45.2k|            ReadHuffmanCode(alphabet_size, dec, code_lengths, huffman_tables);
  550|  45.2k|        htrees[j] = huffman_tables->curr_segment->curr_table;
  551|  45.2k|        if (size == 0) {
  ------------------
  |  Branch (551:13): [True: 575, False: 44.6k]
  ------------------
  552|    575|          goto Error;
  553|    575|        }
  554|  44.6k|        if (is_trivial_literal && kLiteralMap[j] == 1) {
  ------------------
  |  Branch (554:13): [True: 38.4k, False: 6.19k]
  |  Branch (554:35): [True: 22.9k, False: 15.5k]
  ------------------
  555|  22.9k|          is_trivial_literal = (htrees[j]->bits == 0);
  556|  22.9k|        }
  557|  44.6k|        total_size += htrees[j]->bits;
  558|  44.6k|        huffman_tables->curr_segment->curr_table += size;
  559|  44.6k|        if (j <= ALPHA) {
  ------------------
  |  Branch (559:13): [True: 35.8k, False: 8.78k]
  ------------------
  560|  35.8k|          int local_max_bits = code_lengths[0];
  561|  35.8k|          int k;
  562|  10.0M|          for (k = 1; k < alphabet_size; ++k) {
  ------------------
  |  Branch (562:23): [True: 10.0M, False: 35.8k]
  ------------------
  563|  10.0M|            if (code_lengths[k] > local_max_bits) {
  ------------------
  |  Branch (563:17): [True: 17.4k, False: 10.0M]
  ------------------
  564|  17.4k|              local_max_bits = code_lengths[k];
  565|  17.4k|            }
  566|  10.0M|          }
  567|  35.8k|          max_bits += local_max_bits;
  568|  35.8k|        }
  569|  44.6k|      }
  570|  8.78k|      htree_group->is_trivial_literal = is_trivial_literal;
  571|  8.78k|      htree_group->is_trivial_code = 0;
  572|  8.78k|      if (is_trivial_literal) {
  ------------------
  |  Branch (572:11): [True: 6.40k, False: 2.38k]
  ------------------
  573|  6.40k|        const int red = htrees[RED][0].value;
  574|  6.40k|        const int blue = htrees[BLUE][0].value;
  575|  6.40k|        const int alpha = htrees[ALPHA][0].value;
  576|  6.40k|        htree_group->literal_arb = ((uint32_t)alpha << 24) | (red << 16) | blue;
  577|  6.40k|        if (total_size == 0 && htrees[GREEN][0].value < NUM_LITERAL_CODES) {
  ------------------
  |  |   43|  5.91k|#define NUM_LITERAL_CODES 256
  ------------------
  |  Branch (577:13): [True: 5.91k, False: 488]
  |  Branch (577:32): [True: 5.90k, False: 14]
  ------------------
  578|  5.90k|          htree_group->is_trivial_code = 1;
  579|  5.90k|          htree_group->literal_arb |= htrees[GREEN][0].value << 8;
  580|  5.90k|        }
  581|  6.40k|      }
  582|  8.78k|      htree_group->packed_table = NULL;
  583|  8.78k|      if (!htree_group->is_trivial_code && (max_bits < HUFFMAN_PACKED_BITS) &&
  ------------------
  |  |   78|  2.88k|#define HUFFMAN_PACKED_BITS 6
  ------------------
  |  Branch (583:11): [True: 2.88k, False: 5.90k]
  |  Branch (583:44): [True: 2.70k, False: 180]
  ------------------
  584|  2.70k|          !BuildPackedTable(htree_group, huffman_tables)) {
  ------------------
  |  Branch (584:11): [True: 0, False: 2.70k]
  ------------------
  585|      0|        VP8LSetError(dec, VP8_STATUS_OUT_OF_MEMORY);
  586|      0|        goto Error;
  587|      0|      }
  588|  8.78k|    }
  589|  30.7k|  }
  590|  2.52k|  ok = 1;
  591|       |
  592|  3.24k|Error:
  593|  3.24k|  WebPSafeFree(code_lengths);
  594|  3.24k|  if (!ok) {
  ------------------
  |  Branch (594:7): [True: 725, False: 2.52k]
  ------------------
  595|    725|    VP8LHuffmanTablesDeallocate(huffman_tables);
  596|    725|    VP8LHtreeGroupsFree(*htree_groups);
  597|       |    *htree_groups = NULL;
  598|    725|  }
  599|  3.24k|  return ok;
  600|  2.52k|}
VP8LGetWindowRows:
 1204|  1.23k|int VP8LGetWindowRows(int width, int height, int max_history_rows) {
 1205|       |  // A backward reference of MAX_LENGTH pixels starting mid-row can span 1 extra
 1206|       |  // row beyond ceil(MAX_LENGTH / width).
 1207|  1.23k|  const int max_length_rows = (MAX_LENGTH + width - 1) / width + 1;
  ------------------
  |  |   51|  1.23k|#define MAX_LENGTH ((1 << MAX_LENGTH_BITS) - 1)
  |  |  ------------------
  |  |  |  |   48|  1.23k|#define MAX_LENGTH_BITS 12
  |  |  ------------------
  ------------------
 1208|       |  // Minimum rows required in the window at any shift point:
 1209|       |  // - max_history_rows: backward-reference history prior to last_row/saved_row.
 1210|       |  // - NUM_ARGB_CACHE_ROWS: decoded rows queued before ProcessRows/SaveState.
 1211|       |  // - max_length_rows: headroom for a MAX_LENGTH copy before the next shift.
 1212|       |  // - 2: 1 for the current partially-decoded row + 1 for the (num_window_rows -
 1213|       |  //   1) margin in GetWindowLimit().
 1214|  1.23k|  const int min_rows =
 1215|  1.23k|      max_history_rows + NUM_ARGB_CACHE_ROWS + max_length_rows + 2;
  ------------------
  |  |   36|  1.23k|#define NUM_ARGB_CACHE_ROWS 16
  ------------------
 1216|       |  // Allocate 2x min_rows so that ShiftWindow() shifts ~min_rows at a time
 1217|       |  // rather than on every batch, amortizing the memmove() cost.
 1218|  1.23k|  const int num_window_rows = 2 * min_rows;
 1219|  1.23k|  return (num_window_rows < height) ? num_window_rows : height;
  ------------------
  |  Branch (1219:10): [True: 0, False: 1.23k]
  ------------------
 1220|  1.23k|}
VP8LNew:
 1698|  2.06k|VP8LDecoder* VP8LNew(void) {
 1699|  2.06k|  VP8LDecoder* const dec = (VP8LDecoder*)WebPSafeCalloc(1ULL, sizeof(*dec));
 1700|  2.06k|  if (dec == NULL) return NULL;
  ------------------
  |  Branch (1700:7): [True: 0, False: 2.06k]
  ------------------
 1701|  2.06k|  dec->status = VP8_STATUS_OK;
 1702|  2.06k|  dec->state = READ_DIM;
 1703|       |
 1704|  2.06k|  VP8LDspInit();  // Init critical function pointers.
 1705|       |
 1706|  2.06k|  return dec;
 1707|  2.06k|}
VP8LDelete:
 1745|  2.06k|void VP8LDelete(VP8LDecoder* const dec) {
 1746|  2.06k|  if (dec != NULL) {
  ------------------
  |  Branch (1746:7): [True: 2.06k, False: 0]
  ------------------
 1747|  2.06k|    VP8LClear(dec);
 1748|  2.06k|    WebPSafeFree(dec);
 1749|  2.06k|  }
 1750|  2.06k|}
VP8LDecodeHeader:
 2012|  2.06k|int VP8LDecodeHeader(VP8LDecoder* const dec, VP8Io* const io) {
 2013|  2.06k|  int width, height, has_alpha;
 2014|       |
 2015|  2.06k|  if (dec == NULL) return 0;
  ------------------
  |  Branch (2015:7): [True: 0, False: 2.06k]
  ------------------
 2016|  2.06k|  if (io == NULL) {
  ------------------
  |  Branch (2016:7): [True: 0, False: 2.06k]
  ------------------
 2017|      0|    return VP8LSetError(dec, VP8_STATUS_INVALID_PARAM);
 2018|      0|  }
 2019|       |
 2020|  2.06k|  dec->io = io;
 2021|  2.06k|  dec->status = VP8_STATUS_OK;
 2022|  2.06k|  {
 2023|  2.06k|    const uint8_t* WEBP_BIDI_INDEXABLE const bounded_data =
 2024|  2.06k|        WEBP_UNSAFE_FORGE_BIDI_INDEXABLE(const uint8_t*, io->data,
  ------------------
  |  |  180|  2.06k|#define WEBP_UNSAFE_FORGE_BIDI_INDEXABLE(typ, ptr, size) ((typ)(ptr))
  ------------------
 2025|  2.06k|                                         io->data_size);
 2026|  2.06k|    VP8LInitBitReader(&dec->br, bounded_data, io->data_size);
 2027|  2.06k|  }
 2028|  2.06k|  if (!ReadImageInfo(&dec->br, &width, &height, &has_alpha)) {
  ------------------
  |  Branch (2028:7): [True: 0, False: 2.06k]
  ------------------
 2029|      0|    VP8LSetError(dec, VP8_STATUS_BITSTREAM_ERROR);
 2030|      0|    goto Error;
 2031|      0|  }
 2032|  2.06k|  dec->state = READ_DIM;
 2033|  2.06k|  io->width = width;
 2034|  2.06k|  io->height = height;
 2035|       |
 2036|  2.06k|  if (!DecodeImageStream(width, height, /*is_level0=*/1, dec,
  ------------------
  |  Branch (2036:7): [True: 805, False: 1.25k]
  ------------------
 2037|  2.06k|                         /*decoded_data=*/NULL)) {
 2038|    805|    goto Error;
 2039|    805|  }
 2040|  1.25k|  return 1;
 2041|       |
 2042|    805|Error:
 2043|    805|  VP8LClear(dec);
 2044|       |  assert(dec->status != VP8_STATUS_OK);
 2045|    805|  return 0;
 2046|  2.06k|}
VP8LDecodeImage:
 2048|  1.23k|int VP8LDecodeImage(VP8LDecoder* const dec) {
 2049|  1.23k|  VP8Io* io = NULL;
 2050|  1.23k|  WebPDecParams* params = NULL;
 2051|       |
 2052|  1.23k|  if (dec == NULL) return 0;
  ------------------
  |  Branch (2052:7): [True: 0, False: 1.23k]
  ------------------
 2053|       |
 2054|  1.23k|  assert(dec->hdr.huffman_tables.root.start != NULL);
 2055|  1.23k|  assert(dec->hdr.htree_groups != NULL);
 2056|  1.23k|  assert(dec->hdr.num_htree_groups > 0);
 2057|       |
 2058|  1.23k|  io = dec->io;
 2059|  1.23k|  assert(io != NULL);
 2060|  1.23k|  params = (WebPDecParams*)io->opaque;
 2061|  1.23k|  assert(params != NULL);
 2062|       |
 2063|       |  // Initialization.
 2064|  1.23k|  if (dec->state != READ_DATA) {
  ------------------
  |  Branch (2064:7): [True: 1.23k, False: 0]
  ------------------
 2065|  1.23k|    dec->output = params->output;
 2066|  1.23k|    assert(dec->output != NULL);
 2067|       |
 2068|  1.23k|    if (!WebPIoInitFromOptions(params->options, io, MODE_BGRA)) {
  ------------------
  |  Branch (2068:9): [True: 0, False: 1.23k]
  ------------------
 2069|      0|      VP8LSetError(dec, VP8_STATUS_INVALID_PARAM);
 2070|      0|      goto Err;
 2071|      0|    }
 2072|       |
 2073|  1.23k|    if (!AllocateInternalBuffers32b(dec, io->width)) goto Err;
  ------------------
  |  Branch (2073:9): [True: 0, False: 1.23k]
  ------------------
 2074|       |
 2075|  1.23k|#if !defined(WEBP_REDUCE_SIZE)
 2076|  1.23k|    if (io->use_scaling && !AllocateAndInitRescaler(dec, io)) goto Err;
  ------------------
  |  Branch (2076:9): [True: 0, False: 1.23k]
  |  Branch (2076:28): [True: 0, False: 0]
  ------------------
 2077|       |#else
 2078|       |    if (io->use_scaling) {
 2079|       |      VP8LSetError(dec, VP8_STATUS_INVALID_PARAM);
 2080|       |      goto Err;
 2081|       |    }
 2082|       |#endif
 2083|  1.23k|    if (io->use_scaling || WebPIsPremultipliedMode(dec->output->colorspace)) {
  ------------------
  |  Branch (2083:9): [True: 0, False: 1.23k]
  |  Branch (2083:28): [True: 0, False: 1.23k]
  ------------------
 2084|       |      // need the alpha-multiply functions for premultiplied output or rescaling
 2085|      0|      WebPInitAlphaProcessing();
 2086|      0|    }
 2087|       |
 2088|  1.23k|    if (!WebPIsRGBMode(dec->output->colorspace)) {
  ------------------
  |  Branch (2088:9): [True: 286, False: 949]
  ------------------
 2089|    286|      WebPInitConvertARGBToYUV();
 2090|    286|      if (WebPIsAlphaMode(dec->output->colorspace) &&
  ------------------
  |  Branch (2090:11): [True: 0, False: 286]
  ------------------
 2091|      0|          dec->output->u.YUVA.a != NULL) {
  ------------------
  |  Branch (2091:11): [True: 0, False: 0]
  ------------------
 2092|      0|        WebPInitAlphaProcessing();
 2093|      0|      }
 2094|    286|    }
 2095|  1.23k|    if (dec->incremental) {
  ------------------
  |  Branch (2095:9): [True: 0, False: 1.23k]
  ------------------
 2096|      0|      if (dec->hdr.color_cache_size > 0 &&
  ------------------
  |  Branch (2096:11): [True: 0, False: 0]
  ------------------
 2097|      0|          dec->hdr.saved_color_cache.colors == NULL) {
  ------------------
  |  Branch (2097:11): [True: 0, False: 0]
  ------------------
 2098|      0|        if (!VP8LColorCacheInit(&dec->hdr.saved_color_cache,
  ------------------
  |  Branch (2098:13): [True: 0, False: 0]
  ------------------
 2099|      0|                                dec->hdr.color_cache.hash_bits)) {
 2100|      0|          VP8LSetError(dec, VP8_STATUS_OUT_OF_MEMORY);
 2101|      0|          goto Err;
 2102|      0|        }
 2103|      0|      }
 2104|      0|    }
 2105|  1.23k|    dec->state = READ_DATA;
 2106|  1.23k|  }
 2107|       |
 2108|       |  // Decode.
 2109|  1.23k|  if (!DecodeImageData(dec, dec->pixels, dec->width, dec->height,
  ------------------
  |  Branch (2109:7): [True: 322, False: 913]
  ------------------
 2110|  1.23k|                       io->crop_bottom, ProcessRows)) {
 2111|    322|    goto Err;
 2112|    322|  }
 2113|       |
 2114|    913|  params->last_y = dec->last_out_row;
 2115|    913|  return 1;
 2116|       |
 2117|    322|Err:
 2118|    322|  VP8LClear(dec);
 2119|       |  assert(dec->status != VP8_STATUS_OK);
 2120|    322|  return 0;
 2121|  1.23k|}
vp8l_dec.c:ReadImageInfo:
  114|  7.30k|                                        int* const has_alpha) {
  115|  7.30k|  if (VP8LReadBits(br, 8) != VP8L_MAGIC_BYTE) return 0;
  ------------------
  |  |   28|  7.30k|#define VP8L_MAGIC_BYTE 0x2f   // VP8L signature byte.
  ------------------
  |  Branch (115:7): [True: 0, False: 7.30k]
  ------------------
  116|  7.30k|  *width = VP8LReadBits(br, VP8L_IMAGE_SIZE_BITS) + 1;
  ------------------
  |  |   30|  7.30k|  14                         // Number of bits used to store width and height.
  ------------------
  117|  7.30k|  *height = VP8LReadBits(br, VP8L_IMAGE_SIZE_BITS) + 1;
  ------------------
  |  |   30|  7.30k|  14                         // Number of bits used to store width and height.
  ------------------
  118|  7.30k|  *has_alpha = VP8LReadBits(br, 1);
  119|  7.30k|  if (VP8LReadBits(br, VP8L_VERSION_BITS) != 0) return 0;
  ------------------
  |  |   31|  7.30k|#define VP8L_VERSION_BITS 3  // 3 bits reserved for version.
  ------------------
  |  Branch (119:7): [True: 0, False: 7.30k]
  ------------------
  120|  7.30k|  return !br->eos;
  121|  7.30k|}
vp8l_dec.c:VP8LSetError:
   92|  2.36k|static int VP8LSetError(VP8LDecoder* const dec, VP8StatusCode error) {
   93|       |  // The oldest error reported takes precedence over the new one.
   94|  2.36k|  if (dec->status == VP8_STATUS_OK || dec->status == VP8_STATUS_SUSPENDED) {
  ------------------
  |  Branch (94:7): [True: 1.12k, False: 1.23k]
  |  Branch (94:39): [True: 0, False: 1.23k]
  ------------------
   95|  1.12k|    dec->status = error;
   96|  1.12k|  }
   97|  2.36k|  return 0;
   98|  2.36k|}
vp8l_dec.c:ReadHuffmanCode:
  330|   152k|                                          HuffmanTables* const table) {
  331|   152k|  int ok = 0;
  332|   152k|  int size = 0;
  333|   152k|  VP8LBitReader* const br = &dec->br;
  334|   152k|  const int simple_code = VP8LReadBits(br, 1);
  335|       |
  336|   152k|  WEBP_UNSAFE_MEMSET(code_lengths, 0, alphabet_size * sizeof(*code_lengths));
  ------------------
  |  |  175|   152k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  337|       |
  338|   152k|  if (simple_code) {  // Read symbols, codes & code lengths directly.
  ------------------
  |  Branch (338:7): [True: 151k, False: 1.05k]
  ------------------
  339|   151k|    const int num_symbols = VP8LReadBits(br, 1) + 1;
  340|   151k|    const int first_symbol_len_code = VP8LReadBits(br, 1);
  341|       |    // The first code is either 1 bit or 8 bit code.
  342|   151k|    int symbol = VP8LReadBits(br, (first_symbol_len_code == 0) ? 1 : 8);
  ------------------
  |  Branch (342:35): [True: 149k, False: 1.37k]
  ------------------
  343|       |    // 'symbol' can exceed 'alphabet_size', but not code_lengths[]'s size.
  344|   151k|    code_lengths[symbol] = 1;
  345|       |    // The second code (if present), is always 8 bits long.
  346|   151k|    if (num_symbols == 2) {
  ------------------
  |  Branch (346:9): [True: 112k, False: 38.9k]
  ------------------
  347|   112k|      symbol = VP8LReadBits(br, 8);
  348|   112k|      code_lengths[symbol] = 1;
  349|   112k|    }
  350|   151k|    ok = 1;
  351|   151k|  } else {  // Decode Huffman-coded code lengths.
  352|  1.05k|    int i;
  353|  1.05k|    int code_length_code_lengths[NUM_CODE_LENGTH_CODES] = {0};
  354|  1.05k|    const int num_codes = VP8LReadBits(br, 4) + 4;
  355|  1.05k|    assert(num_codes <= NUM_CODE_LENGTH_CODES);
  356|       |
  357|  9.85k|    for (i = 0; i < num_codes; ++i) {
  ------------------
  |  Branch (357:17): [True: 8.80k, False: 1.05k]
  ------------------
  358|  8.80k|      code_length_code_lengths[kCodeLengthCodeOrder[i]] = VP8LReadBits(br, 3);
  359|  8.80k|    }
  360|  1.05k|    ok = ReadHuffmanCodeLengths(dec, code_length_code_lengths, alphabet_size,
  361|  1.05k|                                code_lengths);
  362|  1.05k|  }
  363|       |
  364|   152k|  ok = ok && !br->eos;
  ------------------
  |  Branch (364:8): [True: 151k, False: 299]
  |  Branch (364:14): [True: 151k, False: 173]
  ------------------
  365|   152k|  if (ok) {
  ------------------
  |  Branch (365:7): [True: 151k, False: 472]
  ------------------
  366|   151k|    const int* WEBP_BIDI_INDEXABLE const bounded_code_lengths =
  367|   151k|        WEBP_UNSAFE_FORGE_BIDI_INDEXABLE(const int*, code_lengths,
  ------------------
  |  |  180|   151k|#define WEBP_UNSAFE_FORGE_BIDI_INDEXABLE(typ, ptr, size) ((typ)(ptr))
  ------------------
  368|   151k|                                         alphabet_size * sizeof(int));
  369|   151k|    size = VP8LBuildHuffmanTable(table, HUFFMAN_TABLE_BITS,
  ------------------
  |  |   29|   151k|#define HUFFMAN_TABLE_BITS 8
  ------------------
  370|   151k|                                 bounded_code_lengths, alphabet_size);
  371|   151k|  }
  372|   152k|  if (!ok || size <= 0) {
  ------------------
  |  Branch (372:7): [True: 472, False: 151k]
  |  Branch (372:14): [True: 137, False: 151k]
  ------------------
  373|    609|    return VP8LSetError(dec, (size < 0) ? VP8_STATUS_OUT_OF_MEMORY
  ------------------
  |  Branch (373:30): [True: 0, False: 609]
  ------------------
  374|    609|                                        : VP8_STATUS_BITSTREAM_ERROR);
  375|    609|  }
  376|   151k|  return size;
  377|   152k|}
vp8l_dec.c:ReadHuffmanCodeLengths:
  258|  1.05k|    int num_symbols, int* const code_lengths) {
  259|  1.05k|  int ok = 0;
  260|  1.05k|  VP8StatusCode status = VP8_STATUS_BITSTREAM_ERROR;
  261|  1.05k|  VP8LBitReader* const br = &dec->br;
  262|  1.05k|  int size;
  263|  1.05k|  int symbol;
  264|  1.05k|  int max_symbol;
  265|  1.05k|  int prev_code_len = DEFAULT_CODE_LENGTH;
  ------------------
  |  |   40|  1.05k|#define DEFAULT_CODE_LENGTH 8
  ------------------
  266|  1.05k|  HuffmanTables tables;
  267|  1.05k|  const int* WEBP_BIDI_INDEXABLE const bounded_code_lengths =
  268|  1.05k|      WEBP_UNSAFE_FORGE_BIDI_INDEXABLE(
  ------------------
  |  |  180|  1.05k|#define WEBP_UNSAFE_FORGE_BIDI_INDEXABLE(typ, ptr, size) ((typ)(ptr))
  ------------------
  269|  1.05k|          const int*, code_length_code_lengths,
  270|  1.05k|          NUM_CODE_LENGTH_CODES * sizeof(*code_length_code_lengths));
  271|       |
  272|  1.05k|  if (!VP8LHuffmanTablesAllocate(1 << LENGTHS_TABLE_BITS, &tables)) {
  ------------------
  |  |   32|  1.05k|#define LENGTHS_TABLE_BITS 7
  ------------------
  |  Branch (272:7): [True: 0, False: 1.05k]
  ------------------
  273|      0|    status = VP8_STATUS_OUT_OF_MEMORY;
  274|      0|    goto End;
  275|      0|  }
  276|  1.05k|  size = VP8LBuildHuffmanTable(&tables, LENGTHS_TABLE_BITS,
  ------------------
  |  |   32|  1.05k|#define LENGTHS_TABLE_BITS 7
  ------------------
  277|  1.05k|                               bounded_code_lengths, NUM_CODE_LENGTH_CODES);
  ------------------
  |  |   60|  1.05k|#define NUM_CODE_LENGTH_CODES 19
  ------------------
  278|  1.05k|  if (size < 0) status = VP8_STATUS_OUT_OF_MEMORY;
  ------------------
  |  Branch (278:7): [True: 0, False: 1.05k]
  ------------------
  279|  1.05k|  if (size <= 0) goto End;
  ------------------
  |  Branch (279:7): [True: 220, False: 832]
  ------------------
  280|       |
  281|    832|  if (VP8LReadBits(br, 1)) {  // use length
  ------------------
  |  Branch (281:7): [True: 635, False: 197]
  ------------------
  282|    635|    const int length_nbits = 2 + 2 * VP8LReadBits(br, 3);
  283|    635|    max_symbol = 2 + VP8LReadBits(br, length_nbits);
  284|    635|    if (max_symbol > num_symbols) {
  ------------------
  |  Branch (284:9): [True: 21, False: 614]
  ------------------
  285|     21|      goto End;
  286|     21|    }
  287|    635|  } else {
  288|    197|    max_symbol = num_symbols;
  289|    197|  }
  290|       |
  291|    811|  symbol = 0;
  292|   109k|  while (symbol < num_symbols) {
  ------------------
  |  Branch (292:10): [True: 109k, False: 150]
  ------------------
  293|   109k|    const HuffmanCode* p;
  294|   109k|    int code_len;
  295|   109k|    if (max_symbol-- == 0) break;
  ------------------
  |  Branch (295:9): [True: 603, False: 109k]
  ------------------
  296|   109k|    VP8LFillBitWindow(br);
  297|   109k|    p = &tables.curr_segment->start[VP8LPrefetchBits(br) & LENGTHS_TABLE_MASK];
  ------------------
  |  |   33|   109k|#define LENGTHS_TABLE_MASK ((1 << LENGTHS_TABLE_BITS) - 1)
  |  |  ------------------
  |  |  |  |   32|   109k|#define LENGTHS_TABLE_BITS 7
  |  |  ------------------
  ------------------
  298|   109k|    VP8LSetBitPos(br, br->bit_pos + p->bits);
  299|   109k|    code_len = p->value;
  300|   109k|    if (code_len < kCodeLengthLiterals) {
  ------------------
  |  Branch (300:9): [True: 96.8k, False: 12.1k]
  ------------------
  301|  96.8k|      code_lengths[symbol++] = code_len;
  302|  96.8k|      if (code_len != 0) prev_code_len = code_len;
  ------------------
  |  Branch (302:11): [True: 91.4k, False: 5.41k]
  ------------------
  303|  96.8k|    } else {
  304|  12.1k|      const int use_prev = (code_len == kCodeLengthRepeatCode);
  305|  12.1k|      const int slot = code_len - kCodeLengthLiterals;
  306|  12.1k|      const int extra_bits = kCodeLengthExtraBits[slot];
  307|  12.1k|      const int repeat_offset = kCodeLengthRepeatOffsets[slot];
  308|  12.1k|      int repeat = VP8LReadBits(br, extra_bits) + repeat_offset;
  309|  12.1k|      if (symbol + repeat > num_symbols) {
  ------------------
  |  Branch (309:11): [True: 58, False: 12.1k]
  ------------------
  310|     58|        goto End;
  311|  12.1k|      } else {
  312|  12.1k|        const int length = use_prev ? prev_code_len : 0;
  ------------------
  |  Branch (312:28): [True: 5.57k, False: 6.52k]
  ------------------
  313|   150k|        while (repeat-- > 0) code_lengths[symbol++] = length;
  ------------------
  |  Branch (313:16): [True: 138k, False: 12.1k]
  ------------------
  314|  12.1k|      }
  315|  12.1k|    }
  316|   109k|  }
  317|    753|  ok = 1;
  318|       |
  319|  1.05k|End:
  320|  1.05k|  VP8LHuffmanTablesDeallocate(&tables);
  321|  1.05k|  if (!ok) return VP8LSetError(dec, status);
  ------------------
  |  Branch (321:7): [True: 299, False: 753]
  ------------------
  322|    753|  return ok;
  323|  1.05k|}
vp8l_dec.c:BuildPackedTable:
  225|  2.70k|                            HuffmanTables* const huffman_tables) {
  226|  2.70k|  uint32_t code;
  227|  2.70k|  const int total_size = HUFFMAN_PACKED_TABLE_SIZE *
  ------------------
  |  |   79|  2.70k|#define HUFFMAN_PACKED_TABLE_SIZE (1u << HUFFMAN_PACKED_BITS)
  |  |  ------------------
  |  |  |  |   78|  2.70k|#define HUFFMAN_PACKED_BITS 6
  |  |  ------------------
  ------------------
  228|  2.70k|                         sizeof(*htree_group->packed_table) /
  229|  2.70k|                         sizeof(*huffman_tables->curr_segment->curr_table);
  230|  2.70k|  if (!VP8LHuffmanTablesEnsureCapacity(total_size, huffman_tables)) {
  ------------------
  |  Branch (230:7): [True: 0, False: 2.70k]
  ------------------
  231|      0|    return 0;
  232|      0|  }
  233|  2.70k|  htree_group->packed_table =
  234|  2.70k|      (HuffmanCode32*)huffman_tables->curr_segment->curr_table;
  235|  2.70k|  huffman_tables->curr_segment->curr_table += total_size;
  236|   175k|  for (code = 0; code < HUFFMAN_PACKED_TABLE_SIZE; ++code) {
  ------------------
  |  |   79|   175k|#define HUFFMAN_PACKED_TABLE_SIZE (1u << HUFFMAN_PACKED_BITS)
  |  |  ------------------
  |  |  |  |   78|   175k|#define HUFFMAN_PACKED_BITS 6
  |  |  ------------------
  ------------------
  |  Branch (236:18): [True: 173k, False: 2.70k]
  ------------------
  237|   173k|    uint32_t bits = code;
  238|   173k|    HuffmanCode32* const huff = &htree_group->packed_table[bits];
  239|   173k|    HuffmanCode hcode = htree_group->htrees[GREEN][bits];
  240|   173k|    if (hcode.value >= NUM_LITERAL_CODES) {
  ------------------
  |  |   43|   173k|#define NUM_LITERAL_CODES 256
  ------------------
  |  Branch (240:9): [True: 9.42k, False: 163k]
  ------------------
  241|  9.42k|      huff->bits = hcode.bits + BITS_SPECIAL_MARKER;
  ------------------
  |  |  196|  9.42k|#define BITS_SPECIAL_MARKER 0x100  // something large enough (and a bit-mask)
  ------------------
  242|  9.42k|      huff->value = hcode.value;
  243|   163k|    } else {
  244|   163k|      huff->bits = 0;
  245|   163k|      huff->value = 0;
  246|   163k|      bits >>= AccumulateHCode(hcode, 8, huff);
  247|   163k|      bits >>= AccumulateHCode(htree_group->htrees[RED][bits], 16, huff);
  248|   163k|      bits >>= AccumulateHCode(htree_group->htrees[BLUE][bits], 0, huff);
  249|   163k|      bits >>= AccumulateHCode(htree_group->htrees[ALPHA][bits], 24, huff);
  250|   163k|      (void)bits;
  251|   163k|    }
  252|   173k|  }
  253|  2.70k|  return 1;
  254|  2.70k|}
vp8l_dec.c:AccumulateHCode:
  217|   654k|                           HuffmanCode32* const huff) {
  218|   654k|  huff->bits += hcode.bits;
  219|   654k|  huff->value |= (uint32_t)hcode.value << shift;
  220|       |  assert(huff->bits <= HUFFMAN_TABLE_BITS);
  221|   654k|  return hcode.bits;
  222|   654k|}
vp8l_dec.c:VP8LClear:
 1722|  3.18k|static void VP8LClear(VP8LDecoder* const dec) {
 1723|  3.18k|  int i;
 1724|  3.18k|  if (dec == NULL) return;
  ------------------
  |  Branch (1724:7): [True: 0, False: 3.18k]
  ------------------
 1725|  3.18k|  ClearMetadata(&dec->hdr);
 1726|       |
 1727|  3.18k|  ClearInternalBuffers(dec);
 1728|  4.30k|  for (i = 0; i < dec->next_transform; ++i) {
  ------------------
  |  Branch (1728:15): [True: 1.11k, False: 3.18k]
  ------------------
 1729|  1.11k|    ClearTransform(&dec->transforms[i]);
 1730|  1.11k|  }
 1731|  3.18k|  dec->next_transform = 0;
 1732|  3.18k|  dec->transforms_seen = 0;
 1733|       |
 1734|  3.18k|  if (dec->rescaler != NULL) {
  ------------------
  |  Branch (1734:7): [True: 0, False: 3.18k]
  ------------------
 1735|      0|    WebPSafeFree(dec->rescaler->dst);
 1736|      0|    WebPSafeFree(dec->rescaler);
 1737|      0|    dec->rescaler = NULL;
 1738|      0|  }
 1739|  3.18k|  WebPSafeFree(dec->rescaler_memory);
 1740|  3.18k|  dec->rescaler_memory = NULL;
 1741|       |
 1742|       |  dec->output = NULL;  // leave no trace behind
 1743|  3.18k|}
vp8l_dec.c:ClearMetadata:
 1684|  5.40k|static void ClearMetadata(VP8LMetadata* const hdr) {
 1685|  5.40k|  assert(hdr != NULL);
 1686|       |
 1687|  5.40k|  WebPSafeFree(hdr->huffman_image);
 1688|  5.40k|  VP8LHuffmanTablesDeallocate(&hdr->huffman_tables);
 1689|  5.40k|  VP8LHtreeGroupsFree(hdr->htree_groups);
 1690|  5.40k|  VP8LColorCacheClear(&hdr->color_cache);
 1691|  5.40k|  VP8LColorCacheClear(&hdr->saved_color_cache);
 1692|  5.40k|  InitMetadata(hdr);
 1693|  5.40k|}
vp8l_dec.c:InitMetadata:
 1679|  5.40k|static void InitMetadata(VP8LMetadata* const hdr) {
 1680|  5.40k|  assert(hdr != NULL);
 1681|  5.40k|  WEBP_UNSAFE_MEMSET(hdr, 0, sizeof(*hdr));
  ------------------
  |  |  175|  5.40k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
 1682|  5.40k|}
vp8l_dec.c:ClearInternalBuffers:
 1711|  3.18k|static void ClearInternalBuffers(VP8LDecoder* const dec) {
 1712|  3.18k|  WebPSafeFree(dec->pixels);
 1713|  3.18k|  dec->pixels = NULL;
 1714|  3.18k|  dec->argb_cache = NULL;
 1715|       |  dec->accumulated_rgb_pixels = NULL;
 1716|  3.18k|  dec->num_window_rows = 0;
 1717|  3.18k|  dec->window_start_row = 0;
 1718|  3.18k|}
vp8l_dec.c:ClearTransform:
 1587|  1.11k|static void ClearTransform(VP8LTransform* const transform) {
 1588|  1.11k|  WebPSafeFree(transform->data);
 1589|       |  transform->data = NULL;
 1590|  1.11k|}
vp8l_dec.c:DecodeImageStream:
 1764|  3.47k|                                            uint32_t** const decoded_data) {
 1765|  3.47k|  int ok = 1;
 1766|  3.47k|  int transform_xsize = xsize;
 1767|  3.47k|  int transform_ysize = ysize;
 1768|  3.47k|  VP8LBitReader* const br = &dec->br;
 1769|  3.47k|  VP8LMetadata* const hdr = &dec->hdr;
 1770|  3.47k|  uint32_t* data = NULL;
 1771|  3.47k|  int color_cache_bits = 0;
 1772|       |
 1773|       |  // Read the transforms (may recurse).
 1774|  3.47k|  if (is_level0) {
  ------------------
  |  Branch (1774:7): [True: 2.06k, False: 1.41k]
  ------------------
 1775|  3.17k|    while (ok && VP8LReadBits(br, 1)) {
  ------------------
  |  Branch (1775:12): [True: 3.06k, False: 116]
  |  Branch (1775:18): [True: 1.11k, False: 1.94k]
  ------------------
 1776|  1.11k|      ok = ReadTransform(&transform_xsize, transform_ysize, dec);
 1777|  1.11k|    }
 1778|  2.06k|  }
 1779|       |
 1780|       |  // Color cache
 1781|  3.47k|  if (ok && VP8LReadBits(br, 1)) {
  ------------------
  |  Branch (1781:7): [True: 3.36k, False: 116]
  |  Branch (1781:13): [True: 633, False: 2.72k]
  ------------------
 1782|    633|    color_cache_bits = VP8LReadBits(br, 4);
 1783|    633|    ok = (color_cache_bits >= 1 && color_cache_bits <= MAX_CACHE_BITS);
  ------------------
  |  |   36|    632|#define MAX_CACHE_BITS 11
  ------------------
  |  Branch (1783:11): [True: 632, False: 1]
  |  Branch (1783:36): [True: 625, False: 7]
  ------------------
 1784|    633|    if (!ok) {
  ------------------
  |  Branch (1784:9): [True: 8, False: 625]
  ------------------
 1785|      8|      VP8LSetError(dec, VP8_STATUS_BITSTREAM_ERROR);
 1786|      8|      goto End;
 1787|      8|    }
 1788|    633|  }
 1789|       |
 1790|       |  // Read the Huffman codes (may recurse).
 1791|  3.46k|  ok = ok && ReadHuffmanCodes(dec, transform_xsize, transform_ysize,
  ------------------
  |  Branch (1791:8): [True: 3.35k, False: 116]
  |  Branch (1791:14): [True: 2.52k, False: 831]
  ------------------
 1792|  3.35k|                              color_cache_bits, is_level0);
 1793|  3.46k|  if (!ok) {
  ------------------
  |  Branch (1793:7): [True: 947, False: 2.52k]
  ------------------
 1794|    947|    VP8LSetError(dec, VP8_STATUS_BITSTREAM_ERROR);
 1795|    947|    goto End;
 1796|    947|  }
 1797|       |
 1798|       |  // Finish setting up the color-cache
 1799|  2.52k|  if (color_cache_bits > 0) {
  ------------------
  |  Branch (1799:7): [True: 409, False: 2.11k]
  ------------------
 1800|    409|    hdr->color_cache_size = 1 << color_cache_bits;
 1801|    409|    if (!VP8LColorCacheInit(&hdr->color_cache, color_cache_bits)) {
  ------------------
  |  Branch (1801:9): [True: 0, False: 409]
  ------------------
 1802|      0|      ok = VP8LSetError(dec, VP8_STATUS_OUT_OF_MEMORY);
 1803|      0|      goto End;
 1804|      0|    }
 1805|  2.11k|  } else {
 1806|  2.11k|    hdr->color_cache_size = 0;
 1807|  2.11k|  }
 1808|  2.52k|  UpdateDecoder(dec, transform_xsize, transform_ysize);
 1809|       |
 1810|  2.52k|  if (is_level0) {  // level 0 complete
  ------------------
  |  Branch (1810:7): [True: 1.25k, False: 1.26k]
  ------------------
 1811|  1.25k|    dec->state = READ_HDR;
 1812|  1.25k|    goto End;
 1813|  1.25k|  }
 1814|       |
 1815|  1.26k|  {
 1816|  1.26k|    const uint64_t total_size = (uint64_t)transform_xsize * transform_ysize;
 1817|  1.26k|    data = (uint32_t*)WebPSafeMalloc(total_size, sizeof(*data));
 1818|  1.26k|    if (data == NULL) {
  ------------------
  |  Branch (1818:9): [True: 0, False: 1.26k]
  ------------------
 1819|      0|      ok = VP8LSetError(dec, VP8_STATUS_OUT_OF_MEMORY);
 1820|      0|      goto End;
 1821|      0|    }
 1822|  1.26k|  }
 1823|       |
 1824|       |  // Use the Huffman trees to decode the LZ77 encoded data.
 1825|  1.26k|  ok = DecodeImageData(dec, data, transform_xsize, transform_ysize,
 1826|  1.26k|                       transform_ysize, NULL);
 1827|  1.26k|  ok = ok && !br->eos;
  ------------------
  |  Branch (1827:8): [True: 1.20k, False: 59]
  |  Branch (1827:14): [True: 1.20k, False: 0]
  ------------------
 1828|       |
 1829|  3.47k|End:
 1830|  3.47k|  if (!ok) {
  ------------------
  |  Branch (1830:7): [True: 1.01k, False: 2.46k]
  ------------------
 1831|  1.01k|    WebPSafeFree(data);
 1832|  1.01k|    ClearMetadata(hdr);
 1833|  2.46k|  } else {
 1834|  2.46k|    if (decoded_data != NULL) {
  ------------------
  |  Branch (1834:9): [True: 1.20k, False: 1.25k]
  ------------------
 1835|  1.20k|      *decoded_data = data;
 1836|  1.25k|    } else {
 1837|       |      // We allocate image data in this function only for transforms. At level 0
 1838|       |      // (that is: not the transforms), we shouldn't have allocated anything.
 1839|  1.25k|      assert(data == NULL);
 1840|  1.25k|      assert(is_level0);
 1841|  1.25k|    }
 1842|  2.46k|    dec->last_pixel = 0;  // Reset for future DECODE_DATA_FUNC() calls.
 1843|  2.46k|    if (!is_level0) ClearMetadata(hdr);  // Clean up temporary data behind.
  ------------------
  |  Branch (1843:9): [True: 1.20k, False: 1.25k]
  ------------------
 1844|  2.46k|  }
 1845|  3.47k|  return ok;
 1846|  1.26k|}
vp8l_dec.c:ReadTransform:
 1621|  1.11k|                                        VP8LDecoder* const dec) {
 1622|  1.11k|  int ok = 1;
 1623|  1.11k|  VP8LBitReader* const br = &dec->br;
 1624|  1.11k|  VP8LTransform* transform = &dec->transforms[dec->next_transform];
 1625|  1.11k|  const VP8LImageTransformType type =
 1626|  1.11k|      (VP8LImageTransformType)VP8LReadBits(br, 2);
 1627|       |
 1628|       |  // Each transform type can only be present once in the stream.
 1629|  1.11k|  if (dec->transforms_seen & (1U << type)) {
  ------------------
  |  Branch (1629:7): [True: 3, False: 1.11k]
  ------------------
 1630|      3|    return 0;  // Already there, let's not accept the second same transform.
 1631|      3|  }
 1632|  1.11k|  dec->transforms_seen |= (1U << type);
 1633|       |
 1634|  1.11k|  transform->type = type;
 1635|  1.11k|  transform->xsize = *xsize;
 1636|  1.11k|  transform->ysize = ysize;
 1637|  1.11k|  transform->data = NULL;
 1638|  1.11k|  ++dec->next_transform;
 1639|  1.11k|  assert(dec->next_transform <= NUM_TRANSFORMS);
 1640|       |
 1641|  1.11k|  switch (type) {
 1642|    577|    case PREDICTOR_TRANSFORM:
  ------------------
  |  Branch (1642:5): [True: 577, False: 535]
  ------------------
 1643|    723|    case CROSS_COLOR_TRANSFORM:
  ------------------
  |  Branch (1643:5): [True: 146, False: 966]
  ------------------
 1644|    723|      transform->bits =
 1645|    723|          MIN_TRANSFORM_BITS + VP8LReadBits(br, NUM_TRANSFORM_BITS);
  ------------------
  |  |   60|    723|#define MIN_TRANSFORM_BITS 2
  ------------------
                        MIN_TRANSFORM_BITS + VP8LReadBits(br, NUM_TRANSFORM_BITS);
  ------------------
  |  |   61|    723|#define NUM_TRANSFORM_BITS 3
  ------------------
 1646|    723|      ok = DecodeImageStream(
 1647|    723|          VP8LSubSampleSize(transform->xsize, transform->bits),
 1648|    723|          VP8LSubSampleSize(transform->ysize, transform->bits),
 1649|    723|          /*is_level0=*/0, dec, &transform->data);
 1650|    723|      break;
 1651|    209|    case COLOR_INDEXING_TRANSFORM: {
  ------------------
  |  Branch (1651:5): [True: 209, False: 903]
  ------------------
 1652|    209|      const int num_colors = VP8LReadBits(br, 8) + 1;
 1653|    209|      const int bits = (num_colors > 16)  ? 0
  ------------------
  |  Branch (1653:24): [True: 77, False: 132]
  ------------------
 1654|    209|                       : (num_colors > 4) ? 1
  ------------------
  |  Branch (1654:26): [True: 46, False: 86]
  ------------------
 1655|    132|                       : (num_colors > 2) ? 2
  ------------------
  |  Branch (1655:26): [True: 41, False: 45]
  ------------------
 1656|     86|                                          : 3;
 1657|    209|      *xsize = VP8LSubSampleSize(transform->xsize, bits);
 1658|    209|      transform->bits = bits;
 1659|    209|      ok = DecodeImageStream(num_colors, /*ysize=*/1, /*is_level0=*/0, dec,
 1660|    209|                             &transform->data);
 1661|    209|      if (ok && !ExpandColorMap(num_colors, transform)) {
  ------------------
  |  Branch (1661:11): [True: 194, False: 15]
  |  Branch (1661:17): [True: 0, False: 194]
  ------------------
 1662|      0|        return VP8LSetError(dec, VP8_STATUS_OUT_OF_MEMORY);
 1663|      0|      }
 1664|    209|      break;
 1665|    209|    }
 1666|    209|    case SUBTRACT_GREEN_TRANSFORM:
  ------------------
  |  Branch (1666:5): [True: 180, False: 932]
  ------------------
 1667|    180|      break;
 1668|      0|    default:
  ------------------
  |  Branch (1668:5): [True: 0, False: 1.11k]
  ------------------
 1669|      0|      assert(0);  // can't happen
 1670|      0|      break;
 1671|  1.11k|  }
 1672|       |
 1673|  1.11k|  return ok;
 1674|  1.11k|}
vp8l_dec.c:ExpandColorMap:
 1595|    194|                                         VP8LTransform* const transform) {
 1596|    194|  int i;
 1597|    194|  const int final_num_colors = 1 << (8 >> transform->bits);
 1598|    194|  uint32_t* const new_color_map = (uint32_t*)WebPSafeMalloc(
 1599|    194|      (uint64_t)final_num_colors, sizeof(*new_color_map));
 1600|    194|  if (new_color_map == NULL) {
  ------------------
  |  Branch (1600:7): [True: 0, False: 194]
  ------------------
 1601|      0|    return 0;
 1602|    194|  } else {
 1603|    194|    uint8_t* const data = (uint8_t*)transform->data;
 1604|    194|    uint8_t* const new_data = (uint8_t*)new_color_map;
 1605|    194|    new_color_map[0] = transform->data[0];
 1606|  33.0k|    for (i = 4; i < 4 * num_colors; ++i) {
  ------------------
  |  Branch (1606:17): [True: 32.8k, False: 194]
  ------------------
 1607|       |      // Equivalent to VP8LAddPixels(), on a byte-basis.
 1608|  32.8k|      new_data[i] = (data[i] + new_data[i - 4]) & 0xff;
 1609|  32.8k|    }
 1610|  39.8k|    for (; i < 4 * final_num_colors; ++i) {
  ------------------
  |  Branch (1610:12): [True: 39.6k, False: 194]
  ------------------
 1611|  39.6k|      new_data[i] = 0;  // black tail.
 1612|  39.6k|    }
 1613|    194|    WebPSafeFree(transform->data);
 1614|    194|    transform->data = new_color_map;
 1615|    194|  }
 1616|    194|  return 1;
 1617|    194|}
vp8l_dec.c:ReadHuffmanCodes:
  381|  3.35k|                                           int allow_recursion) {
  382|  3.35k|  int i;
  383|  3.35k|  VP8LBitReader* const br = &dec->br;
  384|  3.35k|  VP8LMetadata* const hdr = &dec->hdr;
  385|  3.35k|  uint32_t* huffman_image = NULL;
  386|  3.35k|  HTreeGroup* htree_groups = NULL;
  387|  3.35k|  HuffmanTables* huffman_tables = &hdr->huffman_tables;
  388|  3.35k|  int num_htree_groups = 1;
  389|  3.35k|  int num_htree_groups_max = 1;
  390|  3.35k|  int* mapping = NULL;
  391|  3.35k|  int ok = 0;
  392|       |
  393|       |  // Check the table has been 0 initialized (through InitMetadata).
  394|  3.35k|  assert(huffman_tables->root.start == NULL);
  395|  3.35k|  assert(huffman_tables->curr_segment == NULL);
  396|       |
  397|  3.35k|  if (allow_recursion && VP8LReadBits(br, 1)) {
  ------------------
  |  Branch (397:7): [True: 1.94k, False: 1.41k]
  |  Branch (397:26): [True: 483, False: 1.45k]
  ------------------
  398|       |    // use meta Huffman codes.
  399|    483|    const int huffman_precision =
  400|    483|        MIN_HUFFMAN_BITS + VP8LReadBits(br, NUM_HUFFMAN_BITS);
  ------------------
  |  |   55|    483|#define MIN_HUFFMAN_BITS 2  // min number of Huffman bits
  ------------------
                      MIN_HUFFMAN_BITS + VP8LReadBits(br, NUM_HUFFMAN_BITS);
  ------------------
  |  |   56|    483|#define NUM_HUFFMAN_BITS 3
  ------------------
  401|    483|    const int huffman_xsize = VP8LSubSampleSize(xsize, huffman_precision);
  402|    483|    const int huffman_ysize = VP8LSubSampleSize(ysize, huffman_precision);
  403|    483|    const int huffman_pixs = huffman_xsize * huffman_ysize;
  404|    483|    if (!DecodeImageStream(huffman_xsize, huffman_ysize, /*is_level0=*/0, dec,
  ------------------
  |  Branch (404:9): [True: 96, False: 387]
  ------------------
  405|    483|                           &huffman_image)) {
  406|     96|      goto Error;
  407|     96|    }
  408|    387|    hdr->huffman_subsample_bits = huffman_precision;
  409|   312k|    for (i = 0; i < huffman_pixs; ++i) {
  ------------------
  |  Branch (409:17): [True: 312k, False: 387]
  ------------------
  410|       |      // The huffman data is stored in red and green bytes.
  411|   312k|      const int group = (huffman_image[i] >> 8) & 0xffff;
  412|   312k|      huffman_image[i] = group;
  413|   312k|      if (group >= num_htree_groups_max) {
  ------------------
  |  Branch (413:11): [True: 615, False: 311k]
  ------------------
  414|    615|        num_htree_groups_max = group + 1;
  415|    615|      }
  416|   312k|    }
  417|       |    // Check the validity of num_htree_groups_max. If it seems too big, use a
  418|       |    // smaller value for later. This will prevent big memory allocations to end
  419|       |    // up with a bad bitstream anyway.
  420|       |    // The value of 200 is arbitrary but the encoder of the current code usually
  421|       |    // does not go above that value. We also know that num_htree_groups_max is
  422|       |    // smaller than (1 << 16) and should be smaller than the number of pixels in
  423|       |    // the Huffman image (though the format allows it to be bigger).
  424|    387|    if (num_htree_groups_max > 200 || num_htree_groups_max > huffman_pixs) {
  ------------------
  |  Branch (424:9): [True: 117, False: 270]
  |  Branch (424:39): [True: 49, False: 221]
  ------------------
  425|       |      // Create a mapping from the used indices to the minimal set of used
  426|       |      // values [0, num_htree_groups)
  427|    166|      mapping = (int*)WebPSafeMalloc(num_htree_groups_max, sizeof(*mapping));
  428|    166|      if (mapping == NULL) {
  ------------------
  |  Branch (428:11): [True: 0, False: 166]
  ------------------
  429|      0|        VP8LSetError(dec, VP8_STATUS_OUT_OF_MEMORY);
  430|      0|        goto Error;
  431|      0|      }
  432|       |      // -1 means a value is unmapped, and therefore unused in the Huffman
  433|       |      // image.
  434|    166|      WEBP_UNSAFE_MEMSET(mapping, 0xff,
  ------------------
  |  |  175|    166|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  435|    166|                         num_htree_groups_max * sizeof(*mapping));
  436|  53.9k|      for (num_htree_groups = 0, i = 0; i < huffman_pixs; ++i) {
  ------------------
  |  Branch (436:41): [True: 53.7k, False: 166]
  ------------------
  437|       |        // Get the current mapping for the group and remap the Huffman image.
  438|  53.7k|        int* const mapped_group = &mapping[huffman_image[i]];
  439|  53.7k|        if (*mapped_group == -1) *mapped_group = num_htree_groups++;
  ------------------
  |  Branch (439:13): [True: 5.42k, False: 48.3k]
  ------------------
  440|  53.7k|        huffman_image[i] = *mapped_group;
  441|  53.7k|      }
  442|    221|    } else {
  443|    221|      num_htree_groups = num_htree_groups_max;
  444|    221|    }
  445|    387|    if (num_htree_groups == 1) {
  ------------------
  |  Branch (445:9): [True: 101, False: 286]
  ------------------
  446|    101|      WebPSafeFree(huffman_image);
  447|    101|      huffman_image = NULL;
  448|    101|      hdr->huffman_subsample_bits = 0;
  449|    101|    }
  450|    387|  }
  451|       |
  452|  3.25k|  if (br->eos) goto Error;
  ------------------
  |  Branch (452:7): [True: 10, False: 3.24k]
  ------------------
  453|       |
  454|  3.24k|  if (!ReadHuffmanCodesHelper(color_cache_bits, num_htree_groups,
  ------------------
  |  Branch (454:7): [True: 725, False: 2.52k]
  ------------------
  455|  3.24k|                              num_htree_groups_max, mapping, dec,
  456|  3.24k|                              huffman_tables, &htree_groups)) {
  457|    725|    goto Error;
  458|    725|  }
  459|  2.52k|  ok = 1;
  460|       |
  461|       |  // All OK. Finalize pointers.
  462|  2.52k|  hdr->huffman_image = huffman_image;
  463|  2.52k|  hdr->num_htree_groups = num_htree_groups;
  464|  2.52k|  hdr->htree_groups = htree_groups;
  465|       |
  466|  3.35k|Error:
  467|  3.35k|  WebPSafeFree(mapping);
  468|  3.35k|  if (!ok) {
  ------------------
  |  Branch (468:7): [True: 831, False: 2.52k]
  ------------------
  469|    831|    WebPSafeFree(huffman_image);
  470|    831|    VP8LHuffmanTablesDeallocate(huffman_tables);
  471|    831|    VP8LHtreeGroupsFree(htree_groups);
  472|    831|  }
  473|  3.35k|  return ok;
  474|  2.52k|}
vp8l_dec.c:UpdateDecoder:
 1752|  2.52k|static void UpdateDecoder(VP8LDecoder* const dec, int width, int height) {
 1753|  2.52k|  VP8LMetadata* const hdr = &dec->hdr;
 1754|  2.52k|  const int num_bits = hdr->huffman_subsample_bits;
 1755|  2.52k|  dec->width = width;
 1756|  2.52k|  dec->height = height;
 1757|       |
 1758|  2.52k|  hdr->huffman_xsize = VP8LSubSampleSize(width, num_bits);
 1759|  2.52k|  hdr->huffman_mask = (num_bits == 0) ? ~0 : (1 << num_bits) - 1;
  ------------------
  |  Branch (1759:23): [True: 2.49k, False: 23]
  ------------------
 1760|  2.52k|}
vp8l_dec.c:GetWindowRows:
 1224|  1.23k|static int GetWindowRows(int width, int height) {
 1225|  1.23k|  return VP8LGetWindowRows(width, height, GetMaxDistanceRows(width));
 1226|  1.23k|}
vp8l_dec.c:GetMaxDistanceRows:
 1197|  1.23k|static int GetMaxDistanceRows(int width) {
 1198|  1.23k|  const int max_plane_dist = 7 * width + 8;
 1199|  1.23k|  const int max_dist =
 1200|  1.23k|      (LZ77_WINDOW_SIZE > max_plane_dist) ? LZ77_WINDOW_SIZE : max_plane_dist;
  ------------------
  |  |   53|  1.23k|#define LZ77_WINDOW_SIZE ((1 << LZ77_WINDOW_SIZE_BITS) - 120)
  |  |  ------------------
  |  |  |  |   49|  1.23k|#define LZ77_WINDOW_SIZE_BITS 20
  |  |  ------------------
  ------------------
                    (LZ77_WINDOW_SIZE > max_plane_dist) ? LZ77_WINDOW_SIZE : max_plane_dist;
  ------------------
  |  |   53|  1.23k|#define LZ77_WINDOW_SIZE ((1 << LZ77_WINDOW_SIZE_BITS) - 120)
  |  |  ------------------
  |  |  |  |   49|  1.23k|#define LZ77_WINDOW_SIZE_BITS 20
  |  |  ------------------
  ------------------
  |  Branch (1200:7): [True: 1.23k, False: 0]
  ------------------
 1201|  1.23k|  return (max_dist + width - 1) / width;
 1202|  1.23k|}
vp8l_dec.c:AllocateInternalBuffers32b:
 1851|  1.23k|                                                     int final_width) {
 1852|  1.23k|  const int num_window_rows = GetWindowRows(dec->width, dec->height);
 1853|  1.23k|  const uint64_t num_pixels = (uint64_t)dec->width * num_window_rows;
 1854|       |  // Scratch buffer corresponding to top-prediction row for transforming the
 1855|       |  // first row in the row-blocks. Not needed for paletted alpha.
 1856|  1.23k|  const uint64_t cache_top_pixels = final_width;
 1857|       |  // Scratch buffer for temporary BGRA storage. Not needed for paletted alpha.
 1858|  1.23k|  const uint64_t cache_pixels = (uint64_t)final_width * NUM_ARGB_CACHE_ROWS;
  ------------------
  |  |   36|  1.23k|#define NUM_ARGB_CACHE_ROWS 16
  ------------------
 1859|       |  // Scratch buffer to accumulate RGBA values (hence 4*)for YUV conversion.
 1860|  1.23k|  uint64_t accumulated_rgb_pixels = 0;
 1861|  1.23k|  uint64_t total_num_pixels;
 1862|  1.23k|  if (dec->output != NULL && !WebPIsRGBMode(dec->output->colorspace)) {
  ------------------
  |  Branch (1862:7): [True: 1.23k, False: 0]
  |  Branch (1862:30): [True: 286, False: 949]
  ------------------
 1863|    286|    const int uv_width = (dec->io->crop_right - dec->io->crop_left + 1) >> 1;
 1864|    286|    accumulated_rgb_pixels =
 1865|    286|        4 * uv_width * sizeof(*dec->accumulated_rgb_pixels) / sizeof(uint32_t);
 1866|    286|  }
 1867|  1.23k|  total_num_pixels =
 1868|  1.23k|      num_pixels + cache_top_pixels + cache_pixels + accumulated_rgb_pixels;
 1869|  1.23k|  assert(dec->width <= final_width);
 1870|  1.23k|  dec->pixels = (uint32_t*)WebPSafeMalloc(total_num_pixels, sizeof(uint32_t));
 1871|  1.23k|  if (dec->pixels == NULL) {
  ------------------
  |  Branch (1871:7): [True: 0, False: 1.23k]
  ------------------
 1872|      0|    ClearInternalBuffers(dec);
 1873|      0|    return VP8LSetError(dec, VP8_STATUS_OUT_OF_MEMORY);
 1874|      0|  }
 1875|  1.23k|  dec->num_window_rows = num_window_rows;
 1876|  1.23k|  dec->window_start_row = 0;
 1877|  1.23k|  dec->argb_cache = dec->pixels + num_pixels + cache_top_pixels;
 1878|  1.23k|  dec->accumulated_rgb_pixels =
 1879|  1.23k|      accumulated_rgb_pixels == 0
  ------------------
  |  Branch (1879:7): [True: 949, False: 286]
  ------------------
 1880|  1.23k|          ? NULL
 1881|  1.23k|          : (uint16_t*)(dec->pixels + num_pixels + cache_top_pixels +
 1882|    286|                        cache_pixels);
 1883|       |
 1884|  1.23k|  return 1;
 1885|  1.23k|}
vp8l_dec.c:GetWindowLimit:
 1233|  2.50k|                                int has_process_func) {
 1234|  2.50k|  if (!has_process_func || dec->num_window_rows >= height) return 0;
  ------------------
  |  Branch (1234:7): [True: 1.26k, False: 1.23k]
  |  Branch (1234:28): [True: 1.23k, False: 0]
  ------------------
 1235|      0|  return (ptrdiff_t)(dec->num_window_rows - 1) * dec->width - MAX_LENGTH;
  ------------------
  |  |   51|      0|#define MAX_LENGTH ((1 << MAX_LENGTH_BITS) - 1)
  |  |  ------------------
  |  |  |  |   48|      0|#define MAX_LENGTH_BITS 12
  |  |  ------------------
  ------------------
 1236|  2.50k|}
vp8l_dec.c:GetWindowOffset:
  927|  4.61k|static WEBP_INLINE ptrdiff_t GetWindowOffset(const VP8LDecoder* const dec) {
  928|  4.61k|  return (ptrdiff_t)dec->window_start_row * dec->width;
  929|  4.61k|}
vp8l_dec.c:GetWindowRowOffset:
  941|  1.05M|                                                int row) {
  942|  1.05M|  return (ptrdiff_t)(row - dec->window_start_row) * dec->width;
  943|  1.05M|}
vp8l_dec.c:GetHtreeGroupForPos:
  890|  1.10M|                                                   int x, int y) {
  891|  1.10M|  const int meta_index = GetMetaIndex(hdr->huffman_image, hdr->huffman_xsize,
  892|  1.10M|                                      hdr->huffman_subsample_bits, x, y);
  893|       |  assert(meta_index < hdr->num_htree_groups);
  894|  1.10M|  return hdr->htree_groups + meta_index;
  895|  1.10M|}
vp8l_dec.c:GetMetaIndex:
  884|  1.10M|                                    int bits, int x, int y) {
  885|  1.10M|  if (bits == 0) return 0;
  ------------------
  |  Branch (885:7): [True: 1.08M, False: 17.6k]
  ------------------
  886|  17.6k|  return image[xsize * (y >> bits) + (x >> bits)];
  887|  1.10M|}
vp8l_dec.c:ReadSymbol:
  180|  2.70M|                                  VP8LBitReader* const br) {
  181|  2.70M|  int nbits;
  182|  2.70M|  uint32_t val = VP8LPrefetchBits(br);
  183|  2.70M|  table += val & HUFFMAN_TABLE_MASK;
  ------------------
  |  |   30|  2.70M|#define HUFFMAN_TABLE_MASK ((1 << HUFFMAN_TABLE_BITS) - 1)
  |  |  ------------------
  |  |  |  |   29|  2.70M|#define HUFFMAN_TABLE_BITS 8
  |  |  ------------------
  ------------------
  184|  2.70M|  nbits = table->bits - HUFFMAN_TABLE_BITS;
  ------------------
  |  |   29|  2.70M|#define HUFFMAN_TABLE_BITS 8
  ------------------
  185|  2.70M|  if (nbits > 0) {
  ------------------
  |  Branch (185:7): [True: 203k, False: 2.50M]
  ------------------
  186|   203k|    VP8LSetBitPos(br, br->bit_pos + HUFFMAN_TABLE_BITS);
  ------------------
  |  |   29|   203k|#define HUFFMAN_TABLE_BITS 8
  ------------------
  187|   203k|    val = VP8LPrefetchBits(br);
  188|   203k|    table += table->value;
  189|   203k|    table += val & ((1 << nbits) - 1);
  190|   203k|  }
  191|  2.70M|  VP8LSetBitPos(br, br->bit_pos + table->bits);
  192|  2.70M|  return table->value;
  193|  2.70M|}
vp8l_dec.c:GetCopyLength:
  158|  29.0k|                                     VP8LBitReader* const br) {
  159|       |  // Length and distance prefixes are encoded the same way.
  160|  29.0k|  return GetCopyDistance(length_symbol, br);
  161|  29.0k|}
vp8l_dec.c:GetCopyDistance:
  147|  58.1k|                                       VP8LBitReader* const br) {
  148|  58.1k|  int extra_bits, offset;
  149|  58.1k|  if (distance_symbol < 4) {
  ------------------
  |  Branch (149:7): [True: 52.4k, False: 5.70k]
  ------------------
  150|  52.4k|    return distance_symbol + 1;
  151|  52.4k|  }
  152|  5.70k|  extra_bits = (distance_symbol - 2) >> 1;
  153|  5.70k|  offset = (2 + (distance_symbol & 1)) << extra_bits;
  154|  5.70k|  return offset + VP8LReadBits(br, extra_bits) + 1;
  155|  58.1k|}
vp8l_dec.c:PlaneCodeToDistance:
  163|  29.0k|static WEBP_INLINE int PlaneCodeToDistance(int xsize, int plane_code) {
  164|  29.0k|  if (plane_code > CODE_TO_PLANE_CODES) {
  ------------------
  |  |   64|  29.0k|#define CODE_TO_PLANE_CODES 120
  ------------------
  |  Branch (164:7): [True: 392, False: 28.6k]
  ------------------
  165|    392|    return plane_code - CODE_TO_PLANE_CODES;
  ------------------
  |  |   64|    392|#define CODE_TO_PLANE_CODES 120
  ------------------
  166|  28.6k|  } else {
  167|  28.6k|    const int dist_code = kCodeToPlane[plane_code - 1];
  168|  28.6k|    const int yoffset = dist_code >> 4;
  169|  28.6k|    const int xoffset = 8 - (dist_code & 0xf);
  170|  28.6k|    const int dist = yoffset * xsize + xoffset;
  171|  28.6k|    return (dist >= 1) ? dist : 1;  // dist<1 can happen if xsize is very small
  ------------------
  |  Branch (171:12): [True: 25.6k, False: 3.05k]
  ------------------
  172|  28.6k|  }
  173|  29.0k|}
vp8l_dec.c:ShiftWindow:
 1260|  1.08M|                             size_t elem_size) {
 1261|  1.08M|  int min_row, min_window_start_row;
 1262|  1.08M|  if (window_limit == 0 || src_offset < window_limit) return 0;
  ------------------
  |  Branch (1262:7): [True: 1.08M, False: 0]
  |  Branch (1262:28): [True: 0, False: 0]
  ------------------
 1263|      0|  min_row = dec->last_row;
 1264|      0|  if (dec->incremental) {
  ------------------
  |  Branch (1264:7): [True: 0, False: 0]
  ------------------
 1265|      0|    const int saved_row = dec->saved_last_pixel / dec->width;
 1266|      0|    if (saved_row < min_row) min_row = saved_row;
  ------------------
  |  Branch (1266:9): [True: 0, False: 0]
  ------------------
 1267|      0|  }
 1268|      0|  min_window_start_row = min_row - GetMaxDistanceRows(dec->width);
 1269|      0|  return VP8LShiftWindowBuffer(data, dec->width, elem_size,
 1270|      0|                               min_window_start_row, src_offset,
 1271|      0|                               &dec->window_start_row);
 1272|  1.08M|}
vp8l_dec.c:GetAbsoluteOffset:
  934|  2.11k|                                         ptrdiff_t window_offset) {
  935|  2.11k|  return (int)(window_offset + GetWindowOffset(dec));
  936|  2.11k|}
vp8l_dec.c:DecodeImageData:
 1421|  2.50k|                                          ProcessRowsFunc process_func) {
 1422|  2.50k|  int row = dec->last_pixel / width;
 1423|  2.50k|  int col = dec->last_pixel % width;
 1424|  2.50k|  VP8LBitReader* const br = &dec->br;
 1425|  2.50k|  VP8LMetadata* const hdr = &dec->hdr;
 1426|  2.50k|  const ptrdiff_t window_limit =
 1427|  2.50k|      GetWindowLimit(dec, height, process_func != NULL);
 1428|  2.50k|  uint32_t* src = data + dec->last_pixel - GetWindowOffset(dec);
 1429|  2.50k|  uint32_t* last_cached = src;
 1430|  2.50k|  uint32_t* src_end = data + GetWindowRowOffset(dec, height);
 1431|  2.50k|  uint32_t* src_last = data + GetWindowRowOffset(dec, last_row);
 1432|  2.50k|  const int len_code_limit = NUM_LITERAL_CODES + NUM_LENGTH_CODES;
  ------------------
  |  |   43|  2.50k|#define NUM_LITERAL_CODES 256
  ------------------
                const int len_code_limit = NUM_LITERAL_CODES + NUM_LENGTH_CODES;
  ------------------
  |  |   44|  2.50k|#define NUM_LENGTH_CODES 24
  ------------------
 1433|  2.50k|  const int color_cache_limit = len_code_limit + hdr->color_cache_size;
 1434|  2.50k|  int next_sync_row = dec->incremental ? row : 1 << 24;
  ------------------
  |  Branch (1434:23): [True: 0, False: 2.50k]
  ------------------
 1435|  2.50k|  VP8LColorCache* const color_cache =
 1436|  2.50k|      (hdr->color_cache_size > 0) ? &hdr->color_cache : NULL;
  ------------------
  |  Branch (1436:7): [True: 406, False: 2.09k]
  ------------------
 1437|  2.50k|  const int mask = hdr->huffman_mask;
 1438|  2.50k|  const HTreeGroup* htree_group =
 1439|  2.50k|      (src < src_last) ? GetHtreeGroupForPos(hdr, col, row) : NULL;
  ------------------
  |  Branch (1439:7): [True: 2.50k, False: 0]
  ------------------
 1440|  2.50k|  assert(dec->last_row < last_row);
 1441|  2.50k|  assert(src_last <= src_end);
 1442|       |
 1443|  19.3M|  while (src < src_last) {
  ------------------
  |  Branch (1443:10): [True: 19.3M, False: 2.11k]
  ------------------
 1444|  19.3M|    int code;
 1445|  19.3M|    if (row >= next_sync_row) {
  ------------------
  |  Branch (1445:9): [True: 0, False: 19.3M]
  ------------------
 1446|      0|      SaveState(dec, GetAbsoluteOffset(dec, src - data));
 1447|      0|      next_sync_row = row + SYNC_EVERY_N_ROWS;
  ------------------
  |  | 1417|      0|#define SYNC_EVERY_N_ROWS 8  // minimum number of rows between check-points
  ------------------
 1448|      0|    }
 1449|       |    // Only update when changing tile. Note we could use this test:
 1450|       |    // if "((((prev_col ^ col) | prev_row ^ row)) > mask)" -> tile changed
 1451|       |    // but that's actually slower and needs storing the previous col/row.
 1452|  19.3M|    if ((col & mask) == 0) {
  ------------------
  |  Branch (1452:9): [True: 1.08M, False: 18.2M]
  ------------------
 1453|  1.08M|      htree_group = GetHtreeGroupForPos(hdr, col, row);
 1454|  1.08M|    }
 1455|  19.3M|    assert(htree_group != NULL);
 1456|  19.3M|    if (htree_group->is_trivial_code) {
  ------------------
  |  Branch (1456:9): [True: 17.3M, False: 1.99M]
  ------------------
 1457|  17.3M|      *src = htree_group->literal_arb;
 1458|  17.3M|      goto AdvanceByOne;
 1459|  17.3M|    }
 1460|  1.99M|    VP8LFillBitWindow(br);
 1461|  1.99M|    if (htree_group->packed_table != NULL) {
  ------------------
  |  Branch (1461:9): [True: 1.03M, False: 955k]
  ------------------
 1462|  1.03M|      code = ReadPackedSymbols(htree_group, br, src);
 1463|  1.03M|      if (VP8LIsEndOfStream(br)) break;
  ------------------
  |  Branch (1463:11): [True: 182, False: 1.03M]
  ------------------
 1464|  1.03M|      if (code == PACKED_NON_LITERAL_CODE) goto AdvanceByOne;
  ------------------
  |  |  197|  1.03M|#define PACKED_NON_LITERAL_CODE 0  // must be < NUM_LITERAL_CODES
  ------------------
  |  Branch (1464:11): [True: 945k, False: 93.5k]
  ------------------
 1465|  1.03M|    } else {
 1466|   955k|      code = ReadSymbol(htree_group->htrees[GREEN], br);
 1467|   955k|    }
 1468|  1.04M|    if (code < NUM_LITERAL_CODES) {  // Literal
  ------------------
  |  |   43|  1.04M|#define NUM_LITERAL_CODES 256
  ------------------
  |  Branch (1468:9): [True: 892k, False: 156k]
  ------------------
 1469|   892k|      if (htree_group->is_trivial_literal) {
  ------------------
  |  Branch (1469:11): [True: 318k, False: 573k]
  ------------------
 1470|   318k|        if (VP8LIsEndOfStream(br)) break;
  ------------------
  |  Branch (1470:13): [True: 19, False: 318k]
  ------------------
 1471|   318k|        *src = htree_group->literal_arb | (code << 8);
 1472|   573k|      } else {
 1473|   573k|        int red, blue, alpha;
 1474|   573k|        red = ReadSymbol(htree_group->htrees[RED], br);
 1475|   573k|        VP8LFillBitWindow(br);
 1476|   573k|        blue = ReadSymbol(htree_group->htrees[BLUE], br);
 1477|   573k|        alpha = ReadSymbol(htree_group->htrees[ALPHA], br);
 1478|   573k|        if (VP8LIsEndOfStream(br)) break;
  ------------------
  |  Branch (1478:13): [True: 62, False: 573k]
  ------------------
 1479|   573k|        *src = ((uint32_t)alpha << 24) | (red << 16) | (code << 8) | blue;
 1480|   573k|      }
 1481|  19.3M|    AdvanceByOne:
 1482|  19.3M|      ++src;
 1483|  19.3M|      ++col;
 1484|  19.3M|      if (col >= width) {
  ------------------
  |  Branch (1484:11): [True: 1.05M, False: 18.2M]
  ------------------
 1485|  1.05M|        col = 0;
 1486|  1.05M|        ++row;
 1487|  1.05M|        if (process_func != NULL) {
  ------------------
  |  Branch (1487:13): [True: 995k, False: 62.8k]
  ------------------
 1488|   995k|          if (row <= last_row) {
  ------------------
  |  Branch (1488:15): [True: 995k, False: 0]
  ------------------
 1489|   995k|            process_func(dec, row, /*wait_for_biggest_batch=*/1);
 1490|   995k|          }
 1491|   995k|        }
 1492|  1.05M|        if (color_cache != NULL) {
  ------------------
  |  Branch (1492:13): [True: 108k, False: 949k]
  ------------------
 1493|  1.58M|          while (last_cached < src) {
  ------------------
  |  Branch (1493:18): [True: 1.47M, False: 108k]
  ------------------
 1494|  1.47M|            VP8LColorCacheInsert(color_cache, *last_cached++);
 1495|  1.47M|          }
 1496|   108k|        }
 1497|  1.05M|        ShiftWindow32b(dec, data, window_limit, &src, &last_cached, &src_end,
 1498|  1.05M|                       &src_last);
 1499|  1.05M|      }
 1500|  19.3M|    } else if (code < len_code_limit) {  // Backward reference
  ------------------
  |  Branch (1500:16): [True: 29.0k, False: 127k]
  ------------------
 1501|  29.0k|      int dist_code, dist;
 1502|  29.0k|      const int length_sym = code - NUM_LITERAL_CODES;
  ------------------
  |  |   43|  29.0k|#define NUM_LITERAL_CODES 256
  ------------------
 1503|  29.0k|      const int length = GetCopyLength(length_sym, br);
 1504|  29.0k|      const int dist_symbol = ReadSymbol(htree_group->htrees[DIST], br);
 1505|  29.0k|      VP8LFillBitWindow(br);
 1506|  29.0k|      dist_code = GetCopyDistance(dist_symbol, br);
 1507|  29.0k|      dist = PlaneCodeToDistance(width, dist_code);
 1508|       |
 1509|  29.0k|      if (VP8LIsEndOfStream(br)) break;
  ------------------
  |  Branch (1509:11): [True: 83, False: 28.9k]
  ------------------
 1510|  28.9k|      if (src - data < (ptrdiff_t)dist || src_end - src < (ptrdiff_t)length) {
  ------------------
  |  Branch (1510:11): [True: 14, False: 28.9k]
  |  Branch (1510:43): [True: 13, False: 28.9k]
  ------------------
 1511|     27|        goto Error;
 1512|  28.9k|      } else {
 1513|  28.9k|        CopyBlock32b(src, dist, length);
 1514|  28.9k|      }
 1515|  28.9k|      src += length;
 1516|  28.9k|      col += length;
 1517|  84.9k|      while (col >= width) {
  ------------------
  |  Branch (1517:14): [True: 56.0k, False: 28.9k]
  ------------------
 1518|  56.0k|        col -= width;
 1519|  56.0k|        ++row;
 1520|  56.0k|        if (process_func != NULL) {
  ------------------
  |  Branch (1520:13): [True: 54.1k, False: 1.91k]
  ------------------
 1521|  54.1k|          if (row <= last_row) {
  ------------------
  |  Branch (1521:15): [True: 54.1k, False: 0]
  ------------------
 1522|  54.1k|            process_func(dec, row, /*wait_for_biggest_batch=*/1);
 1523|  54.1k|          }
 1524|  54.1k|        }
 1525|  56.0k|      }
 1526|       |      // Because of the check done above (before 'src' was incremented by
 1527|       |      // 'length'), the following holds true.
 1528|  28.9k|      assert(src <= src_end);
 1529|  28.9k|      if (col & mask) htree_group = GetHtreeGroupForPos(hdr, col, row);
  ------------------
  |  Branch (1529:11): [True: 20.7k, False: 8.16k]
  ------------------
 1530|  28.9k|      if (color_cache != NULL) {
  ------------------
  |  Branch (1530:11): [True: 7.88k, False: 21.0k]
  ------------------
 1531|   222k|        while (last_cached < src) {
  ------------------
  |  Branch (1531:16): [True: 214k, False: 7.88k]
  ------------------
 1532|   214k|          VP8LColorCacheInsert(color_cache, *last_cached++);
 1533|   214k|        }
 1534|  7.88k|      }
 1535|  28.9k|      ShiftWindow32b(dec, data, window_limit, &src, &last_cached, &src_end,
 1536|  28.9k|                     &src_last);
 1537|   127k|    } else if (code < color_cache_limit) {  // Color cache
  ------------------
  |  Branch (1537:16): [True: 127k, False: 0]
  ------------------
 1538|   127k|      const int key = code - len_code_limit;
 1539|   127k|      assert(color_cache != NULL);
 1540|   127k|      if (VP8LIsEndOfStream(br)) break;
  ------------------
  |  Branch (1540:11): [True: 8, False: 127k]
  ------------------
 1541|   579k|      while (last_cached < src) {
  ------------------
  |  Branch (1541:14): [True: 452k, False: 127k]
  ------------------
 1542|   452k|        VP8LColorCacheInsert(color_cache, *last_cached++);
 1543|   452k|      }
 1544|   127k|      *src = VP8LColorCacheLookup(color_cache, key);
 1545|   127k|      goto AdvanceByOne;
 1546|   127k|    } else {  // Not reached
 1547|      0|      goto Error;
 1548|      0|    }
 1549|  1.04M|  }
 1550|       |
 1551|  2.47k|  br->eos = VP8LIsEndOfStream(br);
 1552|       |  // In incremental decoding:
 1553|       |  // br->eos && src < src_last: if 'br' reached the end of the buffer and
 1554|       |  // 'src_last' has not been reached yet, there is not enough data. 'dec' has to
 1555|       |  // be reset until there is more data.
 1556|       |  // !br->eos && src < src_last: this cannot happen as either the buffer is
 1557|       |  // fully read, either enough has been read to reach 'src_last'.
 1558|       |  // src >= src_last: 'src_last' is reached, all is fine. 'src' can actually go
 1559|       |  // beyond 'src_last' in case the image is cropped and an LZ77 goes further.
 1560|       |  // The buffer might have been enough or there is some left. 'br->eos' does
 1561|       |  // not matter.
 1562|  2.47k|  assert(!dec->incremental || (br->eos && src < src_last) || src >= src_last);
 1563|  2.47k|  if (dec->incremental && br->eos && src < src_last) {
  ------------------
  |  Branch (1563:7): [True: 0, False: 2.47k]
  |  Branch (1563:27): [True: 0, False: 0]
  |  Branch (1563:38): [True: 0, False: 0]
  ------------------
 1564|      0|    RestoreState(dec);
 1565|  2.47k|  } else if ((dec->incremental && src >= src_last) || !br->eos) {
  ------------------
  |  Branch (1565:15): [True: 0, False: 2.47k]
  |  Branch (1565:35): [True: 0, False: 0]
  |  Branch (1565:55): [True: 2.11k, False: 354]
  ------------------
 1566|       |    // Process the remaining rows corresponding to last row-block.
 1567|  2.11k|    if (process_func != NULL) {
  ------------------
  |  Branch (1567:9): [True: 913, False: 1.20k]
  ------------------
 1568|    913|      process_func(dec, row > last_row ? last_row : row,
  ------------------
  |  Branch (1568:25): [True: 0, False: 913]
  ------------------
 1569|    913|                   /*wait_for_biggest_batch=*/0);
 1570|    913|    }
 1571|  2.11k|    dec->status = VP8_STATUS_OK;
 1572|  2.11k|    dec->last_pixel = GetAbsoluteOffset(dec, src - data);
 1573|  2.11k|  } else {
 1574|       |    // if not incremental, and we are past the end of buffer (eos=1), then this
 1575|       |    // is a real bitstream error.
 1576|    354|    goto Error;
 1577|    354|  }
 1578|  2.11k|  return 1;
 1579|       |
 1580|    381|Error:
 1581|    381|  return VP8LSetError(dec, VP8_STATUS_BITSTREAM_ERROR);
 1582|  2.47k|}
vp8l_dec.c:ReadPackedSymbols:
  200|  1.03M|                                         uint32_t* const dst) {
  201|  1.03M|  const uint32_t val = VP8LPrefetchBits(br) & (HUFFMAN_PACKED_TABLE_SIZE - 1);
  ------------------
  |  |   79|  1.03M|#define HUFFMAN_PACKED_TABLE_SIZE (1u << HUFFMAN_PACKED_BITS)
  |  |  ------------------
  |  |  |  |   78|  1.03M|#define HUFFMAN_PACKED_BITS 6
  |  |  ------------------
  ------------------
  202|  1.03M|  HuffmanCode32 code;
  203|  1.03M|  assert(group->packed_table != NULL);
  204|  1.03M|  code = group->packed_table[val];
  205|  1.03M|  if (code.bits < BITS_SPECIAL_MARKER) {
  ------------------
  |  |  196|  1.03M|#define BITS_SPECIAL_MARKER 0x100  // something large enough (and a bit-mask)
  ------------------
  |  Branch (205:7): [True: 945k, False: 93.5k]
  ------------------
  206|   945k|    VP8LSetBitPos(br, br->bit_pos + code.bits);
  207|   945k|    *dst = code.value;
  208|   945k|    return PACKED_NON_LITERAL_CODE;
  ------------------
  |  |  197|   945k|#define PACKED_NON_LITERAL_CODE 0  // must be < NUM_LITERAL_CODES
  ------------------
  209|   945k|  } else {
  210|  93.5k|    VP8LSetBitPos(br, br->bit_pos + code.bits - BITS_SPECIAL_MARKER);
  ------------------
  |  |  196|  93.5k|#define BITS_SPECIAL_MARKER 0x100  // something large enough (and a bit-mask)
  ------------------
  211|       |    assert(code.value >= NUM_LITERAL_CODES);
  212|  93.5k|    return code.value;
  213|  93.5k|  }
  214|  1.03M|}
vp8l_dec.c:ShiftWindow32b:
 1295|  1.08M|                           uint32_t** const src_last) {
 1296|  1.08M|  const ptrdiff_t shift_pixels =
 1297|  1.08M|      ShiftWindow(dec, data, *src - data, window_limit, sizeof(*data));
 1298|  1.08M|  if (shift_pixels > 0) {
  ------------------
  |  Branch (1298:7): [True: 0, False: 1.08M]
  ------------------
 1299|      0|    *src -= shift_pixels;
 1300|      0|    *last_cached -= shift_pixels;
 1301|      0|    *src_end -= shift_pixels;
 1302|      0|    *src_last -= shift_pixels;
 1303|      0|  }
 1304|  1.08M|}
vp8l_dec.c:CopyBlock32b:
 1172|  28.9k|                                     int length) {
 1173|  28.9k|  const uint32_t* const src = dst - dist;
 1174|  28.9k|  if (dist <= 2 && length >= 4 && WEBP_IS_ALIGNED(dst, uint32_t)) {
  ------------------
  |  |   80|  18.5k|  ((sizeof(TYPE) & (sizeof(TYPE) - 1)) == 0 && \
  |  |  ------------------
  |  |  |  Branch (80:4): [True: 18.5k, Folded]
  |  |  ------------------
  |  |   81|  18.5k|   ((uintptr_t)(PTR) & (sizeof(TYPE) - 1)) == 0)
  |  |  ------------------
  |  |  |  Branch (81:4): [True: 18.5k, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (1174:7): [True: 23.9k, False: 4.95k]
  |  Branch (1174:20): [True: 18.5k, False: 5.47k]
  ------------------
 1175|  18.5k|    uint64_t pattern;
 1176|  18.5k|    if (dist == 1) {
  ------------------
  |  Branch (1176:9): [True: 18.1k, False: 390]
  ------------------
 1177|  18.1k|      pattern = (uint64_t)src[0];
 1178|  18.1k|      pattern |= pattern << 32;
 1179|  18.1k|    } else {
 1180|    390|      WEBP_UNSAFE_MEMCPY(&pattern, src, sizeof(pattern));
  ------------------
  |  |  174|    390|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
 1181|    390|    }
 1182|  18.5k|    CopySmallPattern32b(src, dst, length, pattern);
 1183|  18.5k|  } else if (dist >= length) {  // no overlap
  ------------------
  |  Branch (1183:14): [True: 3.94k, False: 6.48k]
  ------------------
 1184|  3.94k|    WEBP_UNSAFE_MEMCPY(dst, src, length * sizeof(*dst));
  ------------------
  |  |  174|  3.94k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
 1185|  6.48k|  } else {
 1186|  6.48k|    int i;
 1187|  87.3k|    for (i = 0; i < length; ++i) dst[i] = src[i];
  ------------------
  |  Branch (1187:17): [True: 80.8k, False: 6.48k]
  ------------------
 1188|  6.48k|  }
 1189|  28.9k|}
vp8l_dec.c:CopySmallPattern32b:
 1155|  18.5k|                                            int length, uint64_t pattern) {
 1156|  18.5k|  int i;
 1157|  18.5k|  if (!WEBP_IS_ALIGNED(dst, uint64_t)) {  // Align 'dst' to 8-bytes boundary.
  ------------------
  |  |   80|  18.5k|  ((sizeof(TYPE) & (sizeof(TYPE) - 1)) == 0 && \
  |  |  ------------------
  |  |  |  Branch (80:4): [True: 18.5k, Folded]
  |  |  ------------------
  |  |   81|  18.5k|   ((uintptr_t)(PTR) & (sizeof(TYPE) - 1)) == 0)
  |  |  ------------------
  |  |  |  Branch (81:4): [True: 8.66k, False: 9.85k]
  |  |  ------------------
  ------------------
 1158|  9.85k|    *dst++ = *src++;
 1159|  9.85k|    pattern = (pattern >> 32) | (pattern << 32);
 1160|  9.85k|    --length;
 1161|  9.85k|  }
 1162|  18.5k|  assert(WEBP_IS_ALIGNED(dst, uint64_t));
 1163|   192k|  for (i = 0; i < (length >> 1); ++i) {
  ------------------
  |  Branch (1163:15): [True: 173k, False: 18.5k]
  ------------------
 1164|   173k|    ((uint64_t*)dst)[i] = pattern;  // Copy the pattern 8 bytes at a time.
 1165|   173k|  }
 1166|  18.5k|  if (length & 1) {  // Finish with left-over.
  ------------------
  |  Branch (1166:7): [True: 9.79k, False: 8.72k]
  ------------------
 1167|  9.79k|    dst[i << 1] = src[i << 1];
 1168|  9.79k|  }
 1169|  18.5k|}
vp8l_dec.c:ApplyInverseTransforms:
  906|  66.1k|                                   int num_rows, const uint32_t* const rows) {
  907|  66.1k|  int n = dec->next_transform;
  908|  66.1k|  const int cache_pixs = dec->width * num_rows;
  909|  66.1k|  const int end_row = start_row + num_rows;
  910|  66.1k|  const uint32_t* rows_in = rows;
  911|  66.1k|  uint32_t* const rows_out = dec->argb_cache;
  912|       |
  913|       |  // Inverse transforms.
  914|   125k|  while (n-- > 0) {
  ------------------
  |  Branch (914:10): [True: 59.8k, False: 66.1k]
  ------------------
  915|  59.8k|    VP8LTransform* const transform = &dec->transforms[n];
  916|  59.8k|    VP8LInverseTransform(transform, start_row, end_row, rows_in, rows_out);
  917|  59.8k|    rows_in = rows_out;
  918|  59.8k|  }
  919|  66.1k|  if (rows_in != rows_out) {
  ------------------
  |  Branch (919:7): [True: 16.7k, False: 49.3k]
  ------------------
  920|       |    // No transform called, hence just copy.
  921|  16.7k|    WEBP_UNSAFE_MEMCPY(rows_out, rows_in, cache_pixs * sizeof(*rows_out));
  ------------------
  |  |  174|  16.7k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
  922|  16.7k|  }
  923|  66.1k|}
vp8l_dec.c:ProcessRows:
  948|  1.05M|                        int wait_for_biggest_batch) {
  949|  1.05M|  const uint32_t* const rows =
  950|  1.05M|      dec->pixels + GetWindowRowOffset(dec, dec->last_row);
  951|  1.05M|  int num_rows;
  952|       |
  953|       |  // In case of YUV conversion and if we do not need to get to the last row.
  954|  1.05M|  if (wait_for_biggest_batch) {
  ------------------
  |  Branch (954:7): [True: 1.04M, False: 913]
  ------------------
  955|       |    // In case of YUV conversion, and if we do not use the whole cropping
  956|       |    // region.
  957|  1.04M|    if (!WebPIsRGBMode(dec->output->colorspace) && row >= dec->io->crop_top &&
  ------------------
  |  Branch (957:9): [True: 292k, False: 756k]
  |  Branch (957:52): [True: 292k, False: 0]
  ------------------
  958|   292k|        row < dec->io->crop_bottom) {
  ------------------
  |  Branch (958:9): [True: 292k, False: 214]
  ------------------
  959|       |      // Make sure the number of rows to process is even.
  960|   292k|      if ((row - dec->io->crop_top) % 2 != 0) return;
  ------------------
  |  Branch (960:11): [True: 146k, False: 146k]
  ------------------
  961|       |      // Make sure the cache is as full as possible.
  962|   146k|      if (row % NUM_ARGB_CACHE_ROWS != 0 &&
  ------------------
  |  |   36|   146k|#define NUM_ARGB_CACHE_ROWS 16
  ------------------
  |  Branch (962:11): [True: 128k, False: 18.2k]
  ------------------
  963|   128k|          (row + 1) % NUM_ARGB_CACHE_ROWS != 0) {
  ------------------
  |  |   36|   128k|#define NUM_ARGB_CACHE_ROWS 16
  ------------------
  |  Branch (963:11): [True: 128k, False: 0]
  ------------------
  964|   128k|        return;
  965|   128k|      }
  966|   756k|    } else {
  967|   756k|      if (row % NUM_ARGB_CACHE_ROWS != 0) return;
  ------------------
  |  |   36|   756k|#define NUM_ARGB_CACHE_ROWS 16
  ------------------
  |  Branch (967:11): [True: 709k, False: 46.9k]
  ------------------
  968|   756k|    }
  969|  1.04M|  }
  970|  66.1k|  num_rows = row - dec->last_row;
  971|  66.1k|  assert(row <= dec->io->crop_bottom);
  972|       |  // We can't process more than NUM_ARGB_CACHE_ROWS at a time (that's the size
  973|       |  // of argb_cache), but we currently don't need more than that.
  974|  66.1k|  assert(num_rows <= NUM_ARGB_CACHE_ROWS);
  975|  66.1k|  if (num_rows > 0) {  // Emit output.
  ------------------
  |  Branch (975:7): [True: 66.1k, False: 19]
  ------------------
  976|  66.1k|    VP8Io* const io = dec->io;
  977|  66.1k|    uint8_t* rows_data = (uint8_t*)dec->argb_cache;
  978|  66.1k|    const int in_stride = io->width * sizeof(uint32_t);  // in unit of RGBA
  979|  66.1k|    ApplyInverseTransforms(dec, dec->last_row, num_rows, rows);
  980|  66.1k|    if (!SetCropWindow(io, dec->last_row, row, &rows_data, in_stride)) {
  ------------------
  |  Branch (980:9): [True: 0, False: 66.1k]
  ------------------
  981|       |      // Nothing to output (this time).
  982|  66.1k|    } else {
  983|  66.1k|      const WebPDecBuffer* const output = dec->output;
  984|  66.1k|      if (WebPIsRGBMode(output->colorspace)) {  // convert to RGBA
  ------------------
  |  Branch (984:11): [True: 47.6k, False: 18.4k]
  ------------------
  985|  47.6k|        const WebPRGBABuffer* const buf = &output->u.RGBA;
  986|  47.6k|        uint8_t* const rgba =
  987|  47.6k|            buf->rgba + (ptrdiff_t)dec->last_out_row * buf->stride;
  988|  47.6k|        const int num_rows_out =
  989|  47.6k|#if !defined(WEBP_REDUCE_SIZE)
  990|  47.6k|            io->use_scaling ? EmitRescaledRowsRGBA(dec, rows_data, in_stride,
  ------------------
  |  Branch (990:13): [True: 0, False: 47.6k]
  ------------------
  991|      0|                                                   io->mb_h, rgba, buf->stride)
  992|  47.6k|                            :
  993|  47.6k|#endif  // WEBP_REDUCE_SIZE
  994|  47.6k|                            EmitRows(output->colorspace, rows_data, in_stride,
  995|  47.6k|                                     io->mb_w, io->mb_h, rgba, buf->stride);
  996|       |        // Update 'last_out_row'.
  997|  47.6k|        dec->last_out_row += num_rows_out;
  998|  47.6k|      } else {  // convert to YUVA
  999|  18.4k|        dec->last_out_row =
 1000|  18.4k|            io->use_scaling
  ------------------
  |  Branch (1000:13): [True: 0, False: 18.4k]
  ------------------
 1001|  18.4k|                ? EmitRescaledRowsYUVA(dec, rows_data, in_stride, io->mb_h)
 1002|  18.4k|                : EmitRowsYUVA(rows_data, io, in_stride,
 1003|  18.4k|                               dec->accumulated_rgb_pixels, dec);
 1004|  18.4k|      }
 1005|  66.1k|      assert(dec->last_out_row <= output->height);
 1006|  66.1k|    }
 1007|  66.1k|  }
 1008|       |
 1009|       |  // Update 'last_row'.
 1010|  66.1k|  dec->last_row = row;
 1011|       |  assert(dec->last_row <= dec->height);
 1012|  66.1k|}
vp8l_dec.c:SetCropWindow:
  860|  66.1k|                                        int pixel_stride) {
  861|  66.1k|  assert(y_start < y_end);
  862|  66.1k|  assert(io->crop_left < io->crop_right);
  863|  66.1k|  if (y_end > io->crop_bottom) {
  ------------------
  |  Branch (863:7): [True: 0, False: 66.1k]
  ------------------
  864|      0|    y_end = io->crop_bottom;  // make sure we don't overflow on last row.
  865|      0|  }
  866|  66.1k|  if (y_start < io->crop_top) {
  ------------------
  |  Branch (866:7): [True: 0, False: 66.1k]
  ------------------
  867|      0|    const int delta = io->crop_top - y_start;
  868|      0|    y_start = io->crop_top;
  869|      0|    *in_data += (ptrdiff_t)delta * pixel_stride;
  870|      0|  }
  871|  66.1k|  if (y_start >= y_end) return 0;  // Crop window is empty.
  ------------------
  |  Branch (871:7): [True: 0, False: 66.1k]
  ------------------
  872|       |
  873|  66.1k|  *in_data += (ptrdiff_t)io->crop_left * sizeof(uint32_t);
  874|       |
  875|  66.1k|  io->mb_y = y_start - io->crop_top;
  876|  66.1k|  io->mb_w = io->crop_right - io->crop_left;
  877|  66.1k|  io->mb_h = y_end - y_start;
  878|  66.1k|  return 1;  // Non-empty crop window.
  879|  66.1k|}
vp8l_dec.c:EmitRows:
  701|  47.6k|                    int out_stride) {
  702|  47.6k|  int lines = mb_h;
  703|  47.6k|  uint8_t* row_out = out;
  704|   803k|  while (lines-- > 0) {
  ------------------
  |  Branch (704:10): [True: 755k, False: 47.6k]
  ------------------
  705|       |    assert(WEBP_IS_ALIGNED(row_in, uint32_t));
  706|   755k|    VP8LConvertFromBGRA((const uint32_t*)row_in, mb_w, colorspace, row_out);
  707|   755k|    row_in += in_stride;
  708|   755k|    row_out += out_stride;
  709|   755k|  }
  710|  47.6k|  return mb_h;  // Num rows out == num rows in.
  711|  47.6k|}
vp8l_dec.c:EmitRowsYUVA:
  790|  18.4k|                        VP8LDecoder* const dec) {
  791|  18.4k|  int y_pos = dec->last_out_row;
  792|  18.4k|  const int width = io->mb_w;
  793|  18.4k|  int num_rows = io->mb_h;
  794|  18.4k|  const int y_pos_final = y_pos + num_rows;
  795|  18.4k|  const int y_stride = dec->output->u.YUVA.y_stride;
  796|  18.4k|  const int u_stride = dec->output->u.YUVA.u_stride;
  797|  18.4k|  const int v_stride = dec->output->u.YUVA.v_stride;
  798|  18.4k|  const int a_stride = dec->output->u.YUVA.a_stride;
  799|  18.4k|  uint8_t* dst_a =
  800|  18.4k|      WebPIsAlphaMode(dec->output->colorspace) ? dec->output->u.YUVA.a : NULL;
  ------------------
  |  Branch (800:7): [True: 0, False: 18.4k]
  ------------------
  801|  18.4k|  uint8_t* dst_y = dec->output->u.YUVA.y + (ptrdiff_t)y_pos * y_stride;
  802|  18.4k|  uint8_t* dst_u = dec->output->u.YUVA.u + (ptrdiff_t)(y_pos >> 1) * u_stride;
  803|  18.4k|  uint8_t* dst_v = dec->output->u.YUVA.v + (ptrdiff_t)(y_pos >> 1) * v_stride;
  804|  18.4k|  const uint8_t* r_ptr = in + CHANNEL_OFFSET(1);
  ------------------
  |  |   51|  18.4k|#define CHANNEL_OFFSET(i) (3 - (i))
  ------------------
  805|  18.4k|  const uint8_t* g_ptr = in + CHANNEL_OFFSET(2);
  ------------------
  |  |   51|  18.4k|#define CHANNEL_OFFSET(i) (3 - (i))
  ------------------
  806|  18.4k|  const uint8_t* b_ptr = in + CHANNEL_OFFSET(3);
  ------------------
  |  |   51|  18.4k|#define CHANNEL_OFFSET(i) (3 - (i))
  ------------------
  807|  18.4k|  const uint8_t* a_ptr = NULL;
  808|  18.4k|  int has_alpha = 0;
  809|       |
  810|       |  // Make sure the lines are processed two by two from the start.
  811|  18.4k|  assert(y_pos % 2 == 0);
  812|       |
  813|       |  // Make sure num_rows is even. y_pos_final will check if it not.
  814|  18.4k|  num_rows &= ~1;
  815|       |
  816|  18.4k|  if (dst_a) {
  ------------------
  |  Branch (816:7): [True: 0, False: 18.4k]
  ------------------
  817|      0|    dst_a += (ptrdiff_t)y_pos * a_stride;
  818|      0|    a_ptr = in + CHANNEL_OFFSET(0);
  ------------------
  |  |   51|      0|#define CHANNEL_OFFSET(i) (3 - (i))
  ------------------
  819|      0|    has_alpha = CheckNonOpaque(a_ptr, width, num_rows, in_stride);
  820|      0|  }
  821|       |  // Process pairs of lines.
  822|  18.4k|  WebPImportYUVAFromRGBA(r_ptr, g_ptr, b_ptr, a_ptr, /*step=*/4, in_stride,
  823|  18.4k|                         has_alpha, width, num_rows, tmp_rgb, y_stride,
  824|  18.4k|                         u_stride, v_stride, a_stride, dst_y, dst_u, dst_v,
  825|  18.4k|                         dst_a);
  826|       |
  827|  18.4k|  y_pos += num_rows;
  828|  18.4k|  if (y_pos_final == io->crop_bottom - io->crop_top && y_pos < y_pos_final) {
  ------------------
  |  Branch (828:7): [True: 214, False: 18.2k]
  |  Branch (828:56): [True: 106, False: 108]
  ------------------
  829|    106|    assert(y_pos + 1 == y_pos_final);
  830|       |    // If we output the last line of an image with odd height.
  831|    106|    dst_y += (ptrdiff_t)num_rows * y_stride;
  832|    106|    dst_u += (ptrdiff_t)(num_rows >> 1) * u_stride;
  833|    106|    dst_v += (ptrdiff_t)(num_rows >> 1) * v_stride;
  834|    106|    r_ptr += (ptrdiff_t)num_rows * in_stride;
  835|    106|    g_ptr += (ptrdiff_t)num_rows * in_stride;
  836|    106|    b_ptr += (ptrdiff_t)num_rows * in_stride;
  837|    106|    if (dst_a) {
  ------------------
  |  Branch (837:9): [True: 0, False: 106]
  ------------------
  838|      0|      dst_a += (ptrdiff_t)num_rows * a_stride;
  839|      0|      a_ptr += (ptrdiff_t)num_rows * in_stride;
  840|      0|      has_alpha = CheckNonOpaque(a_ptr, width, /*height=*/1, in_stride);
  841|      0|    }
  842|    106|    WebPImportYUVAFromRGBALastLine(r_ptr, g_ptr, b_ptr, a_ptr, /*step=*/4,
  843|    106|                                   has_alpha, width, tmp_rgb, dst_y, dst_u,
  844|    106|                                   dst_v, dst_a);
  845|    106|    y_pos = y_pos_final;
  846|    106|  }
  847|  18.4k|  return y_pos;
  848|  18.4k|}

WebPParseHeaders:
  436|  4.77k|VP8StatusCode WebPParseHeaders(WebPHeaderStructure* const headers) {
  437|       |  // status is marked volatile as a workaround for a clang-3.8 (aarch64) bug
  438|  4.77k|  volatile VP8StatusCode status;
  439|  4.77k|  int has_animation = 0;
  440|  4.77k|  assert(headers != NULL);
  441|       |  // fill out headers, ignore width/height/has_alpha.
  442|  4.77k|  {
  443|  4.77k|    const uint8_t* WEBP_BIDI_INDEXABLE const bounded_data =
  444|  4.77k|        WEBP_UNSAFE_FORGE_BIDI_INDEXABLE(const uint8_t*, headers->data,
  ------------------
  |  |  180|  4.77k|#define WEBP_UNSAFE_FORGE_BIDI_INDEXABLE(typ, ptr, size) ((typ)(ptr))
  ------------------
  445|  4.77k|                                         headers->data_size);
  446|  4.77k|    status = ParseHeadersInternal(bounded_data, headers->data_size, NULL, NULL,
  447|  4.77k|                                  NULL, &has_animation, NULL, headers);
  448|  4.77k|  }
  449|  4.77k|  if (status == VP8_STATUS_OK || status == VP8_STATUS_NOT_ENOUGH_DATA) {
  ------------------
  |  Branch (449:7): [True: 4.73k, False: 31]
  |  Branch (449:34): [True: 31, False: 0]
  ------------------
  450|       |    // The WebPDemux API + libwebp can be used to decode individual
  451|       |    // uncomposited frames or the WebPAnimDecoder can be used to fully
  452|       |    // reconstruct them (see webp/demux.h).
  453|  4.77k|    if (has_animation) {
  ------------------
  |  Branch (453:9): [True: 0, False: 4.77k]
  ------------------
  454|      0|      status = VP8_STATUS_UNSUPPORTED_FEATURE;
  455|      0|    }
  456|  4.77k|  }
  457|  4.77k|  return status;
  458|  4.77k|}
WebPResetDecParams:
  463|  4.77k|void WebPResetDecParams(WebPDecParams* const params) {
  464|  4.77k|  if (params != NULL) {
  ------------------
  |  Branch (464:7): [True: 4.77k, False: 0]
  ------------------
  465|  4.77k|    WEBP_UNSAFE_MEMSET(params, 0, sizeof(*params));
  ------------------
  |  |  175|  4.77k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  466|  4.77k|  }
  467|  4.77k|}
WebPDecodeRGBInto:
  581|    386|                           int stride) {
  582|    386|  return DecodeIntoRGBABuffer(MODE_RGB, data, data_size, output, stride, size);
  583|    386|}
WebPDecodeRGBAInto:
  588|    416|                            int stride) {
  589|    416|  return DecodeIntoRGBABuffer(MODE_RGBA, data, data_size, output, stride, size);
  590|    416|}
WebPDecodeARGBInto:
  595|    388|                            int stride) {
  596|    388|  return DecodeIntoRGBABuffer(MODE_ARGB, data, data_size, output, stride, size);
  597|    388|}
WebPDecodeBGRInto:
  602|    470|                           int stride) {
  603|    470|  return DecodeIntoRGBABuffer(MODE_BGR, data, data_size, output, stride, size);
  604|    470|}
WebPDecodeBGRAInto:
  609|    102|                            int stride) {
  610|    102|  return DecodeIntoRGBABuffer(MODE_BGRA, data, data_size, output, stride, size);
  611|    102|}
WebPDecodeYUVInto:
  619|    415|                           size_t v_size, int v_stride) {
  620|    415|  WebPDecParams params;
  621|    415|  WebPDecBuffer output;
  622|    415|  if (luma == NULL || !WebPInitDecBuffer(&output)) return NULL;
  ------------------
  |  Branch (622:7): [True: 0, False: 415]
  |  Branch (622:23): [True: 0, False: 415]
  ------------------
  623|    415|  WebPResetDecParams(&params);
  624|    415|  params.output = &output;
  625|    415|  output.colorspace = MODE_YUV;
  626|    415|  output.u.YUVA.y = luma;
  627|    415|  output.u.YUVA.y_stride = luma_stride;
  628|    415|  output.u.YUVA.y_size = luma_size;
  629|    415|  output.u.YUVA.u = u;
  630|    415|  output.u.YUVA.u_stride = u_stride;
  631|    415|  output.u.YUVA.u_size = u_size;
  632|    415|  output.u.YUVA.v = v;
  633|    415|  output.u.YUVA.v_stride = v_stride;
  634|    415|  output.u.YUVA.v_size = v_size;
  635|    415|  output.is_external_memory = 1;
  636|    415|  if (DecodeInto(data, data_size, &params) != VP8_STATUS_OK) {
  ------------------
  |  Branch (636:7): [True: 291, False: 124]
  ------------------
  637|    291|    return NULL;
  638|    291|  }
  639|    124|  return luma;
  640|    415|}
WebPDecodeRGB:
  679|    422|                       size_t data_size, int* width, int* height) {
  680|       |  return Decode(MODE_RGB, data, data_size, width, height, NULL);
  681|    422|}
WebPDecodeRGBA:
  684|    435|                        size_t data_size, int* width, int* height) {
  685|       |  return Decode(MODE_RGBA, data, data_size, width, height, NULL);
  686|    435|}
WebPDecodeARGB:
  689|    442|                        size_t data_size, int* width, int* height) {
  690|       |  return Decode(MODE_ARGB, data, data_size, width, height, NULL);
  691|    442|}
WebPDecodeBGR:
  694|    432|                       size_t data_size, int* width, int* height) {
  695|       |  return Decode(MODE_BGR, data, data_size, width, height, NULL);
  696|    432|}
WebPDecodeBGRA:
  699|    480|                        size_t data_size, int* width, int* height) {
  700|       |  return Decode(MODE_BGRA, data, data_size, width, height, NULL);
  701|    480|}
WebPDecodeYUV:
  705|    382|                       uint8_t** v, int* stride, int* uv_stride) {
  706|       |  // data, width and height are checked by Decode().
  707|    382|  if (u == NULL || v == NULL || stride == NULL || uv_stride == NULL) {
  ------------------
  |  Branch (707:7): [True: 0, False: 382]
  |  Branch (707:20): [True: 0, False: 382]
  |  Branch (707:33): [True: 0, False: 382]
  |  Branch (707:51): [True: 0, False: 382]
  ------------------
  708|      0|    return NULL;
  709|      0|  }
  710|       |
  711|    382|  {
  712|    382|    WebPDecBuffer output;  // only to preserve the side-infos
  713|    382|    uint8_t* const out =
  714|    382|        Decode(MODE_YUV, data, data_size, width, height, &output);
  715|       |
  716|    382|    if (out != NULL) {
  ------------------
  |  Branch (716:9): [True: 108, False: 274]
  ------------------
  717|    108|      const WebPYUVABuffer* const buf = &output.u.YUVA;
  718|    108|      *u = buf->u;
  719|    108|      *v = buf->v;
  720|    108|      *stride = buf->y_stride;
  721|    108|      *uv_stride = buf->u_stride;
  722|       |      assert(buf->u_stride == buf->v_stride);
  723|    108|    }
  724|    382|    return out;
  725|    382|  }
  726|    382|}
WebPGetInfo:
  752|  7.65k|                size_t data_size, int* width, int* height) {
  753|  7.65k|  WebPBitstreamFeatures features;
  754|       |
  755|  7.65k|  if (GetFeatures(data, data_size, &features) != VP8_STATUS_OK) {
  ------------------
  |  Branch (755:7): [True: 264, False: 7.38k]
  ------------------
  756|    264|    return 0;
  757|    264|  }
  758|       |
  759|  7.38k|  if (width != NULL) {
  ------------------
  |  Branch (759:7): [True: 7.38k, False: 0]
  ------------------
  760|  7.38k|    *width = features.width;
  761|  7.38k|  }
  762|  7.38k|  if (height != NULL) {
  ------------------
  |  Branch (762:7): [True: 7.38k, False: 0]
  ------------------
  763|  7.38k|    *height = features.height;
  764|  7.38k|  }
  765|       |
  766|  7.38k|  return 1;
  767|  7.65k|}
WebPIoInitFromOptions:
  914|  3.71k|                          VP8Io* const io, WEBP_CSP_MODE src_colorspace) {
  915|  3.71k|  const int W = io->width;
  916|  3.71k|  const int H = io->height;
  917|  3.71k|  int x = 0, y = 0, w = W, h = H;
  918|       |
  919|       |  // Cropping
  920|  3.71k|  io->use_cropping = (options != NULL) && options->use_cropping;
  ------------------
  |  Branch (920:22): [True: 0, False: 3.71k]
  |  Branch (920:43): [True: 0, False: 0]
  ------------------
  921|  3.71k|  if (io->use_cropping) {
  ------------------
  |  Branch (921:7): [True: 0, False: 3.71k]
  ------------------
  922|      0|    w = options->crop_width;
  923|      0|    h = options->crop_height;
  924|      0|    x = options->crop_left;
  925|      0|    y = options->crop_top;
  926|      0|    if (!WebPIsRGBMode(src_colorspace)) {  // only snap for YUV420
  ------------------
  |  Branch (926:9): [True: 0, False: 0]
  ------------------
  927|      0|      x &= ~1;
  928|      0|      y &= ~1;
  929|      0|    }
  930|      0|    if (!WebPCheckCropDimensions(W, H, x, y, w, h)) {
  ------------------
  |  Branch (930:9): [True: 0, False: 0]
  ------------------
  931|      0|      return 0;  // out of frame boundary error
  932|      0|    }
  933|      0|  }
  934|  3.71k|  io->crop_left = x;
  935|  3.71k|  io->crop_top = y;
  936|  3.71k|  io->crop_right = x + w;
  937|  3.71k|  io->crop_bottom = y + h;
  938|  3.71k|  io->mb_w = w;
  939|  3.71k|  io->mb_h = h;
  940|       |
  941|       |  // Scaling
  942|  3.71k|  io->use_scaling = (options != NULL) && options->use_scaling;
  ------------------
  |  Branch (942:21): [True: 0, False: 3.71k]
  |  Branch (942:42): [True: 0, False: 0]
  ------------------
  943|  3.71k|  if (io->use_scaling) {
  ------------------
  |  Branch (943:7): [True: 0, False: 3.71k]
  ------------------
  944|      0|    int scaled_width = options->scaled_width;
  945|      0|    int scaled_height = options->scaled_height;
  946|      0|    if (!WebPRescalerGetScaledDimensions(w, h, &scaled_width, &scaled_height)) {
  ------------------
  |  Branch (946:9): [True: 0, False: 0]
  ------------------
  947|      0|      return 0;
  948|      0|    }
  949|      0|    io->scaled_width = scaled_width;
  950|      0|    io->scaled_height = scaled_height;
  951|      0|  }
  952|       |
  953|       |  // Filter
  954|  3.71k|  io->bypass_filtering = (options != NULL) && options->bypass_filtering;
  ------------------
  |  Branch (954:26): [True: 0, False: 3.71k]
  |  Branch (954:47): [True: 0, False: 0]
  ------------------
  955|       |
  956|       |  // Fancy upsampler
  957|  3.71k|#ifdef FANCY_UPSAMPLING
  958|  3.71k|  io->fancy_upsampling = (options == NULL) || (!options->no_fancy_upsampling);
  ------------------
  |  Branch (958:26): [True: 3.71k, False: 0]
  |  Branch (958:47): [True: 0, False: 0]
  ------------------
  959|  3.71k|#endif
  960|       |
  961|  3.71k|  if (io->use_scaling) {
  ------------------
  |  Branch (961:7): [True: 0, False: 3.71k]
  ------------------
  962|       |    // disable filter (only for large downscaling ratio).
  963|      0|    io->bypass_filtering |=
  964|      0|        (io->scaled_width < W * 3 / 4) && (io->scaled_height < H * 3 / 4);
  ------------------
  |  Branch (964:9): [True: 0, False: 0]
  |  Branch (964:43): [True: 0, False: 0]
  ------------------
  965|      0|    io->fancy_upsampling = 0;
  966|      0|  }
  967|  3.71k|  return 1;
  968|  3.71k|}
webp_dec.c:ParseHeadersInternal:
  299|  12.4k|    WebPHeaderStructure* const headers) {
  300|  12.4k|  size_t data_size = data_size_param;
  301|  12.4k|  const uint8_t* WEBP_COUNTED_BY(data_size) data = data_param;
  302|  12.4k|  int canvas_width = 0;
  303|  12.4k|  int canvas_height = 0;
  304|  12.4k|  int image_width = 0;
  305|  12.4k|  int image_height = 0;
  306|  12.4k|  int found_riff = 0;
  307|  12.4k|  int found_vp8x = 0;
  308|  12.4k|  int animation_present = 0;
  309|  12.4k|  const int have_all_data = (headers != NULL) ? headers->have_all_data : 0;
  ------------------
  |  Branch (309:29): [True: 4.77k, False: 7.64k]
  ------------------
  310|       |
  311|  12.4k|  VP8StatusCode status;
  312|  12.4k|  WebPHeaderStructure hdrs;
  313|       |
  314|  12.4k|  if (data == NULL || data_size < RIFF_HEADER_SIZE) {
  ------------------
  |  |   83|  12.4k|#define RIFF_HEADER_SIZE 12  // Size of the RIFF header ("RIFFnnnnWEBP").
  ------------------
  |  Branch (314:7): [True: 0, False: 12.4k]
  |  Branch (314:23): [True: 20, False: 12.3k]
  ------------------
  315|     20|    return VP8_STATUS_NOT_ENOUGH_DATA;
  316|     20|  }
  317|  12.3k|  WEBP_UNSAFE_MEMSET(&hdrs, 0, sizeof(hdrs));
  ------------------
  |  |  175|  12.3k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  318|  12.3k|  hdrs.data = data;
  319|  12.3k|  hdrs.data_size = data_size;
  320|       |
  321|       |  // Skip over RIFF header.
  322|  12.3k|  status = ParseRIFF(&data, &data_size, have_all_data, &hdrs.riff_size);
  323|  12.3k|  if (status != VP8_STATUS_OK) {
  ------------------
  |  Branch (323:7): [True: 2, False: 12.3k]
  ------------------
  324|      2|    return status;  // Wrong RIFF header / insufficient data.
  325|      2|  }
  326|  12.3k|  found_riff = (hdrs.riff_size > 0);
  327|       |
  328|       |  // Skip over VP8X.
  329|  12.3k|  {
  330|  12.3k|    uint32_t flags = 0;
  331|  12.3k|    status = ParseVP8X(&data, &data_size, &found_vp8x, &canvas_width,
  332|  12.3k|                       &canvas_height, &flags);
  333|  12.3k|    if (status != VP8_STATUS_OK) {
  ------------------
  |  Branch (333:9): [True: 49, False: 12.3k]
  ------------------
  334|     49|      return status;  // Wrong VP8X / insufficient data.
  335|     49|    }
  336|  12.3k|    animation_present = !!(flags & ANIMATION_FLAG);
  337|  12.3k|    if (!found_riff && found_vp8x) {
  ------------------
  |  Branch (337:9): [True: 12.3k, False: 0]
  |  Branch (337:24): [True: 1, False: 12.3k]
  ------------------
  338|       |      // Note: This restriction may be removed in the future, if it becomes
  339|       |      // necessary to send VP8X chunk to the decoder.
  340|      1|      return VP8_STATUS_BITSTREAM_ERROR;
  341|      1|    }
  342|  12.3k|    if (has_alpha != NULL) *has_alpha = !!(flags & ALPHA_FLAG);
  ------------------
  |  Branch (342:9): [True: 7.57k, False: 4.77k]
  ------------------
  343|  12.3k|    if (has_animation != NULL) *has_animation = animation_present;
  ------------------
  |  Branch (343:9): [True: 12.3k, False: 0]
  ------------------
  344|  12.3k|    if (format != NULL) *format = 0;  // default = undefined
  ------------------
  |  Branch (344:9): [True: 7.57k, False: 4.77k]
  ------------------
  345|       |
  346|  12.3k|    image_width = canvas_width;
  347|  12.3k|    image_height = canvas_height;
  348|  12.3k|    if (found_vp8x && animation_present && headers == NULL) {
  ------------------
  |  Branch (348:9): [True: 0, False: 12.3k]
  |  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|  12.3k|  }
  353|       |
  354|  12.3k|  if (data_size < TAG_SIZE) {
  ------------------
  |  |   80|  12.3k|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  |  Branch (354:7): [True: 0, False: 12.3k]
  ------------------
  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|  12.3k|  if ((found_riff && found_vp8x) ||
  ------------------
  |  Branch (360:8): [True: 0, False: 12.3k]
  |  Branch (360:22): [True: 0, False: 0]
  ------------------
  361|  12.3k|      (!found_riff && !found_vp8x && !memcmp(data, "ALPH", TAG_SIZE))) {
  ------------------
  |  |   80|  12.3k|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  |  Branch (361:8): [True: 12.3k, False: 0]
  |  Branch (361:23): [True: 12.3k, False: 0]
  |  Branch (361:38): [True: 69, False: 12.2k]
  ------------------
  362|     69|    size_t local_alpha_data_size = 0;
  363|     69|    const uint8_t* WEBP_COUNTED_BY(local_alpha_data_size) local_alpha_data =
  364|     69|        NULL;
  365|     69|    status = ParseOptionalChunks(&data, &data_size, hdrs.riff_size,
  366|     69|                                 &local_alpha_data, &local_alpha_data_size);
  367|     69|    if (status != VP8_STATUS_OK) {
  ------------------
  |  Branch (367:9): [True: 69, False: 0]
  ------------------
  368|     69|      goto ReturnWidthHeight;  // Invalid chunk size / insufficient data.
  369|     69|    }
  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|  12.2k|  status = ParseVP8Header(&data, &data_size, have_all_data, hdrs.riff_size,
  376|  12.2k|                          &hdrs.compressed_size, &hdrs.is_lossless);
  377|  12.2k|  if (status != VP8_STATUS_OK) {
  ------------------
  |  Branch (377:7): [True: 31, False: 12.2k]
  ------------------
  378|     31|    goto ReturnWidthHeight;  // Wrong VP8/VP8L chunk-header / insufficient data.
  379|     31|  }
  380|  12.2k|  if (hdrs.compressed_size > MAX_CHUNK_PAYLOAD) {
  ------------------
  |  |   96|  12.2k|#define MAX_CHUNK_PAYLOAD (~0U - CHUNK_HEADER_SIZE - 1)
  |  |  ------------------
  |  |  |  |   82|  12.2k|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  |  |  ------------------
  ------------------
  |  Branch (380:7): [True: 1, False: 12.2k]
  ------------------
  381|      1|    return VP8_STATUS_BITSTREAM_ERROR;
  382|      1|  }
  383|       |
  384|  12.2k|  if (format != NULL && !animation_present) {
  ------------------
  |  Branch (384:7): [True: 7.50k, False: 4.73k]
  |  Branch (384:25): [True: 7.50k, False: 0]
  ------------------
  385|  7.50k|    *format = hdrs.is_lossless ? 2 : 1;
  ------------------
  |  Branch (385:15): [True: 3.22k, False: 4.28k]
  ------------------
  386|  7.50k|  }
  387|       |
  388|  12.2k|  if (!hdrs.is_lossless) {
  ------------------
  |  Branch (388:7): [True: 6.96k, False: 5.28k]
  ------------------
  389|  6.96k|    if (data_size < VP8_FRAME_HEADER_SIZE) {
  ------------------
  |  |   24|  6.96k|#define VP8_FRAME_HEADER_SIZE 10  // Size of the frame header within VP8 data.
  ------------------
  |  Branch (389:9): [True: 5, False: 6.95k]
  ------------------
  390|      5|      status = VP8_STATUS_NOT_ENOUGH_DATA;
  391|      5|      goto ReturnWidthHeight;
  392|      5|    }
  393|       |    // Validates raw VP8 data.
  394|  6.95k|    if (!VP8GetInfo(data, data_size, (uint32_t)hdrs.compressed_size,
  ------------------
  |  Branch (394:9): [True: 71, False: 6.88k]
  ------------------
  395|  6.95k|                    &image_width, &image_height)) {
  396|     71|      return VP8_STATUS_BITSTREAM_ERROR;
  397|     71|    }
  398|  6.95k|  } else {
  399|  5.28k|    if (data_size < VP8L_FRAME_HEADER_SIZE) {
  ------------------
  |  |   33|  5.28k|#define VP8L_FRAME_HEADER_SIZE 5  // Size of the VP8L frame header.
  ------------------
  |  Branch (399:9): [True: 37, False: 5.24k]
  ------------------
  400|     37|      status = VP8_STATUS_NOT_ENOUGH_DATA;
  401|     37|      goto ReturnWidthHeight;
  402|     37|    }
  403|       |    // Validates raw VP8L data.
  404|  5.24k|    if (!VP8LGetInfo(data, data_size, &image_width, &image_height, has_alpha)) {
  ------------------
  |  Branch (404:9): [True: 7, False: 5.23k]
  ------------------
  405|      7|      return VP8_STATUS_BITSTREAM_ERROR;
  406|      7|    }
  407|  5.24k|  }
  408|       |  // Validates image size coherency.
  409|  12.1k|  if (found_vp8x) {
  ------------------
  |  Branch (409:7): [True: 0, False: 12.1k]
  ------------------
  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|  12.1k|  if (headers != NULL) {
  ------------------
  |  Branch (414:7): [True: 4.73k, False: 7.38k]
  ------------------
  415|  4.73k|    *headers = hdrs;
  416|  4.73k|    headers->offset = data - headers->data;
  417|  4.73k|    assert((uint64_t)(data - headers->data) < MAX_CHUNK_PAYLOAD);
  418|  4.73k|    assert(headers->offset == headers->data_size - data_size);
  419|  4.73k|  }
  420|  12.2k|ReturnWidthHeight:
  421|  12.2k|  if (status == VP8_STATUS_OK ||
  ------------------
  |  Branch (421:7): [True: 12.1k, False: 142]
  ------------------
  422|  12.1k|      (status == VP8_STATUS_NOT_ENOUGH_DATA && found_vp8x && headers == NULL)) {
  ------------------
  |  Branch (422:8): [True: 141, False: 1]
  |  Branch (422:48): [True: 0, False: 141]
  |  Branch (422:62): [True: 0, False: 0]
  ------------------
  423|  12.1k|    if (has_alpha != NULL) {
  ------------------
  |  Branch (423:9): [True: 7.38k, False: 4.73k]
  ------------------
  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|  7.38k|      *has_alpha |= (hdrs.alpha_data != NULL);
  427|  7.38k|    }
  428|  12.1k|    if (width != NULL) *width = image_width;
  ------------------
  |  Branch (428:9): [True: 7.38k, False: 4.73k]
  ------------------
  429|  12.1k|    if (height != NULL) *height = image_height;
  ------------------
  |  Branch (429:9): [True: 7.38k, False: 4.73k]
  ------------------
  430|  12.1k|    return VP8_STATUS_OK;
  431|  12.1k|  } else {
  432|    142|    return status;
  433|    142|  }
  434|  12.2k|}
webp_dec.c:ParseRIFF:
   68|  12.3k|                               size_t* WEBP_SINGLE const riff_size) {
   69|  12.3k|  assert(data != NULL);
   70|  12.3k|  assert(data_size != NULL);
   71|  12.3k|  assert(riff_size != NULL);
   72|       |
   73|  12.3k|  *riff_size = 0;  // Default: no RIFF present.
   74|  12.3k|  if (*data_size >= RIFF_HEADER_SIZE && !memcmp(*data, "RIFF", TAG_SIZE)) {
  ------------------
  |  |   83|  24.7k|#define RIFF_HEADER_SIZE 12  // Size of the RIFF header ("RIFFnnnnWEBP").
  ------------------
                if (*data_size >= RIFF_HEADER_SIZE && !memcmp(*data, "RIFF", TAG_SIZE)) {
  ------------------
  |  |   80|  12.3k|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  |  Branch (74:7): [True: 12.3k, False: 0]
  |  Branch (74:41): [True: 2, False: 12.3k]
  ------------------
   75|      2|    if (memcmp(*data + 8, "WEBP", TAG_SIZE)) {
  ------------------
  |  |   80|      2|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  |  Branch (75:9): [True: 2, False: 0]
  ------------------
   76|      2|      return VP8_STATUS_BITSTREAM_ERROR;  // Wrong image file signature.
   77|      2|    } 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|      2|  }
   95|  12.3k|  return VP8_STATUS_OK;
   96|  12.3k|}
webp_dec.c:ParseVP8X:
  111|  12.3k|                               uint32_t* WEBP_SINGLE const flags_ptr) {
  112|  12.3k|  const uint32_t vp8x_size = CHUNK_HEADER_SIZE + VP8X_CHUNK_SIZE;
  ------------------
  |  |   82|  12.3k|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
                const uint32_t vp8x_size = CHUNK_HEADER_SIZE + VP8X_CHUNK_SIZE;
  ------------------
  |  |   86|  12.3k|#define VP8X_CHUNK_SIZE 10   // Size of a VP8X chunk.
  ------------------
  113|  12.3k|  assert(data != NULL);
  114|  12.3k|  assert(data_size != NULL);
  115|  12.3k|  assert(found_vp8x != NULL);
  116|       |
  117|  12.3k|  *found_vp8x = 0;
  118|       |
  119|  12.3k|  if (*data_size < CHUNK_HEADER_SIZE) {
  ------------------
  |  |   82|  12.3k|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  |  Branch (119:7): [True: 0, False: 12.3k]
  ------------------
  120|      0|    return VP8_STATUS_NOT_ENOUGH_DATA;  // Insufficient data.
  121|      0|  }
  122|       |
  123|  12.3k|  if (!memcmp(*data, "VP8X", TAG_SIZE)) {
  ------------------
  |  |   80|  12.3k|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  |  Branch (123:7): [True: 50, False: 12.3k]
  ------------------
  124|     50|    int width, height;
  125|     50|    uint32_t flags;
  126|     50|    const uint32_t chunk_size = GetLE32(*data + TAG_SIZE);
  ------------------
  |  |   80|     50|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  127|     50|    if (chunk_size != VP8X_CHUNK_SIZE) {
  ------------------
  |  |   86|     50|#define VP8X_CHUNK_SIZE 10   // Size of a VP8X chunk.
  ------------------
  |  Branch (127:9): [True: 41, False: 9]
  ------------------
  128|     41|      return VP8_STATUS_BITSTREAM_ERROR;  // Wrong chunk size.
  129|     41|    }
  130|       |
  131|       |    // Verify if enough data is available to validate the VP8X chunk.
  132|      9|    if (*data_size < vp8x_size) {
  ------------------
  |  Branch (132:9): [True: 2, False: 7]
  ------------------
  133|      2|      return VP8_STATUS_NOT_ENOUGH_DATA;  // Insufficient data.
  134|      2|    }
  135|      7|    flags = GetLE32(*data + 8);
  136|      7|    width = 1 + GetLE24(*data + 12);
  137|      7|    height = 1 + GetLE24(*data + 15);
  138|      7|    if (width * (uint64_t)height >= MAX_IMAGE_AREA) {
  ------------------
  |  |   89|      7|#define MAX_IMAGE_AREA (1ULL << 32)    // 32-bit max for width x height.
  ------------------
  |  Branch (138:9): [True: 6, False: 1]
  ------------------
  139|      6|      return VP8_STATUS_BITSTREAM_ERROR;  // image is too large
  140|      6|    }
  141|       |
  142|      1|    if (flags_ptr != NULL) *flags_ptr = flags;
  ------------------
  |  Branch (142:9): [True: 1, False: 0]
  ------------------
  143|      1|    if (width_ptr != NULL) *width_ptr = width;
  ------------------
  |  Branch (143:9): [True: 1, False: 0]
  ------------------
  144|      1|    if (height_ptr != NULL) *height_ptr = height;
  ------------------
  |  Branch (144:9): [True: 1, False: 0]
  ------------------
  145|       |    // Skip over VP8X header bytes.
  146|      1|    *data_size -= vp8x_size;
  147|      1|    *data += vp8x_size;
  148|      1|    *found_vp8x = 1;
  149|      1|  }
  150|  12.3k|  return VP8_STATUS_OK;
  151|  12.3k|}
webp_dec.c:ParseOptionalChunks:
  164|     69|    size_t* WEBP_SINGLE const alpha_size) {
  165|     69|  size_t buf_size;
  166|     69|  const uint8_t* WEBP_COUNTED_BY(buf_size) buf;
  167|     69|  uint64_t total_size = TAG_SIZE +           // "WEBP".
  ------------------
  |  |   80|     69|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  168|     69|                        CHUNK_HEADER_SIZE +  // "VP8Xnnnn".
  ------------------
  |  |   82|     69|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  169|     69|                        VP8X_CHUNK_SIZE;     // data.
  ------------------
  |  |   86|     69|#define VP8X_CHUNK_SIZE 10   // Size of a VP8X chunk.
  ------------------
  170|     69|  assert(data != NULL);
  171|     69|  assert(data_size != NULL);
  172|     69|  buf = *data;
  173|     69|  buf_size = *data_size;
  174|       |
  175|     69|  assert(alpha_data != NULL);
  176|     69|  assert(alpha_size != NULL);
  177|     69|  *alpha_data = NULL;
  178|     69|  *alpha_size = 0;
  179|       |
  180|    313|  while (1) {
  ------------------
  |  Branch (180:10): [True: 313, Folded]
  ------------------
  181|    313|    uint32_t chunk_size;
  182|    313|    uint32_t disk_chunk_size;  // chunk_size with padding
  183|       |
  184|    313|    *data_size = buf_size;
  185|    313|    *data = buf;
  186|       |
  187|    313|    if (buf_size < CHUNK_HEADER_SIZE) {  // Insufficient data.
  ------------------
  |  |   82|    313|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  |  Branch (187:9): [True: 9, False: 304]
  ------------------
  188|      9|      return VP8_STATUS_NOT_ENOUGH_DATA;
  189|      9|    }
  190|       |
  191|    304|    chunk_size = GetLE32(buf + TAG_SIZE);
  ------------------
  |  |   80|    304|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  192|    304|    if (chunk_size > MAX_CHUNK_PAYLOAD) {
  ------------------
  |  |   96|    304|#define MAX_CHUNK_PAYLOAD (~0U - CHUNK_HEADER_SIZE - 1)
  |  |  ------------------
  |  |  |  |   82|    304|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  |  |  ------------------
  ------------------
  |  Branch (192:9): [True: 1, False: 303]
  ------------------
  193|      1|      return VP8_STATUS_BITSTREAM_ERROR;  // Not a valid chunk size.
  194|      1|    }
  195|       |    // For odd-sized chunk-payload, there's one byte padding at the end.
  196|    303|    disk_chunk_size = (CHUNK_HEADER_SIZE + chunk_size + 1) & ~1u;
  ------------------
  |  |   82|    303|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  197|    303|    total_size += disk_chunk_size;
  198|       |
  199|       |    // Check that total bytes skipped so far does not exceed riff_size.
  200|    303|    if (riff_size > 0 && (total_size > riff_size)) {
  ------------------
  |  Branch (200:9): [True: 0, False: 303]
  |  Branch (200:26): [True: 0, False: 0]
  ------------------
  201|      0|      return VP8_STATUS_BITSTREAM_ERROR;  // Not a valid chunk size.
  202|      0|    }
  203|       |
  204|       |    // Start of a (possibly incomplete) VP8/VP8L chunk implies that we have
  205|       |    // parsed all the optional chunks.
  206|       |    // Note: This check must occur before the check 'buf_size < disk_chunk_size'
  207|       |    // below to allow incomplete VP8/VP8L chunks.
  208|    303|    if (!memcmp(buf, "VP8 ", TAG_SIZE) || !memcmp(buf, "VP8L", TAG_SIZE)) {
  ------------------
  |  |   80|    303|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
                  if (!memcmp(buf, "VP8 ", TAG_SIZE) || !memcmp(buf, "VP8L", TAG_SIZE)) {
  ------------------
  |  |   80|    303|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  |  Branch (208:9): [True: 0, False: 303]
  |  Branch (208:43): [True: 0, False: 303]
  ------------------
  209|      0|      return VP8_STATUS_OK;
  210|      0|    }
  211|       |
  212|    303|    if (buf_size < disk_chunk_size) {  // Insufficient data.
  ------------------
  |  Branch (212:9): [True: 59, False: 244]
  ------------------
  213|     59|      return VP8_STATUS_NOT_ENOUGH_DATA;
  214|     59|    }
  215|       |
  216|    244|    if (!memcmp(buf, "ALPH", TAG_SIZE)) {  // A valid ALPH header.
  ------------------
  |  |   80|    244|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  |  Branch (216:9): [True: 27, False: 217]
  ------------------
  217|     27|      *alpha_data = buf + CHUNK_HEADER_SIZE;
  ------------------
  |  |   82|     27|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  218|     27|      *alpha_size = chunk_size;
  219|     27|    }
  220|       |
  221|       |    // We have a full and valid chunk; skip it.
  222|    244|    buf += disk_chunk_size;
  223|    244|    buf_size -= disk_chunk_size;
  224|    244|  }
  225|     69|}
webp_dec.c:ParseVP8Header:
  240|  12.2k|                                    int* WEBP_SINGLE const is_lossless) {
  241|  12.2k|  const size_t local_data_size = *data_size;
  242|  12.2k|  const uint8_t* WEBP_COUNTED_BY(local_data_size) const data = *data_ptr;
  243|  12.2k|  const int is_vp8 = !memcmp(data, "VP8 ", TAG_SIZE);
  ------------------
  |  |   80|  12.2k|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  244|  12.2k|  const int is_vp8l = !memcmp(data, "VP8L", TAG_SIZE);
  ------------------
  |  |   80|  12.2k|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  245|  12.2k|  const uint32_t minimal_size =
  246|  12.2k|      TAG_SIZE + CHUNK_HEADER_SIZE;  // "WEBP" + "VP8 nnnn" OR
  ------------------
  |  |   80|  12.2k|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
                    TAG_SIZE + CHUNK_HEADER_SIZE;  // "WEBP" + "VP8 nnnn" OR
  ------------------
  |  |   82|  12.2k|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  247|       |                                     // "WEBP" + "VP8Lnnnn"
  248|  12.2k|  (void)local_data_size;
  249|  12.2k|  assert(data != NULL);
  250|  12.2k|  assert(data_size != NULL);
  251|  12.2k|  assert(chunk_size != NULL);
  252|  12.2k|  assert(is_lossless != NULL);
  253|  12.2k|  assert(local_data_size >= TAG_SIZE);  // what the two memcmp() above need
  254|       |
  255|  12.2k|  if (*data_size < CHUNK_HEADER_SIZE) {
  ------------------
  |  |   82|  12.2k|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  |  Branch (255:7): [True: 0, False: 12.2k]
  ------------------
  256|      0|    return VP8_STATUS_NOT_ENOUGH_DATA;  // Insufficient data.
  257|      0|  }
  258|       |
  259|  12.2k|  if (is_vp8 || is_vp8l) {
  ------------------
  |  Branch (259:7): [True: 5, False: 12.2k]
  |  Branch (259:17): [True: 183, False: 12.0k]
  ------------------
  260|       |    // Bitstream contains VP8/VP8L header.
  261|    188|    const uint32_t size = GetLE32(data + TAG_SIZE);
  ------------------
  |  |   80|    188|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  262|    188|    if ((riff_size >= minimal_size) && (size > riff_size - minimal_size)) {
  ------------------
  |  Branch (262:9): [True: 0, False: 188]
  |  Branch (262:40): [True: 0, False: 0]
  ------------------
  263|      0|      return VP8_STATUS_BITSTREAM_ERROR;  // Inconsistent size information.
  264|      0|    }
  265|    188|    if (have_all_data && (size > *data_size - CHUNK_HEADER_SIZE)) {
  ------------------
  |  |   82|     54|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  |  Branch (265:9): [True: 54, False: 134]
  |  Branch (265:26): [True: 31, False: 23]
  ------------------
  266|     31|      return VP8_STATUS_NOT_ENOUGH_DATA;  // Truncated bitstream.
  267|     31|    }
  268|       |    // Skip over CHUNK_HEADER_SIZE bytes from VP8/VP8L Header.
  269|    157|    *chunk_size = size;
  270|    157|    *data_size -= CHUNK_HEADER_SIZE;
  ------------------
  |  |   82|    157|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  271|    157|    *data_ptr += CHUNK_HEADER_SIZE;
  ------------------
  |  |   82|    157|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  272|    157|    *is_lossless = is_vp8l;
  273|  12.0k|  } else {
  274|       |    // Raw VP8/VP8L bitstream (no header).
  275|  12.0k|    *is_lossless = VP8LCheckSignature(data, *data_size);
  276|  12.0k|    *chunk_size = *data_size;
  277|  12.0k|  }
  278|       |
  279|  12.2k|  return VP8_STATUS_OK;
  280|  12.2k|}
webp_dec.c:DecodeIntoRGBABuffer:
  559|  1.76k|    uint8_t* WEBP_COUNTED_BY(size) const rgba, int stride, size_t size) {
  560|  1.76k|  WebPDecParams params;
  561|  1.76k|  WebPDecBuffer buf;
  562|  1.76k|  if (rgba == NULL || !WebPInitDecBuffer(&buf)) {
  ------------------
  |  Branch (562:7): [True: 0, False: 1.76k]
  |  Branch (562:23): [True: 0, False: 1.76k]
  ------------------
  563|      0|    return NULL;
  564|      0|  }
  565|  1.76k|  WebPResetDecParams(&params);
  566|  1.76k|  params.output = &buf;
  567|  1.76k|  buf.colorspace = colorspace;
  568|  1.76k|  buf.u.RGBA.rgba = rgba;
  569|  1.76k|  buf.u.RGBA.stride = stride;
  570|  1.76k|  buf.u.RGBA.size = size;
  571|  1.76k|  buf.is_external_memory = 1;
  572|  1.76k|  if (DecodeInto(data, data_size, &params) != VP8_STATUS_OK) {
  ------------------
  |  Branch (572:7): [True: 1.35k, False: 408]
  ------------------
  573|  1.35k|    return NULL;
  574|  1.35k|  }
  575|    408|  return rgba;
  576|  1.76k|}
webp_dec.c:DecodeInto:
  475|  4.77k|    WebPDecParams* const params) {
  476|  4.77k|  VP8StatusCode status;
  477|  4.77k|  VP8Io io;
  478|  4.77k|  WebPHeaderStructure headers;
  479|       |
  480|  4.77k|  headers.data = data;
  481|  4.77k|  headers.data_size = data_size;
  482|  4.77k|  headers.have_all_data = 1;
  483|  4.77k|  status = WebPParseHeaders(&headers);  // Process Pre-VP8 chunks.
  484|  4.77k|  if (status != VP8_STATUS_OK) {
  ------------------
  |  Branch (484:7): [True: 31, False: 4.73k]
  ------------------
  485|     31|    return status;
  486|     31|  }
  487|       |
  488|  4.77k|  assert(params != NULL);
  489|  4.73k|  if (!VP8InitIo(&io)) {
  ------------------
  |  Branch (489:7): [True: 0, False: 4.73k]
  ------------------
  490|      0|    return VP8_STATUS_INVALID_PARAM;
  491|      0|  }
  492|  4.73k|  io.data = headers.data + headers.offset;
  493|  4.73k|  io.data_size = headers.data_size - headers.offset;
  494|  4.73k|  WebPInitCustomIo(params, &io);  // Plug the I/O functions.
  495|       |
  496|  4.73k|  if (!headers.is_lossless) {
  ------------------
  |  Branch (496:7): [True: 2.67k, False: 2.06k]
  ------------------
  497|  2.67k|    VP8Decoder* const dec = VP8New();
  498|  2.67k|    if (dec == NULL) {
  ------------------
  |  Branch (498:9): [True: 0, False: 2.67k]
  ------------------
  499|      0|      return VP8_STATUS_OUT_OF_MEMORY;
  500|      0|    }
  501|  2.67k|    dec->alpha_data = headers.alpha_data;
  502|  2.67k|    dec->alpha_data_size = headers.alpha_data_size;
  503|       |
  504|       |    // Decode bitstream header, update io->width/io->height.
  505|  2.67k|    if (!VP8GetHeaders(dec, &io)) {
  ------------------
  |  Branch (505:9): [True: 163, False: 2.51k]
  ------------------
  506|    163|      status = dec->status;  // An error occurred. Grab error status.
  507|  2.51k|    } else {
  508|       |      // Allocate/check output buffers.
  509|  2.51k|      status = WebPAllocateDecBuffer(io.width, io.height, params->options,
  510|  2.51k|                                     params->output);
  511|  2.51k|      if (status == VP8_STATUS_OK) {  // Decode
  ------------------
  |  Branch (511:11): [True: 2.48k, False: 31]
  ------------------
  512|       |        // This change must be done before calling VP8Decode()
  513|  2.48k|        dec->mt_method =
  514|  2.48k|            VP8GetThreadMethod(params->options, &headers, io.width, io.height);
  515|  2.48k|        VP8InitDithering(params->options, dec);
  516|  2.48k|        if (!VP8Decode(dec, &io)) {
  ------------------
  |  Branch (516:13): [True: 2.16k, False: 321]
  ------------------
  517|  2.16k|          status =
  518|  2.16k|              (params->status != VP8_STATUS_OK) ? params->status : dec->status;
  ------------------
  |  Branch (518:15): [True: 0, False: 2.16k]
  ------------------
  519|  2.16k|        }
  520|  2.48k|      }
  521|  2.51k|    }
  522|  2.67k|    VP8Delete(dec);
  523|  2.67k|  } else {
  524|  2.06k|    VP8LDecoder* const dec = VP8LNew();
  525|  2.06k|    if (dec == NULL) {
  ------------------
  |  Branch (525:9): [True: 0, False: 2.06k]
  ------------------
  526|      0|      return VP8_STATUS_OUT_OF_MEMORY;
  527|      0|    }
  528|  2.06k|    if (!VP8LDecodeHeader(dec, &io)) {
  ------------------
  |  Branch (528:9): [True: 805, False: 1.25k]
  ------------------
  529|    805|      status = dec->status;  // An error occurred. Grab error status.
  530|  1.25k|    } else {
  531|       |      // Allocate/check output buffers.
  532|  1.25k|      status = WebPAllocateDecBuffer(io.width, io.height, params->options,
  533|  1.25k|                                     params->output);
  534|  1.25k|      if (status == VP8_STATUS_OK) {  // Decode
  ------------------
  |  Branch (534:11): [True: 1.23k, False: 22]
  ------------------
  535|  1.23k|        if (!VP8LDecodeImage(dec)) {
  ------------------
  |  Branch (535:13): [True: 322, False: 913]
  ------------------
  536|    322|          status = dec->status;
  537|    322|        }
  538|  1.23k|      }
  539|  1.25k|    }
  540|  2.06k|    VP8LDelete(dec);
  541|  2.06k|  }
  542|       |
  543|  4.73k|  if (status != VP8_STATUS_OK) {
  ------------------
  |  Branch (543:7): [True: 3.50k, False: 1.23k]
  ------------------
  544|  3.50k|    WebPFreeDecBuffer(params->output);
  545|  3.50k|  } else {
  546|  1.23k|    if (params->options != NULL && params->options->flip) {
  ------------------
  |  Branch (546:9): [True: 0, False: 1.23k]
  |  Branch (546:36): [True: 0, False: 0]
  ------------------
  547|       |      // This restores the original stride values if options->flip was used
  548|       |      // during the call to WebPAllocateDecBuffer above.
  549|      0|      status = WebPFlipBuffer(params->output);
  550|      0|    }
  551|  1.23k|  }
  552|  4.73k|  return status;
  553|  4.73k|}
webp_dec.c:Decode:
  649|  2.59k|                                      WebPDecBuffer* const keep_info) {
  650|  2.59k|  WebPDecParams params;
  651|  2.59k|  WebPDecBuffer output;
  652|       |
  653|  2.59k|  if (!WebPInitDecBuffer(&output)) {
  ------------------
  |  Branch (653:7): [True: 0, False: 2.59k]
  ------------------
  654|      0|    return NULL;
  655|      0|  }
  656|  2.59k|  WebPResetDecParams(&params);
  657|  2.59k|  params.output = &output;
  658|  2.59k|  output.colorspace = mode;
  659|       |
  660|       |  // Retrieve (and report back) the required dimensions from bitstream.
  661|  2.59k|  if (!WebPGetInfo(data, data_size, &output.width, &output.height)) {
  ------------------
  |  Branch (661:7): [True: 0, False: 2.59k]
  ------------------
  662|      0|    return NULL;
  663|      0|  }
  664|  2.59k|  if (width != NULL) *width = output.width;
  ------------------
  |  Branch (664:7): [True: 2.59k, False: 0]
  ------------------
  665|  2.59k|  if (height != NULL) *height = output.height;
  ------------------
  |  Branch (665:7): [True: 2.59k, False: 0]
  ------------------
  666|       |
  667|       |  // Decode
  668|  2.59k|  if (DecodeInto(data, data_size, &params) != VP8_STATUS_OK) {
  ------------------
  |  Branch (668:7): [True: 1.89k, False: 702]
  ------------------
  669|  1.89k|    return NULL;
  670|  1.89k|  }
  671|    702|  if (keep_info != NULL) {  // keep track of the side-info
  ------------------
  |  Branch (671:7): [True: 108, False: 594]
  ------------------
  672|    108|    WebPCopyDecBuffer(&output, keep_info);
  673|    108|  }
  674|       |  // return decoded samples (don't clear 'output'!)
  675|    702|  return WebPIsRGBMode(mode) ? output.u.RGBA.rgba : output.u.YUVA.y;
  ------------------
  |  Branch (675:10): [True: 594, False: 108]
  ------------------
  676|  2.59k|}
webp_dec.c:GetFeatures:
  736|  7.65k|                                 WebPBitstreamFeatures* const features) {
  737|  7.65k|  if (features == NULL || data == NULL) {
  ------------------
  |  Branch (737:7): [True: 0, False: 7.65k]
  |  Branch (737:27): [True: 2, False: 7.64k]
  ------------------
  738|      2|    return VP8_STATUS_INVALID_PARAM;
  739|      2|  }
  740|  7.64k|  DefaultFeatures(features);
  741|       |
  742|       |  // Only parse enough of the data to retrieve the features.
  743|  7.64k|  return ParseHeadersInternal(
  744|  7.64k|      data, data_size, &features->width, &features->height,
  745|       |      &features->has_alpha, &features->has_animation, &features->format, NULL);
  746|  7.65k|}
webp_dec.c:DefaultFeatures:
  728|  7.64k|static void DefaultFeatures(WebPBitstreamFeatures* const features) {
  729|  7.64k|  assert(features != NULL);
  730|  7.64k|  WEBP_UNSAFE_MEMSET(features, 0, sizeof(*features));
  ------------------
  |  |  175|  7.64k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  731|  7.64k|}

alpha_processing.c:WebPInitAlphaProcessing_body:
  444|      1|WEBP_DSP_INIT_FUNC(WebPInitAlphaProcessing) {
  445|      1|  WebPMultARGBRow = WebPMultARGBRow_C;
  446|      1|  WebPMultRow = WebPMultRow_C;
  447|      1|  WebPApplyAlphaMultiply4444 = ApplyAlphaMultiply_16b_C;
  448|       |
  449|       |#ifdef WORDS_BIGENDIAN
  450|       |  WebPPackARGB = PackARGB_C;
  451|       |#endif
  452|      1|  WebPPackRGB = PackRGB_C;
  453|      1|#if !WEBP_NEON_OMIT_C_CODE
  454|      1|  WebPApplyAlphaMultiply = ApplyAlphaMultiply_C;
  455|      1|  WebPDispatchAlpha = DispatchAlpha_C;
  456|      1|  WebPDispatchAlphaToGreen = DispatchAlphaToGreen_C;
  457|      1|  WebPExtractAlpha = ExtractAlpha_C;
  458|      1|  WebPExtractGreen = ExtractGreen_C;
  459|      1|#endif
  460|       |
  461|      1|  WebPHasAlpha8b = HasAlpha8b_C;
  462|      1|  WebPHasAlpha32b = HasAlpha32b_C;
  463|      1|  WebPAlphaReplace = AlphaReplace_C;
  464|       |
  465|       |  // If defined, use CPUInfo() to overwrite some pointers with faster versions.
  466|      1|  if (VP8GetCPUInfo != NULL) {
  ------------------
  |  Branch (466:7): [True: 1, False: 0]
  ------------------
  467|      1|#if defined(WEBP_HAVE_SSE2)
  468|      1|    if (VP8GetCPUInfo(kSSE2)) {
  ------------------
  |  Branch (468:9): [True: 1, False: 0]
  ------------------
  469|      1|      WebPInitAlphaProcessingSSE2();
  470|      1|#if defined(WEBP_HAVE_SSE41)
  471|      1|      if (VP8GetCPUInfo(kSSE4_1)) {
  ------------------
  |  Branch (471:11): [True: 1, False: 0]
  ------------------
  472|      1|        WebPInitAlphaProcessingSSE41();
  473|      1|      }
  474|      1|#endif
  475|      1|    }
  476|      1|#endif
  477|       |#if defined(WEBP_USE_MIPS_DSP_R2)
  478|       |    if (VP8GetCPUInfo(kMIPSdspR2)) {
  479|       |      WebPInitAlphaProcessingMIPSdspR2();
  480|       |    }
  481|       |#endif
  482|      1|  }
  483|       |
  484|       |#if defined(WEBP_HAVE_NEON)
  485|       |  if (WEBP_NEON_OMIT_C_CODE ||
  486|       |      (VP8GetCPUInfo != NULL && VP8GetCPUInfo(kNEON))) {
  487|       |    WebPInitAlphaProcessingNEON();
  488|       |  }
  489|       |#endif
  490|       |
  491|      1|  assert(WebPMultARGBRow != NULL);
  492|      1|  assert(WebPMultRow != NULL);
  493|      1|  assert(WebPApplyAlphaMultiply != NULL);
  494|      1|  assert(WebPApplyAlphaMultiply4444 != NULL);
  495|      1|  assert(WebPDispatchAlpha != NULL);
  496|      1|  assert(WebPDispatchAlphaToGreen != NULL);
  497|      1|  assert(WebPExtractAlpha != NULL);
  498|      1|  assert(WebPExtractGreen != NULL);
  499|       |#ifdef WORDS_BIGENDIAN
  500|       |  assert(WebPPackARGB != NULL);
  501|       |#endif
  502|      1|  assert(WebPPackRGB != NULL);
  503|      1|  assert(WebPHasAlpha8b != NULL);
  504|      1|  assert(WebPHasAlpha32b != NULL);
  505|       |  assert(WebPAlphaReplace != NULL);
  506|      1|}

WebPInitAlphaProcessingSSE2:
  406|      1|WEBP_TSAN_IGNORE_FUNCTION void WebPInitAlphaProcessingSSE2(void) {
  407|      1|  WebPMultARGBRow = MultARGBRow_SSE2;
  408|      1|  WebPMultRow = MultRow_SSE2;
  409|      1|  WebPApplyAlphaMultiply = ApplyAlphaMultiply_SSE2;
  410|      1|  WebPDispatchAlpha = DispatchAlpha_SSE2;
  411|      1|  WebPDispatchAlphaToGreen = DispatchAlphaToGreen_SSE2;
  412|      1|  WebPExtractAlpha = ExtractAlpha_SSE2;
  413|      1|  WebPExtractGreen = ExtractGreen_SSE2;
  414|       |
  415|      1|  WebPHasAlpha8b = HasAlpha8b_SSE2;
  416|      1|  WebPHasAlpha32b = HasAlpha32b_SSE2;
  417|      1|  WebPAlphaReplace = AlphaReplace_SSE2;
  418|      1|}

WebPInitAlphaProcessingSSE41:
   86|      1|WEBP_TSAN_IGNORE_FUNCTION void WebPInitAlphaProcessingSSE41(void) {
   87|      1|  WebPExtractAlpha = ExtractAlpha_SSE41;
   88|      1|}

dec_sse2.c:VP8Transpose_2_4x4_16b:
   71|  80.7k|    __m128i* const out1, __m128i* const out2, __m128i* const out3) {
   72|       |  // Transpose the two 4x4.
   73|       |  // a00 a01 a02 a03   b00 b01 b02 b03
   74|       |  // a10 a11 a12 a13   b10 b11 b12 b13
   75|       |  // a20 a21 a22 a23   b20 b21 b22 b23
   76|       |  // a30 a31 a32 a33   b30 b31 b32 b33
   77|  80.7k|  const __m128i transpose0_0 = _mm_unpacklo_epi16(*in0, *in1);
   78|  80.7k|  const __m128i transpose0_1 = _mm_unpacklo_epi16(*in2, *in3);
   79|  80.7k|  const __m128i transpose0_2 = _mm_unpackhi_epi16(*in0, *in1);
   80|  80.7k|  const __m128i transpose0_3 = _mm_unpackhi_epi16(*in2, *in3);
   81|       |  // a00 a10 a01 a11   a02 a12 a03 a13
   82|       |  // a20 a30 a21 a31   a22 a32 a23 a33
   83|       |  // b00 b10 b01 b11   b02 b12 b03 b13
   84|       |  // b20 b30 b21 b31   b22 b32 b23 b33
   85|  80.7k|  const __m128i transpose1_0 = _mm_unpacklo_epi32(transpose0_0, transpose0_1);
   86|  80.7k|  const __m128i transpose1_1 = _mm_unpacklo_epi32(transpose0_2, transpose0_3);
   87|  80.7k|  const __m128i transpose1_2 = _mm_unpackhi_epi32(transpose0_0, transpose0_1);
   88|  80.7k|  const __m128i transpose1_3 = _mm_unpackhi_epi32(transpose0_2, transpose0_3);
   89|       |  // a00 a10 a20 a30 a01 a11 a21 a31
   90|       |  // b00 b10 b20 b30 b01 b11 b21 b31
   91|       |  // a02 a12 a22 a32 a03 a13 a23 a33
   92|       |  // b02 b12 a22 b32 b03 b13 b23 b33
   93|  80.7k|  *out0 = _mm_unpacklo_epi64(transpose1_0, transpose1_1);
   94|  80.7k|  *out1 = _mm_unpackhi_epi64(transpose1_0, transpose1_1);
   95|  80.7k|  *out2 = _mm_unpacklo_epi64(transpose1_2, transpose1_3);
   96|  80.7k|  *out3 = _mm_unpackhi_epi64(transpose1_2, transpose1_3);
   97|       |  // a00 a10 a20 a30   b00 b10 b20 b30
   98|       |  // a01 a11 a21 a31   b01 b11 b21 b31
   99|       |  // a02 a12 a22 a32   b02 b12 b22 b32
  100|       |  // a03 a13 a23 a33   b03 b13 b23 b33
  101|  80.7k|}

yuv_sse41.c:VP8PlanarTo24b_SSE41:
   40|   163k|    __m128i* const in3, __m128i* const in4, __m128i* const in5) {
   41|   163k|  __m128i R0, R1, R2, R3, R4, R5;
   42|   163k|  __m128i G0, G1, G2, G3, G4, G5;
   43|   163k|  __m128i B0, B1, B2, B3, B4, B5;
   44|       |
   45|       |  // Process R.
   46|   163k|  {
   47|   163k|    const __m128i shuff0 =
   48|   163k|        _mm_set_epi8(5, -1, -1, 4, -1, -1, 3, -1, -1, 2, -1, -1, 1, -1, -1, 0);
   49|   163k|    const __m128i shuff1 = _mm_set_epi8(-1, 10, -1, -1, 9, -1, -1, 8, -1, -1, 7,
   50|   163k|                                        -1, -1, 6, -1, -1);
   51|   163k|    const __m128i shuff2 = _mm_set_epi8(-1, -1, 15, -1, -1, 14, -1, -1, 13, -1,
   52|   163k|                                        -1, 12, -1, -1, 11, -1);
   53|   163k|    WEBP_SSE41_SHUFF(R, in0, in1)
  ------------------
  |  |   28|   163k|  OUT##0 = _mm_shuffle_epi8(*IN0, shuff0); \
  |  |   29|   163k|  OUT##1 = _mm_shuffle_epi8(*IN0, shuff1); \
  |  |   30|   163k|  OUT##2 = _mm_shuffle_epi8(*IN0, shuff2); \
  |  |   31|   163k|  OUT##3 = _mm_shuffle_epi8(*IN1, shuff0); \
  |  |   32|   163k|  OUT##4 = _mm_shuffle_epi8(*IN1, shuff1); \
  |  |   33|   163k|  OUT##5 = _mm_shuffle_epi8(*IN1, shuff2);
  ------------------
   54|   163k|  }
   55|       |
   56|       |  // Process G.
   57|   163k|  {
   58|       |    // Same as before, just shifted to the left by one and including the right
   59|       |    // padding.
   60|   163k|    const __m128i shuff0 =
   61|   163k|        _mm_set_epi8(-1, -1, 4, -1, -1, 3, -1, -1, 2, -1, -1, 1, -1, -1, 0, -1);
   62|   163k|    const __m128i shuff1 =
   63|   163k|        _mm_set_epi8(10, -1, -1, 9, -1, -1, 8, -1, -1, 7, -1, -1, 6, -1, -1, 5);
   64|   163k|    const __m128i shuff2 = _mm_set_epi8(-1, 15, -1, -1, 14, -1, -1, 13, -1, -1,
   65|   163k|                                        12, -1, -1, 11, -1, -1);
   66|   163k|    WEBP_SSE41_SHUFF(G, in2, in3)
  ------------------
  |  |   28|   163k|  OUT##0 = _mm_shuffle_epi8(*IN0, shuff0); \
  |  |   29|   163k|  OUT##1 = _mm_shuffle_epi8(*IN0, shuff1); \
  |  |   30|   163k|  OUT##2 = _mm_shuffle_epi8(*IN0, shuff2); \
  |  |   31|   163k|  OUT##3 = _mm_shuffle_epi8(*IN1, shuff0); \
  |  |   32|   163k|  OUT##4 = _mm_shuffle_epi8(*IN1, shuff1); \
  |  |   33|   163k|  OUT##5 = _mm_shuffle_epi8(*IN1, shuff2);
  ------------------
   67|   163k|  }
   68|       |
   69|       |  // Process B.
   70|   163k|  {
   71|   163k|    const __m128i shuff0 =
   72|   163k|        _mm_set_epi8(-1, 4, -1, -1, 3, -1, -1, 2, -1, -1, 1, -1, -1, 0, -1, -1);
   73|   163k|    const __m128i shuff1 =
   74|   163k|        _mm_set_epi8(-1, -1, 9, -1, -1, 8, -1, -1, 7, -1, -1, 6, -1, -1, 5, -1);
   75|   163k|    const __m128i shuff2 = _mm_set_epi8(15, -1, -1, 14, -1, -1, 13, -1, -1, 12,
   76|   163k|                                        -1, -1, 11, -1, -1, 10);
   77|   163k|    WEBP_SSE41_SHUFF(B, in4, in5)
  ------------------
  |  |   28|   163k|  OUT##0 = _mm_shuffle_epi8(*IN0, shuff0); \
  |  |   29|   163k|  OUT##1 = _mm_shuffle_epi8(*IN0, shuff1); \
  |  |   30|   163k|  OUT##2 = _mm_shuffle_epi8(*IN0, shuff2); \
  |  |   31|   163k|  OUT##3 = _mm_shuffle_epi8(*IN1, shuff0); \
  |  |   32|   163k|  OUT##4 = _mm_shuffle_epi8(*IN1, shuff1); \
  |  |   33|   163k|  OUT##5 = _mm_shuffle_epi8(*IN1, shuff2);
  ------------------
   78|   163k|  }
   79|       |
   80|       |  // OR the different channels.
   81|   163k|  {
   82|   163k|    const __m128i RG0 = _mm_or_si128(R0, G0);
   83|   163k|    const __m128i RG1 = _mm_or_si128(R1, G1);
   84|   163k|    const __m128i RG2 = _mm_or_si128(R2, G2);
   85|   163k|    const __m128i RG3 = _mm_or_si128(R3, G3);
   86|   163k|    const __m128i RG4 = _mm_or_si128(R4, G4);
   87|   163k|    const __m128i RG5 = _mm_or_si128(R5, G5);
   88|   163k|    *in0 = _mm_or_si128(RG0, B0);
   89|   163k|    *in1 = _mm_or_si128(RG1, B1);
   90|   163k|    *in2 = _mm_or_si128(RG2, B2);
   91|   163k|    *in3 = _mm_or_si128(RG3, B3);
   92|   163k|    *in4 = _mm_or_si128(RG4, B4);
   93|   163k|    *in5 = _mm_or_si128(RG5, B5);
   94|   163k|  }
   95|   163k|}
yuv_sse41.c:VP8L32bToPlanar_SSE41:
  104|   220k|                                              __m128i* const in3) {
  105|       |  // aaaarrrrggggbbbb
  106|   220k|  const __m128i shuff0 =
  107|   220k|      _mm_set_epi8(15, 11, 7, 3, 14, 10, 6, 2, 13, 9, 5, 1, 12, 8, 4, 0);
  108|   220k|  const __m128i A0 = _mm_shuffle_epi8(*in0, shuff0);
  109|   220k|  const __m128i A1 = _mm_shuffle_epi8(*in1, shuff0);
  110|   220k|  const __m128i A2 = _mm_shuffle_epi8(*in2, shuff0);
  111|   220k|  const __m128i A3 = _mm_shuffle_epi8(*in3, shuff0);
  112|       |  // A0A1R0R1
  113|       |  // G0G1B0B1
  114|       |  // A2A3R2R3
  115|       |  // G0G1B0B1
  116|   220k|  const __m128i B0 = _mm_unpacklo_epi32(A0, A1);
  117|   220k|  const __m128i B1 = _mm_unpackhi_epi32(A0, A1);
  118|   220k|  const __m128i B2 = _mm_unpacklo_epi32(A2, A3);
  119|   220k|  const __m128i B3 = _mm_unpackhi_epi32(A2, A3);
  120|   220k|  *in3 = _mm_unpacklo_epi64(B0, B2);
  121|   220k|  *in2 = _mm_unpackhi_epi64(B0, B2);
  122|   220k|  *in1 = _mm_unpacklo_epi64(B1, B3);
  123|   220k|  *in0 = _mm_unpackhi_epi64(B1, B3);
  124|   220k|}

cpu.c:x86CPUInfo:
  118|     15|static int x86CPUInfo(CPUFeature feature) {
  119|     15|  int max_cpuid_value;
  120|     15|  int cpu_info[4];
  121|     15|  int is_intel = 0;
  122|       |
  123|       |  // get the highest feature value cpuid supports
  124|     15|  GetCPUInfo(cpu_info, 0);
  125|     15|  max_cpuid_value = cpu_info[0];
  126|     15|  if (max_cpuid_value < 1) {
  ------------------
  |  Branch (126:7): [True: 0, False: 15]
  ------------------
  127|      0|    return 0;
  128|     15|  } else {
  129|     15|    const int VENDOR_ID_INTEL_EBX = 0x756e6547;  // uneG
  130|     15|    const int VENDOR_ID_INTEL_EDX = 0x49656e69;  // Ieni
  131|     15|    const int VENDOR_ID_INTEL_ECX = 0x6c65746e;  // letn
  132|     15|    is_intel = (cpu_info[1] == VENDOR_ID_INTEL_EBX &&
  ------------------
  |  Branch (132:17): [True: 0, False: 15]
  ------------------
  133|      0|                cpu_info[2] == VENDOR_ID_INTEL_ECX &&
  ------------------
  |  Branch (133:17): [True: 0, False: 0]
  ------------------
  134|      0|                cpu_info[3] == VENDOR_ID_INTEL_EDX);  // genuine Intel?
  ------------------
  |  Branch (134:17): [True: 0, False: 0]
  ------------------
  135|     15|  }
  136|       |
  137|     15|  GetCPUInfo(cpu_info, 1);
  138|     15|  if (feature == kSSE2) {
  ------------------
  |  Branch (138:7): [True: 6, False: 9]
  ------------------
  139|      6|    return !!(cpu_info[3] & (1 << 26));
  140|      6|  }
  141|      9|  if (feature == kSSE3) {
  ------------------
  |  Branch (141:7): [True: 0, False: 9]
  ------------------
  142|      0|    return !!(cpu_info[2] & (1 << 0));
  143|      0|  }
  144|      9|  if (feature == kSlowSSSE3) {
  ------------------
  |  Branch (144:7): [True: 1, False: 8]
  ------------------
  145|      1|    if (is_intel && (cpu_info[2] & (1 << 9))) {  // SSSE3?
  ------------------
  |  Branch (145:9): [True: 0, False: 1]
  |  Branch (145:21): [True: 0, False: 0]
  ------------------
  146|      0|      return CheckSlowModel(cpu_info[0]);
  147|      0|    }
  148|      1|    return 0;
  149|      1|  }
  150|       |
  151|      8|  if (feature == kSSE4_1) {
  ------------------
  |  Branch (151:7): [True: 6, False: 2]
  ------------------
  152|      6|    return !!(cpu_info[2] & (1 << 19));
  153|      6|  }
  154|      2|  if (feature == kAVX) {
  ------------------
  |  Branch (154:7): [True: 1, False: 1]
  ------------------
  155|       |    // bits 27 (OSXSAVE) & 28 (256-bit AVX)
  156|      1|    if ((cpu_info[2] & 0x18000000) == 0x18000000) {
  ------------------
  |  Branch (156:9): [True: 1, False: 0]
  ------------------
  157|       |      // XMM state and YMM state enabled by the OS.
  158|      1|      return (xgetbv() & 0x6) == 0x6;
  159|      1|    }
  160|      1|  }
  161|      1|  if (feature == kAVX2) {
  ------------------
  |  Branch (161:7): [True: 1, False: 0]
  ------------------
  162|      1|    if (x86CPUInfo(kAVX) && max_cpuid_value >= 7) {
  ------------------
  |  Branch (162:9): [True: 1, False: 0]
  |  Branch (162:29): [True: 1, False: 0]
  ------------------
  163|      1|      GetCPUInfo(cpu_info, 7);
  164|      1|      return !!(cpu_info[1] & (1 << 5));
  165|      1|    }
  166|      1|  }
  167|      0|  return 0;
  168|      1|}
cpu.c:GetCPUInfo:
   45|     31|static WEBP_INLINE void GetCPUInfo(int cpu_info[4], int info_type) {
   46|     31|  __asm__ volatile("cpuid\n"
   47|     31|                   : "=a"(cpu_info[0]), "=b"(cpu_info[1]), "=c"(cpu_info[2]),
   48|     31|                     "=d"(cpu_info[3])
   49|     31|                   : "a"(info_type), "c"(0));
   50|     31|}
cpu.c:xgetbv:
   67|      1|static WEBP_INLINE uint64_t xgetbv(void) {
   68|      1|  const uint32_t ecx = 0;
   69|      1|  uint32_t eax, edx;
   70|       |  // Use the raw opcode for xgetbv for compatibility with older toolchains.
   71|      1|  __asm__ volatile(".byte 0x0f, 0x01, 0xd0\n"
   72|      1|                   : "=a"(eax), "=d"(edx)
   73|      1|                   : "c"(ecx));
   74|      1|  return ((uint64_t)edx << 32) | eax;
   75|      1|}

vp8_dec.c:InitGetCoeffs:
  275|  2.67k|  WEBP_TSAN_IGNORE_FUNCTION void name(void) { WEBP_DSP_INIT(name##_body); } \
  ------------------
  |  |  243|  2.67k|  do {                                                     \
  |  |  244|  2.67k|    if (pthread_mutex_lock(&func##_lock)) break;           \
  |  |  ------------------
  |  |  |  Branch (244:9): [True: 0, False: 2.67k]
  |  |  ------------------
  |  |  245|  2.67k|    if (func##_last_cpuinfo_used != VP8GetCPUInfo) func(); \
  |  |  ------------------
  |  |  |  Branch (245:9): [True: 1, False: 2.67k]
  |  |  ------------------
  |  |  246|  2.67k|    func##_last_cpuinfo_used = VP8GetCPUInfo;              \
  |  |  247|  2.67k|    (void)pthread_mutex_unlock(&func##_lock);              \
  |  |  248|  2.67k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (248:12): [Folded, False: 2.67k]
  |  |  ------------------
  ------------------
WebPInitAlphaProcessing:
  275|  1.20k|  WEBP_TSAN_IGNORE_FUNCTION void name(void) { WEBP_DSP_INIT(name##_body); } \
  ------------------
  |  |  243|  1.20k|  do {                                                     \
  |  |  244|  1.20k|    if (pthread_mutex_lock(&func##_lock)) break;           \
  |  |  ------------------
  |  |  |  Branch (244:9): [True: 0, False: 1.20k]
  |  |  ------------------
  |  |  245|  1.20k|    if (func##_last_cpuinfo_used != VP8GetCPUInfo) func(); \
  |  |  ------------------
  |  |  |  Branch (245:9): [True: 1, False: 1.20k]
  |  |  ------------------
  |  |  246|  1.20k|    func##_last_cpuinfo_used = VP8GetCPUInfo;              \
  |  |  247|  1.20k|    (void)pthread_mutex_unlock(&func##_lock);              \
  |  |  248|  1.20k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (248:12): [Folded, False: 1.20k]
  |  |  ------------------
  ------------------
VP8DspInit:
  275|  2.48k|  WEBP_TSAN_IGNORE_FUNCTION void name(void) { WEBP_DSP_INIT(name##_body); } \
  ------------------
  |  |  243|  2.48k|  do {                                                     \
  |  |  244|  2.48k|    if (pthread_mutex_lock(&func##_lock)) break;           \
  |  |  ------------------
  |  |  |  Branch (244:9): [True: 0, False: 2.48k]
  |  |  ------------------
  |  |  245|  2.48k|    if (func##_last_cpuinfo_used != VP8GetCPUInfo) func(); \
  |  |  ------------------
  |  |  |  Branch (245:9): [True: 1, False: 2.48k]
  |  |  ------------------
  |  |  246|  2.48k|    func##_last_cpuinfo_used = VP8GetCPUInfo;              \
  |  |  247|  2.48k|    (void)pthread_mutex_unlock(&func##_lock);              \
  |  |  248|  2.48k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (248:12): [Folded, False: 2.48k]
  |  |  ------------------
  ------------------
VP8LDspInit:
  275|  2.06k|  WEBP_TSAN_IGNORE_FUNCTION void name(void) { WEBP_DSP_INIT(name##_body); } \
  ------------------
  |  |  243|  2.06k|  do {                                                     \
  |  |  244|  2.06k|    if (pthread_mutex_lock(&func##_lock)) break;           \
  |  |  ------------------
  |  |  |  Branch (244:9): [True: 0, False: 2.06k]
  |  |  ------------------
  |  |  245|  2.06k|    if (func##_last_cpuinfo_used != VP8GetCPUInfo) func(); \
  |  |  ------------------
  |  |  |  Branch (245:9): [True: 1, False: 2.06k]
  |  |  ------------------
  |  |  246|  2.06k|    func##_last_cpuinfo_used = VP8GetCPUInfo;              \
  |  |  247|  2.06k|    (void)pthread_mutex_unlock(&func##_lock);              \
  |  |  248|  2.06k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (248:12): [Folded, False: 2.06k]
  |  |  ------------------
  ------------------
WebPInitUpsamplers:
  275|  2.15k|  WEBP_TSAN_IGNORE_FUNCTION void name(void) { WEBP_DSP_INIT(name##_body); } \
  ------------------
  |  |  243|  2.15k|  do {                                                     \
  |  |  244|  2.15k|    if (pthread_mutex_lock(&func##_lock)) break;           \
  |  |  ------------------
  |  |  |  Branch (244:9): [True: 0, False: 2.15k]
  |  |  ------------------
  |  |  245|  2.15k|    if (func##_last_cpuinfo_used != VP8GetCPUInfo) func(); \
  |  |  ------------------
  |  |  |  Branch (245:9): [True: 1, False: 2.15k]
  |  |  ------------------
  |  |  246|  2.15k|    func##_last_cpuinfo_used = VP8GetCPUInfo;              \
  |  |  247|  2.15k|    (void)pthread_mutex_unlock(&func##_lock);              \
  |  |  248|  2.15k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (248:12): [Folded, False: 2.15k]
  |  |  ------------------
  ------------------
WebPInitSamplers:
  275|  2.15k|  WEBP_TSAN_IGNORE_FUNCTION void name(void) { WEBP_DSP_INIT(name##_body); } \
  ------------------
  |  |  243|  2.15k|  do {                                                     \
  |  |  244|  2.15k|    if (pthread_mutex_lock(&func##_lock)) break;           \
  |  |  ------------------
  |  |  |  Branch (244:9): [True: 0, False: 2.15k]
  |  |  ------------------
  |  |  245|  2.15k|    if (func##_last_cpuinfo_used != VP8GetCPUInfo) func(); \
  |  |  ------------------
  |  |  |  Branch (245:9): [True: 1, False: 2.15k]
  |  |  ------------------
  |  |  246|  2.15k|    func##_last_cpuinfo_used = VP8GetCPUInfo;              \
  |  |  247|  2.15k|    (void)pthread_mutex_unlock(&func##_lock);              \
  |  |  248|  2.15k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (248:12): [Folded, False: 2.15k]
  |  |  ------------------
  ------------------
WebPInitGammaTables:
  275|  18.4k|  WEBP_TSAN_IGNORE_FUNCTION void name(void) { WEBP_DSP_INIT(name##_body); } \
  ------------------
  |  |  243|  18.4k|  do {                                                     \
  |  |  244|  18.4k|    if (pthread_mutex_lock(&func##_lock)) break;           \
  |  |  ------------------
  |  |  |  Branch (244:9): [True: 0, False: 18.4k]
  |  |  ------------------
  |  |  245|  18.4k|    if (func##_last_cpuinfo_used != VP8GetCPUInfo) func(); \
  |  |  ------------------
  |  |  |  Branch (245:9): [True: 1, False: 18.4k]
  |  |  ------------------
  |  |  246|  18.4k|    func##_last_cpuinfo_used = VP8GetCPUInfo;              \
  |  |  247|  18.4k|    (void)pthread_mutex_unlock(&func##_lock);              \
  |  |  248|  18.4k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (248:12): [Folded, False: 18.4k]
  |  |  ------------------
  ------------------
WebPInitConvertARGBToYUV:
  275|    286|  WEBP_TSAN_IGNORE_FUNCTION void name(void) { WEBP_DSP_INIT(name##_body); } \
  ------------------
  |  |  243|    286|  do {                                                     \
  |  |  244|    286|    if (pthread_mutex_lock(&func##_lock)) break;           \
  |  |  ------------------
  |  |  |  Branch (244:9): [True: 0, False: 286]
  |  |  ------------------
  |  |  245|    286|    if (func##_last_cpuinfo_used != VP8GetCPUInfo) func(); \
  |  |  ------------------
  |  |  |  Branch (245:9): [True: 1, False: 285]
  |  |  ------------------
  |  |  246|    286|    func##_last_cpuinfo_used = VP8GetCPUInfo;              \
  |  |  247|    286|    (void)pthread_mutex_unlock(&func##_lock);              \
  |  |  248|    286|  } while (0)
  |  |  ------------------
  |  |  |  Branch (248:12): [Folded, False: 286]
  |  |  ------------------
  ------------------

dec.c:VP8DspInit_body:
  754|      1|WEBP_DSP_INIT_FUNC(VP8DspInit) {
  755|      1|  VP8InitClipTables();
  756|       |
  757|      1|#if !WEBP_NEON_OMIT_C_CODE
  758|      1|  VP8TransformWHT = TransformWHT_C;
  759|      1|  VP8Transform = TransformTwo_C;
  760|      1|  VP8TransformDC = TransformDC_C;
  761|      1|  VP8TransformAC3 = TransformAC3_C;
  762|      1|#endif
  763|      1|  VP8TransformUV = TransformUV_C;
  764|      1|  VP8TransformDCUV = TransformDCUV_C;
  765|       |
  766|      1|#if !WEBP_NEON_OMIT_C_CODE
  767|      1|  VP8VFilter16 = VFilter16_C;
  768|      1|  VP8VFilter16i = VFilter16i_C;
  769|      1|  VP8HFilter16 = HFilter16_C;
  770|      1|  VP8VFilter8 = VFilter8_C;
  771|      1|  VP8VFilter8i = VFilter8i_C;
  772|      1|  VP8SimpleVFilter16 = SimpleVFilter16_C;
  773|      1|  VP8SimpleHFilter16 = SimpleHFilter16_C;
  774|      1|  VP8SimpleVFilter16i = SimpleVFilter16i_C;
  775|      1|  VP8SimpleHFilter16i = SimpleHFilter16i_C;
  776|      1|#endif
  777|       |
  778|      1|#if !WEBP_NEON_OMIT_C_CODE || WEBP_NEON_WORK_AROUND_GCC
  779|      1|  VP8HFilter16i = HFilter16i_C;
  780|      1|  VP8HFilter8 = HFilter8_C;
  781|      1|  VP8HFilter8i = HFilter8i_C;
  782|      1|#endif
  783|       |
  784|      1|#if !WEBP_NEON_OMIT_C_CODE
  785|      1|  VP8PredLuma4[0] = DC4_C;
  786|      1|  VP8PredLuma4[1] = TM4_C;
  787|      1|  VP8PredLuma4[2] = VE4_C;
  788|      1|  VP8PredLuma4[4] = RD4_C;
  789|      1|  VP8PredLuma4[6] = LD4_C;
  790|      1|#endif
  791|       |
  792|      1|  VP8PredLuma4[3] = HE4_C;
  793|      1|  VP8PredLuma4[5] = VR4_C;
  794|      1|  VP8PredLuma4[7] = VL4_C;
  795|      1|  VP8PredLuma4[8] = HD4_C;
  796|      1|  VP8PredLuma4[9] = HU4_C;
  797|       |
  798|      1|#if !WEBP_NEON_OMIT_C_CODE
  799|      1|  VP8PredLuma16[0] = DC16_C;
  800|      1|  VP8PredLuma16[1] = TM16_C;
  801|      1|  VP8PredLuma16[2] = VE16_C;
  802|      1|  VP8PredLuma16[3] = HE16_C;
  803|      1|  VP8PredLuma16[4] = DC16NoTop_C;
  804|      1|  VP8PredLuma16[5] = DC16NoLeft_C;
  805|      1|  VP8PredLuma16[6] = DC16NoTopLeft_C;
  806|       |
  807|      1|  VP8PredChroma8[0] = DC8uv_C;
  808|      1|  VP8PredChroma8[1] = TM8uv_C;
  809|      1|  VP8PredChroma8[2] = VE8uv_C;
  810|      1|  VP8PredChroma8[3] = HE8uv_C;
  811|      1|  VP8PredChroma8[4] = DC8uvNoTop_C;
  812|      1|  VP8PredChroma8[5] = DC8uvNoLeft_C;
  813|      1|  VP8PredChroma8[6] = DC8uvNoTopLeft_C;
  814|      1|#endif
  815|       |
  816|      1|  VP8DitherCombine8x8 = DitherCombine8x8_C;
  817|       |
  818|       |  // If defined, use CPUInfo() to overwrite some pointers with faster versions.
  819|      1|  if (VP8GetCPUInfo != NULL) {
  ------------------
  |  Branch (819:7): [True: 1, False: 0]
  ------------------
  820|      1|#if defined(WEBP_HAVE_SSE2)
  821|      1|    if (VP8GetCPUInfo(kSSE2)) {
  ------------------
  |  Branch (821:9): [True: 1, False: 0]
  ------------------
  822|      1|      VP8DspInitSSE2();
  823|      1|#if defined(WEBP_HAVE_SSE41)
  824|      1|      if (VP8GetCPUInfo(kSSE4_1)) {
  ------------------
  |  Branch (824:11): [True: 1, False: 0]
  ------------------
  825|      1|        VP8DspInitSSE41();
  826|      1|      }
  827|      1|#endif
  828|      1|    }
  829|      1|#endif
  830|       |#if defined(WEBP_USE_MIPS32)
  831|       |    if (VP8GetCPUInfo(kMIPS32)) {
  832|       |      VP8DspInitMIPS32();
  833|       |    }
  834|       |#endif
  835|       |#if defined(WEBP_USE_MIPS_DSP_R2)
  836|       |    if (VP8GetCPUInfo(kMIPSdspR2)) {
  837|       |      VP8DspInitMIPSdspR2();
  838|       |    }
  839|       |#endif
  840|       |#if defined(WEBP_USE_MSA)
  841|       |    if (VP8GetCPUInfo(kMSA)) {
  842|       |      VP8DspInitMSA();
  843|       |    }
  844|       |#endif
  845|      1|  }
  846|       |
  847|       |#if defined(WEBP_HAVE_NEON)
  848|       |  if (WEBP_NEON_OMIT_C_CODE ||
  849|       |      (VP8GetCPUInfo != NULL && VP8GetCPUInfo(kNEON))) {
  850|       |    VP8DspInitNEON();
  851|       |  }
  852|       |#endif
  853|       |
  854|      1|  assert(VP8TransformWHT != NULL);
  855|      1|  assert(VP8Transform != NULL);
  856|      1|  assert(VP8TransformDC != NULL);
  857|      1|  assert(VP8TransformAC3 != NULL);
  858|      1|  assert(VP8TransformUV != NULL);
  859|      1|  assert(VP8TransformDCUV != NULL);
  860|      1|  assert(VP8VFilter16 != NULL);
  861|      1|  assert(VP8HFilter16 != NULL);
  862|      1|  assert(VP8VFilter8 != NULL);
  863|      1|  assert(VP8HFilter8 != NULL);
  864|      1|  assert(VP8VFilter16i != NULL);
  865|      1|  assert(VP8HFilter16i != NULL);
  866|      1|  assert(VP8VFilter8i != NULL);
  867|      1|  assert(VP8HFilter8i != NULL);
  868|      1|  assert(VP8SimpleVFilter16 != NULL);
  869|      1|  assert(VP8SimpleHFilter16 != NULL);
  870|      1|  assert(VP8SimpleVFilter16i != NULL);
  871|      1|  assert(VP8SimpleHFilter16i != NULL);
  872|      1|  assert(VP8PredLuma4[0] != NULL);
  873|      1|  assert(VP8PredLuma4[1] != NULL);
  874|      1|  assert(VP8PredLuma4[2] != NULL);
  875|      1|  assert(VP8PredLuma4[3] != NULL);
  876|      1|  assert(VP8PredLuma4[4] != NULL);
  877|      1|  assert(VP8PredLuma4[5] != NULL);
  878|      1|  assert(VP8PredLuma4[6] != NULL);
  879|      1|  assert(VP8PredLuma4[7] != NULL);
  880|      1|  assert(VP8PredLuma4[8] != NULL);
  881|      1|  assert(VP8PredLuma4[9] != NULL);
  882|      1|  assert(VP8PredLuma16[0] != NULL);
  883|      1|  assert(VP8PredLuma16[1] != NULL);
  884|      1|  assert(VP8PredLuma16[2] != NULL);
  885|      1|  assert(VP8PredLuma16[3] != NULL);
  886|      1|  assert(VP8PredLuma16[4] != NULL);
  887|      1|  assert(VP8PredLuma16[5] != NULL);
  888|      1|  assert(VP8PredLuma16[6] != NULL);
  889|      1|  assert(VP8PredChroma8[0] != NULL);
  890|      1|  assert(VP8PredChroma8[1] != NULL);
  891|      1|  assert(VP8PredChroma8[2] != NULL);
  892|      1|  assert(VP8PredChroma8[3] != NULL);
  893|      1|  assert(VP8PredChroma8[4] != NULL);
  894|      1|  assert(VP8PredChroma8[5] != NULL);
  895|      1|  assert(VP8PredChroma8[6] != NULL);
  896|       |  assert(VP8DitherCombine8x8 != NULL);
  897|      1|}
dec.c:TransformWHT_C:
  149|  2.56k|                           int16_t* WEBP_RESTRICT out) {
  150|  2.56k|  int tmp[16];
  151|  2.56k|  int i;
  152|  12.8k|  for (i = 0; i < 4; ++i) {
  ------------------
  |  Branch (152:15): [True: 10.2k, False: 2.56k]
  ------------------
  153|  10.2k|    const int a0 = in[0 + i] + in[12 + i];
  154|  10.2k|    const int a1 = in[4 + i] + in[8 + i];
  155|  10.2k|    const int a2 = in[4 + i] - in[8 + i];
  156|  10.2k|    const int a3 = in[0 + i] - in[12 + i];
  157|  10.2k|    tmp[0 + i] = a0 + a1;
  158|  10.2k|    tmp[8 + i] = a0 - a1;
  159|  10.2k|    tmp[4 + i] = a3 + a2;
  160|  10.2k|    tmp[12 + i] = a3 - a2;
  161|  10.2k|  }
  162|  12.8k|  for (i = 0; i < 4; ++i) {
  ------------------
  |  Branch (162:15): [True: 10.2k, False: 2.56k]
  ------------------
  163|  10.2k|    const int dc = tmp[0 + i * 4] + 3;  // w/ rounder
  164|  10.2k|    const int a0 = dc + tmp[3 + i * 4];
  165|  10.2k|    const int a1 = tmp[1 + i * 4] + tmp[2 + i * 4];
  166|  10.2k|    const int a2 = tmp[1 + i * 4] - tmp[2 + i * 4];
  167|  10.2k|    const int a3 = dc - tmp[3 + i * 4];
  168|  10.2k|    out[0] = (a0 + a1) >> 3;
  169|  10.2k|    out[16] = (a3 + a2) >> 3;
  170|  10.2k|    out[32] = (a0 - a1) >> 3;
  171|  10.2k|    out[48] = (a3 - a2) >> 3;
  172|  10.2k|    out += 64;
  173|  10.2k|  }
  174|  2.56k|}
dec.c:clip_8b:
   27|  2.00M|static WEBP_INLINE uint8_t clip_8b(int v) {
   28|  2.00M|  return (!(v & ~0xff)) ? v : (v < 0) ? 0 : 255;
  ------------------
  |  Branch (28:10): [True: 1.83M, False: 169k]
  |  Branch (28:31): [True: 89.7k, False: 79.8k]
  ------------------
   29|  2.00M|}
dec.c:TransformDC_C:
  123|   106k|                          uint8_t* WEBP_RESTRICT dst) {
  124|   106k|  const int DC = in[0] + 4;
  125|   106k|  int i, j;
  126|   534k|  for (j = 0; j < 4; ++j) {
  ------------------
  |  Branch (126:15): [True: 427k, False: 106k]
  ------------------
  127|  2.13M|    for (i = 0; i < 4; ++i) {
  ------------------
  |  Branch (127:17): [True: 1.71M, False: 427k]
  ------------------
  128|  1.71M|      STORE(i, j, DC);
  ------------------
  |  |   35|  1.71M|  dst[(x) + (y) * BPS] = clip_8b(dst[(x) + (y) * BPS] + ((v) >> 3))
  |  |  ------------------
  |  |  |  |   33|  1.71M|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  |  |                 dst[(x) + (y) * BPS] = clip_8b(dst[(x) + (y) * BPS] + ((v) >> 3))
  |  |  ------------------
  |  |  |  |   33|  1.71M|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
  129|  1.71M|    }
  130|   427k|  }
  131|   106k|}
dec.c:TransformAC3_C:
   93|  18.5k|                           uint8_t* WEBP_RESTRICT dst) {
   94|  18.5k|  const int a = in[0] + 4;
   95|  18.5k|  const int c4 = WEBP_TRANSFORM_AC3_MUL2(in[4]);
  ------------------
  |  |  244|  18.5k|#define WEBP_TRANSFORM_AC3_MUL2(a) (((a) * WEBP_TRANSFORM_AC3_C2) >> 16)
  |  |  ------------------
  |  |  |  |  242|  18.5k|#define WEBP_TRANSFORM_AC3_C2 35468
  |  |  ------------------
  ------------------
   96|  18.5k|  const int d4 = WEBP_TRANSFORM_AC3_MUL1(in[4]);
  ------------------
  |  |  243|  18.5k|#define WEBP_TRANSFORM_AC3_MUL1(a) ((((a) * WEBP_TRANSFORM_AC3_C1) >> 16) + (a))
  |  |  ------------------
  |  |  |  |  241|  18.5k|#define WEBP_TRANSFORM_AC3_C1 20091
  |  |  ------------------
  ------------------
   97|  18.5k|  const int c1 = WEBP_TRANSFORM_AC3_MUL2(in[1]);
  ------------------
  |  |  244|  18.5k|#define WEBP_TRANSFORM_AC3_MUL2(a) (((a) * WEBP_TRANSFORM_AC3_C2) >> 16)
  |  |  ------------------
  |  |  |  |  242|  18.5k|#define WEBP_TRANSFORM_AC3_C2 35468
  |  |  ------------------
  ------------------
   98|  18.5k|  const int d1 = WEBP_TRANSFORM_AC3_MUL1(in[1]);
  ------------------
  |  |  243|  18.5k|#define WEBP_TRANSFORM_AC3_MUL1(a) ((((a) * WEBP_TRANSFORM_AC3_C1) >> 16) + (a))
  |  |  ------------------
  |  |  |  |  241|  18.5k|#define WEBP_TRANSFORM_AC3_C1 20091
  |  |  ------------------
  ------------------
   99|  18.5k|  STORE2(0, a + d4, d1, c1);
  ------------------
  |  |   38|  18.5k|  do {                      \
  |  |   39|  18.5k|    const int DC = (dc);    \
  |  |   40|  18.5k|    STORE(0, y, DC + (d));  \
  |  |  ------------------
  |  |  |  |   35|  18.5k|  dst[(x) + (y) * BPS] = clip_8b(dst[(x) + (y) * BPS] + ((v) >> 3))
  |  |  |  |  ------------------
  |  |  |  |  |  |   33|  18.5k|#define BPS 32  // this is the common stride for enc/dec
  |  |  |  |  ------------------
  |  |  |  |                 dst[(x) + (y) * BPS] = clip_8b(dst[(x) + (y) * BPS] + ((v) >> 3))
  |  |  |  |  ------------------
  |  |  |  |  |  |   33|  18.5k|#define BPS 32  // this is the common stride for enc/dec
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   41|  18.5k|    STORE(1, y, DC + (c));  \
  |  |  ------------------
  |  |  |  |   35|  18.5k|  dst[(x) + (y) * BPS] = clip_8b(dst[(x) + (y) * BPS] + ((v) >> 3))
  |  |  |  |  ------------------
  |  |  |  |  |  |   33|  18.5k|#define BPS 32  // this is the common stride for enc/dec
  |  |  |  |  ------------------
  |  |  |  |                 dst[(x) + (y) * BPS] = clip_8b(dst[(x) + (y) * BPS] + ((v) >> 3))
  |  |  |  |  ------------------
  |  |  |  |  |  |   33|  18.5k|#define BPS 32  // this is the common stride for enc/dec
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   42|  18.5k|    STORE(2, y, DC - (c));  \
  |  |  ------------------
  |  |  |  |   35|  18.5k|  dst[(x) + (y) * BPS] = clip_8b(dst[(x) + (y) * BPS] + ((v) >> 3))
  |  |  |  |  ------------------
  |  |  |  |  |  |   33|  18.5k|#define BPS 32  // this is the common stride for enc/dec
  |  |  |  |  ------------------
  |  |  |  |                 dst[(x) + (y) * BPS] = clip_8b(dst[(x) + (y) * BPS] + ((v) >> 3))
  |  |  |  |  ------------------
  |  |  |  |  |  |   33|  18.5k|#define BPS 32  // this is the common stride for enc/dec
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   43|  18.5k|    STORE(3, y, DC - (d));  \
  |  |  ------------------
  |  |  |  |   35|  18.5k|  dst[(x) + (y) * BPS] = clip_8b(dst[(x) + (y) * BPS] + ((v) >> 3))
  |  |  |  |  ------------------
  |  |  |  |  |  |   33|  18.5k|#define BPS 32  // this is the common stride for enc/dec
  |  |  |  |  ------------------
  |  |  |  |                 dst[(x) + (y) * BPS] = clip_8b(dst[(x) + (y) * BPS] + ((v) >> 3))
  |  |  |  |  ------------------
  |  |  |  |  |  |   33|  18.5k|#define BPS 32  // this is the common stride for enc/dec
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   44|  18.5k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (44:12): [Folded, False: 18.5k]
  |  |  ------------------
  ------------------
  100|  18.5k|  STORE2(1, a + c4, d1, c1);
  ------------------
  |  |   38|  18.5k|  do {                      \
  |  |   39|  18.5k|    const int DC = (dc);    \
  |  |   40|  18.5k|    STORE(0, y, DC + (d));  \
  |  |  ------------------
  |  |  |  |   35|  18.5k|  dst[(x) + (y) * BPS] = clip_8b(dst[(x) + (y) * BPS] + ((v) >> 3))
  |  |  |  |  ------------------
  |  |  |  |  |  |   33|  18.5k|#define BPS 32  // this is the common stride for enc/dec
  |  |  |  |  ------------------
  |  |  |  |                 dst[(x) + (y) * BPS] = clip_8b(dst[(x) + (y) * BPS] + ((v) >> 3))
  |  |  |  |  ------------------
  |  |  |  |  |  |   33|  18.5k|#define BPS 32  // this is the common stride for enc/dec
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   41|  18.5k|    STORE(1, y, DC + (c));  \
  |  |  ------------------
  |  |  |  |   35|  18.5k|  dst[(x) + (y) * BPS] = clip_8b(dst[(x) + (y) * BPS] + ((v) >> 3))
  |  |  |  |  ------------------
  |  |  |  |  |  |   33|  18.5k|#define BPS 32  // this is the common stride for enc/dec
  |  |  |  |  ------------------
  |  |  |  |                 dst[(x) + (y) * BPS] = clip_8b(dst[(x) + (y) * BPS] + ((v) >> 3))
  |  |  |  |  ------------------
  |  |  |  |  |  |   33|  18.5k|#define BPS 32  // this is the common stride for enc/dec
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   42|  18.5k|    STORE(2, y, DC - (c));  \
  |  |  ------------------
  |  |  |  |   35|  18.5k|  dst[(x) + (y) * BPS] = clip_8b(dst[(x) + (y) * BPS] + ((v) >> 3))
  |  |  |  |  ------------------
  |  |  |  |  |  |   33|  18.5k|#define BPS 32  // this is the common stride for enc/dec
  |  |  |  |  ------------------
  |  |  |  |                 dst[(x) + (y) * BPS] = clip_8b(dst[(x) + (y) * BPS] + ((v) >> 3))
  |  |  |  |  ------------------
  |  |  |  |  |  |   33|  18.5k|#define BPS 32  // this is the common stride for enc/dec
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   43|  18.5k|    STORE(3, y, DC - (d));  \
  |  |  ------------------
  |  |  |  |   35|  18.5k|  dst[(x) + (y) * BPS] = clip_8b(dst[(x) + (y) * BPS] + ((v) >> 3))
  |  |  |  |  ------------------
  |  |  |  |  |  |   33|  18.5k|#define BPS 32  // this is the common stride for enc/dec
  |  |  |  |  ------------------
  |  |  |  |                 dst[(x) + (y) * BPS] = clip_8b(dst[(x) + (y) * BPS] + ((v) >> 3))
  |  |  |  |  ------------------
  |  |  |  |  |  |   33|  18.5k|#define BPS 32  // this is the common stride for enc/dec
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   44|  18.5k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (44:12): [Folded, False: 18.5k]
  |  |  ------------------
  ------------------
  101|  18.5k|  STORE2(2, a - c4, d1, c1);
  ------------------
  |  |   38|  18.5k|  do {                      \
  |  |   39|  18.5k|    const int DC = (dc);    \
  |  |   40|  18.5k|    STORE(0, y, DC + (d));  \
  |  |  ------------------
  |  |  |  |   35|  18.5k|  dst[(x) + (y) * BPS] = clip_8b(dst[(x) + (y) * BPS] + ((v) >> 3))
  |  |  |  |  ------------------
  |  |  |  |  |  |   33|  18.5k|#define BPS 32  // this is the common stride for enc/dec
  |  |  |  |  ------------------
  |  |  |  |                 dst[(x) + (y) * BPS] = clip_8b(dst[(x) + (y) * BPS] + ((v) >> 3))
  |  |  |  |  ------------------
  |  |  |  |  |  |   33|  18.5k|#define BPS 32  // this is the common stride for enc/dec
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   41|  18.5k|    STORE(1, y, DC + (c));  \
  |  |  ------------------
  |  |  |  |   35|  18.5k|  dst[(x) + (y) * BPS] = clip_8b(dst[(x) + (y) * BPS] + ((v) >> 3))
  |  |  |  |  ------------------
  |  |  |  |  |  |   33|  18.5k|#define BPS 32  // this is the common stride for enc/dec
  |  |  |  |  ------------------
  |  |  |  |                 dst[(x) + (y) * BPS] = clip_8b(dst[(x) + (y) * BPS] + ((v) >> 3))
  |  |  |  |  ------------------
  |  |  |  |  |  |   33|  18.5k|#define BPS 32  // this is the common stride for enc/dec
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   42|  18.5k|    STORE(2, y, DC - (c));  \
  |  |  ------------------
  |  |  |  |   35|  18.5k|  dst[(x) + (y) * BPS] = clip_8b(dst[(x) + (y) * BPS] + ((v) >> 3))
  |  |  |  |  ------------------
  |  |  |  |  |  |   33|  18.5k|#define BPS 32  // this is the common stride for enc/dec
  |  |  |  |  ------------------
  |  |  |  |                 dst[(x) + (y) * BPS] = clip_8b(dst[(x) + (y) * BPS] + ((v) >> 3))
  |  |  |  |  ------------------
  |  |  |  |  |  |   33|  18.5k|#define BPS 32  // this is the common stride for enc/dec
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   43|  18.5k|    STORE(3, y, DC - (d));  \
  |  |  ------------------
  |  |  |  |   35|  18.5k|  dst[(x) + (y) * BPS] = clip_8b(dst[(x) + (y) * BPS] + ((v) >> 3))
  |  |  |  |  ------------------
  |  |  |  |  |  |   33|  18.5k|#define BPS 32  // this is the common stride for enc/dec
  |  |  |  |  ------------------
  |  |  |  |                 dst[(x) + (y) * BPS] = clip_8b(dst[(x) + (y) * BPS] + ((v) >> 3))
  |  |  |  |  ------------------
  |  |  |  |  |  |   33|  18.5k|#define BPS 32  // this is the common stride for enc/dec
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   44|  18.5k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (44:12): [Folded, False: 18.5k]
  |  |  ------------------
  ------------------
  102|  18.5k|  STORE2(3, a - d4, d1, c1);
  ------------------
  |  |   38|  18.5k|  do {                      \
  |  |   39|  18.5k|    const int DC = (dc);    \
  |  |   40|  18.5k|    STORE(0, y, DC + (d));  \
  |  |  ------------------
  |  |  |  |   35|  18.5k|  dst[(x) + (y) * BPS] = clip_8b(dst[(x) + (y) * BPS] + ((v) >> 3))
  |  |  |  |  ------------------
  |  |  |  |  |  |   33|  18.5k|#define BPS 32  // this is the common stride for enc/dec
  |  |  |  |  ------------------
  |  |  |  |                 dst[(x) + (y) * BPS] = clip_8b(dst[(x) + (y) * BPS] + ((v) >> 3))
  |  |  |  |  ------------------
  |  |  |  |  |  |   33|  18.5k|#define BPS 32  // this is the common stride for enc/dec
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   41|  18.5k|    STORE(1, y, DC + (c));  \
  |  |  ------------------
  |  |  |  |   35|  18.5k|  dst[(x) + (y) * BPS] = clip_8b(dst[(x) + (y) * BPS] + ((v) >> 3))
  |  |  |  |  ------------------
  |  |  |  |  |  |   33|  18.5k|#define BPS 32  // this is the common stride for enc/dec
  |  |  |  |  ------------------
  |  |  |  |                 dst[(x) + (y) * BPS] = clip_8b(dst[(x) + (y) * BPS] + ((v) >> 3))
  |  |  |  |  ------------------
  |  |  |  |  |  |   33|  18.5k|#define BPS 32  // this is the common stride for enc/dec
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   42|  18.5k|    STORE(2, y, DC - (c));  \
  |  |  ------------------
  |  |  |  |   35|  18.5k|  dst[(x) + (y) * BPS] = clip_8b(dst[(x) + (y) * BPS] + ((v) >> 3))
  |  |  |  |  ------------------
  |  |  |  |  |  |   33|  18.5k|#define BPS 32  // this is the common stride for enc/dec
  |  |  |  |  ------------------
  |  |  |  |                 dst[(x) + (y) * BPS] = clip_8b(dst[(x) + (y) * BPS] + ((v) >> 3))
  |  |  |  |  ------------------
  |  |  |  |  |  |   33|  18.5k|#define BPS 32  // this is the common stride for enc/dec
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   43|  18.5k|    STORE(3, y, DC - (d));  \
  |  |  ------------------
  |  |  |  |   35|  18.5k|  dst[(x) + (y) * BPS] = clip_8b(dst[(x) + (y) * BPS] + ((v) >> 3))
  |  |  |  |  ------------------
  |  |  |  |  |  |   33|  18.5k|#define BPS 32  // this is the common stride for enc/dec
  |  |  |  |  ------------------
  |  |  |  |                 dst[(x) + (y) * BPS] = clip_8b(dst[(x) + (y) * BPS] + ((v) >> 3))
  |  |  |  |  ------------------
  |  |  |  |  |  |   33|  18.5k|#define BPS 32  // this is the common stride for enc/dec
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   44|  18.5k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (44:12): [Folded, False: 18.5k]
  |  |  ------------------
  ------------------
  103|  18.5k|}
dec.c:TransformUV_C:
  116|  12.7k|                          uint8_t* WEBP_RESTRICT dst) {
  117|  12.7k|  VP8Transform(in + 0 * 16, dst, 1);
  118|  12.7k|  VP8Transform(in + 2 * 16, dst + 4 * BPS, 1);
  ------------------
  |  |   33|  12.7k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  119|  12.7k|}
dec.c:TransformDCUV_C:
  135|  10.8k|                            uint8_t* WEBP_RESTRICT dst) {
  136|  10.8k|  if (in[0 * 16]) VP8TransformDC(in + 0 * 16, dst);
  ------------------
  |  Branch (136:7): [True: 5.14k, False: 5.74k]
  ------------------
  137|  10.8k|  if (in[1 * 16]) VP8TransformDC(in + 1 * 16, dst + 4);
  ------------------
  |  Branch (137:7): [True: 5.21k, False: 5.67k]
  ------------------
  138|  10.8k|  if (in[2 * 16]) VP8TransformDC(in + 2 * 16, dst + 4 * BPS);
  ------------------
  |  |   33|  4.97k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  |  Branch (138:7): [True: 4.97k, False: 5.91k]
  ------------------
  139|  10.8k|  if (in[3 * 16]) VP8TransformDC(in + 3 * 16, dst + 4 * BPS + 4);
  ------------------
  |  |   33|  5.49k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  |  Branch (139:7): [True: 5.49k, False: 5.40k]
  ------------------
  140|  10.8k|}
dec.c:DC4_C:
  296|   244k|static void DC4_C(uint8_t* dst) {  // DC
  297|   244k|  uint32_t dc = 4;
  298|   244k|  int i;
  299|  1.22M|  for (i = 0; i < 4; ++i) dc += dst[i - BPS] + dst[-1 + i * BPS];
  ------------------
  |  |   33|   978k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
                for (i = 0; i < 4; ++i) dc += dst[i - BPS] + dst[-1 + i * BPS];
  ------------------
  |  |   33|   978k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  |  Branch (299:15): [True: 978k, False: 244k]
  ------------------
  300|   244k|  dc >>= 3;
  301|  1.22M|  for (i = 0; i < 4; ++i) memset(dst + i * BPS, dc, 4);
  ------------------
  |  |   33|   978k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  |  Branch (301:15): [True: 978k, False: 244k]
  ------------------
  302|   244k|}
dec.c:HE4_C:
  283|  6.49k|static void HE4_C(uint8_t* dst) {  // horizontal
  284|  6.49k|  const int A = dst[-1 - BPS];
  ------------------
  |  |   33|  6.49k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  285|  6.49k|  const int B = dst[-1];
  286|  6.49k|  const int C = dst[-1 + BPS];
  ------------------
  |  |   33|  6.49k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  287|  6.49k|  const int D = dst[-1 + 2 * BPS];
  ------------------
  |  |   33|  6.49k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  288|  6.49k|  const int E = dst[-1 + 3 * BPS];
  ------------------
  |  |   33|  6.49k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  289|  6.49k|  WebPUint32ToMem(dst + 0 * BPS, 0x01010101U * AVG3(A, B, C));
  ------------------
  |  |   33|  6.49k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
                WebPUint32ToMem(dst + 0 * BPS, 0x01010101U * AVG3(A, B, C));
  ------------------
  |  |  264|  6.49k|#define AVG3(a, b, c) ((uint8_t)(((a) + 2 * (b) + (c) + 2) >> 2))
  ------------------
  290|  6.49k|  WebPUint32ToMem(dst + 1 * BPS, 0x01010101U * AVG3(B, C, D));
  ------------------
  |  |   33|  6.49k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
                WebPUint32ToMem(dst + 1 * BPS, 0x01010101U * AVG3(B, C, D));
  ------------------
  |  |  264|  6.49k|#define AVG3(a, b, c) ((uint8_t)(((a) + 2 * (b) + (c) + 2) >> 2))
  ------------------
  291|  6.49k|  WebPUint32ToMem(dst + 2 * BPS, 0x01010101U * AVG3(C, D, E));
  ------------------
  |  |   33|  6.49k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
                WebPUint32ToMem(dst + 2 * BPS, 0x01010101U * AVG3(C, D, E));
  ------------------
  |  |  264|  6.49k|#define AVG3(a, b, c) ((uint8_t)(((a) + 2 * (b) + (c) + 2) >> 2))
  ------------------
  292|  6.49k|  WebPUint32ToMem(dst + 3 * BPS, 0x01010101U * AVG3(D, E, E));
  ------------------
  |  |   33|  6.49k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
                WebPUint32ToMem(dst + 3 * BPS, 0x01010101U * AVG3(D, E, E));
  ------------------
  |  |  264|  6.49k|#define AVG3(a, b, c) ((uint8_t)(((a) + 2 * (b) + (c) + 2) >> 2))
  ------------------
  293|  6.49k|}
dec.c:HD4_C:
  400|  2.89k|static void HD4_C(uint8_t* dst) {  // Horizontal-Down
  401|  2.89k|  const int I = dst[-1 + 0 * BPS];
  ------------------
  |  |   33|  2.89k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  402|  2.89k|  const int J = dst[-1 + 1 * BPS];
  ------------------
  |  |   33|  2.89k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  403|  2.89k|  const int K = dst[-1 + 2 * BPS];
  ------------------
  |  |   33|  2.89k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  404|  2.89k|  const int L = dst[-1 + 3 * BPS];
  ------------------
  |  |   33|  2.89k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  405|  2.89k|  const int X = dst[-1 - BPS];
  ------------------
  |  |   33|  2.89k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  406|  2.89k|  const int A = dst[0 - BPS];
  ------------------
  |  |   33|  2.89k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  407|  2.89k|  const int B = dst[1 - BPS];
  ------------------
  |  |   33|  2.89k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  408|  2.89k|  const int C = dst[2 - BPS];
  ------------------
  |  |   33|  2.89k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  409|       |
  410|  2.89k|  DST(0, 0) = DST(2, 1) = AVG2(I, X);
  ------------------
  |  |  182|  2.89k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  2.89k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(0, 0) = DST(2, 1) = AVG2(I, X);
  ------------------
  |  |  182|  2.89k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  2.89k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(0, 0) = DST(2, 1) = AVG2(I, X);
  ------------------
  |  |  265|  2.89k|#define AVG2(a, b) (((a) + (b) + 1) >> 1)
  ------------------
  411|  2.89k|  DST(0, 1) = DST(2, 2) = AVG2(J, I);
  ------------------
  |  |  182|  2.89k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  2.89k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(0, 1) = DST(2, 2) = AVG2(J, I);
  ------------------
  |  |  182|  2.89k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  2.89k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(0, 1) = DST(2, 2) = AVG2(J, I);
  ------------------
  |  |  265|  2.89k|#define AVG2(a, b) (((a) + (b) + 1) >> 1)
  ------------------
  412|  2.89k|  DST(0, 2) = DST(2, 3) = AVG2(K, J);
  ------------------
  |  |  182|  2.89k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  2.89k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(0, 2) = DST(2, 3) = AVG2(K, J);
  ------------------
  |  |  182|  2.89k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  2.89k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(0, 2) = DST(2, 3) = AVG2(K, J);
  ------------------
  |  |  265|  2.89k|#define AVG2(a, b) (((a) + (b) + 1) >> 1)
  ------------------
  413|  2.89k|  DST(0, 3) = AVG2(L, K);
  ------------------
  |  |  182|  2.89k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  2.89k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(0, 3) = AVG2(L, K);
  ------------------
  |  |  265|  2.89k|#define AVG2(a, b) (((a) + (b) + 1) >> 1)
  ------------------
  414|       |
  415|  2.89k|  DST(3, 0) = AVG3(A, B, C);
  ------------------
  |  |  182|  2.89k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  2.89k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(3, 0) = AVG3(A, B, C);
  ------------------
  |  |  264|  2.89k|#define AVG3(a, b, c) ((uint8_t)(((a) + 2 * (b) + (c) + 2) >> 2))
  ------------------
  416|  2.89k|  DST(2, 0) = AVG3(X, A, B);
  ------------------
  |  |  182|  2.89k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  2.89k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(2, 0) = AVG3(X, A, B);
  ------------------
  |  |  264|  2.89k|#define AVG3(a, b, c) ((uint8_t)(((a) + 2 * (b) + (c) + 2) >> 2))
  ------------------
  417|  2.89k|  DST(1, 0) = DST(3, 1) = AVG3(I, X, A);
  ------------------
  |  |  182|  2.89k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  2.89k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(1, 0) = DST(3, 1) = AVG3(I, X, A);
  ------------------
  |  |  182|  2.89k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  2.89k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(1, 0) = DST(3, 1) = AVG3(I, X, A);
  ------------------
  |  |  264|  2.89k|#define AVG3(a, b, c) ((uint8_t)(((a) + 2 * (b) + (c) + 2) >> 2))
  ------------------
  418|  2.89k|  DST(1, 1) = DST(3, 2) = AVG3(J, I, X);
  ------------------
  |  |  182|  2.89k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  2.89k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(1, 1) = DST(3, 2) = AVG3(J, I, X);
  ------------------
  |  |  182|  2.89k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  2.89k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(1, 1) = DST(3, 2) = AVG3(J, I, X);
  ------------------
  |  |  264|  2.89k|#define AVG3(a, b, c) ((uint8_t)(((a) + 2 * (b) + (c) + 2) >> 2))
  ------------------
  419|  2.89k|  DST(1, 2) = DST(3, 3) = AVG3(K, J, I);
  ------------------
  |  |  182|  2.89k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  2.89k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(1, 2) = DST(3, 3) = AVG3(K, J, I);
  ------------------
  |  |  182|  2.89k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  2.89k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(1, 2) = DST(3, 3) = AVG3(K, J, I);
  ------------------
  |  |  264|  2.89k|#define AVG3(a, b, c) ((uint8_t)(((a) + 2 * (b) + (c) + 2) >> 2))
  ------------------
  420|  2.89k|  DST(1, 3) = AVG3(L, K, J);
  ------------------
  |  |  182|  2.89k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  2.89k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(1, 3) = AVG3(L, K, J);
  ------------------
  |  |  264|  2.89k|#define AVG3(a, b, c) ((uint8_t)(((a) + 2 * (b) + (c) + 2) >> 2))
  ------------------
  421|  2.89k|}
dec.c:HU4_C:
  386|  4.87k|static void HU4_C(uint8_t* dst) {  // Horizontal-Up
  387|  4.87k|  const int I = dst[-1 + 0 * BPS];
  ------------------
  |  |   33|  4.87k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  388|  4.87k|  const int J = dst[-1 + 1 * BPS];
  ------------------
  |  |   33|  4.87k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  389|  4.87k|  const int K = dst[-1 + 2 * BPS];
  ------------------
  |  |   33|  4.87k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  390|  4.87k|  const int L = dst[-1 + 3 * BPS];
  ------------------
  |  |   33|  4.87k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  391|  4.87k|  DST(0, 0) = AVG2(I, J);
  ------------------
  |  |  182|  4.87k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  4.87k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(0, 0) = AVG2(I, J);
  ------------------
  |  |  265|  4.87k|#define AVG2(a, b) (((a) + (b) + 1) >> 1)
  ------------------
  392|  4.87k|  DST(2, 0) = DST(0, 1) = AVG2(J, K);
  ------------------
  |  |  182|  4.87k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  4.87k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(2, 0) = DST(0, 1) = AVG2(J, K);
  ------------------
  |  |  182|  4.87k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  4.87k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(2, 0) = DST(0, 1) = AVG2(J, K);
  ------------------
  |  |  265|  4.87k|#define AVG2(a, b) (((a) + (b) + 1) >> 1)
  ------------------
  393|  4.87k|  DST(2, 1) = DST(0, 2) = AVG2(K, L);
  ------------------
  |  |  182|  4.87k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  4.87k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(2, 1) = DST(0, 2) = AVG2(K, L);
  ------------------
  |  |  182|  4.87k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  4.87k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(2, 1) = DST(0, 2) = AVG2(K, L);
  ------------------
  |  |  265|  4.87k|#define AVG2(a, b) (((a) + (b) + 1) >> 1)
  ------------------
  394|  4.87k|  DST(1, 0) = AVG3(I, J, K);
  ------------------
  |  |  182|  4.87k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  4.87k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(1, 0) = AVG3(I, J, K);
  ------------------
  |  |  264|  4.87k|#define AVG3(a, b, c) ((uint8_t)(((a) + 2 * (b) + (c) + 2) >> 2))
  ------------------
  395|  4.87k|  DST(3, 0) = DST(1, 1) = AVG3(J, K, L);
  ------------------
  |  |  182|  4.87k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  4.87k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(3, 0) = DST(1, 1) = AVG3(J, K, L);
  ------------------
  |  |  182|  4.87k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  4.87k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(3, 0) = DST(1, 1) = AVG3(J, K, L);
  ------------------
  |  |  264|  4.87k|#define AVG3(a, b, c) ((uint8_t)(((a) + 2 * (b) + (c) + 2) >> 2))
  ------------------
  396|  4.87k|  DST(3, 1) = DST(1, 2) = AVG3(K, L, L);
  ------------------
  |  |  182|  4.87k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  4.87k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(3, 1) = DST(1, 2) = AVG3(K, L, L);
  ------------------
  |  |  182|  4.87k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  4.87k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(3, 1) = DST(1, 2) = AVG3(K, L, L);
  ------------------
  |  |  264|  4.87k|#define AVG3(a, b, c) ((uint8_t)(((a) + 2 * (b) + (c) + 2) >> 2))
  ------------------
  397|  4.87k|  DST(3, 2) = DST(2, 2) = DST(0, 3) = DST(1, 3) = DST(2, 3) = DST(3, 3) = L;
  ------------------
  |  |  182|  4.87k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  4.87k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(3, 2) = DST(2, 2) = DST(0, 3) = DST(1, 3) = DST(2, 3) = DST(3, 3) = L;
  ------------------
  |  |  182|  4.87k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  4.87k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(3, 2) = DST(2, 2) = DST(0, 3) = DST(1, 3) = DST(2, 3) = DST(3, 3) = L;
  ------------------
  |  |  182|  4.87k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  4.87k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(3, 2) = DST(2, 2) = DST(0, 3) = DST(1, 3) = DST(2, 3) = DST(3, 3) = L;
  ------------------
  |  |  182|  4.87k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  4.87k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(3, 2) = DST(2, 2) = DST(0, 3) = DST(1, 3) = DST(2, 3) = DST(3, 3) = L;
  ------------------
  |  |  182|  4.87k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  4.87k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(3, 2) = DST(2, 2) = DST(0, 3) = DST(1, 3) = DST(2, 3) = DST(3, 3) = L;
  ------------------
  |  |  182|  4.87k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  4.87k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
  398|  4.87k|}
dec.c:HE8uv_C:
  440|  13.5k|static void HE8uv_C(uint8_t* dst) {  // horizontal
  441|  13.5k|  int j;
  442|   121k|  for (j = 0; j < 8; ++j) {
  ------------------
  |  Branch (442:15): [True: 108k, False: 13.5k]
  ------------------
  443|   108k|    memset(dst, dst[-1], 8);
  444|   108k|    dst += BPS;
  ------------------
  |  |   33|   108k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  445|   108k|  }
  446|  13.5k|}

VP8InitClipTables:
  327|      1|WEBP_TSAN_IGNORE_FUNCTION void VP8InitClipTables(void) {
  328|       |#if (USE_STATIC_TABLES == 0)
  329|       |  int i;
  330|       |  if (!tables_ok) {
  331|       |    for (i = -255; i <= 255; ++i) {
  332|       |      abs0[255 + i] = (i < 0) ? -i : i;
  333|       |    }
  334|       |    for (i = -893; i <= 892; ++i) {
  335|       |      sclip1[893 + i] = (i < -128) ? -128 : (i > 127) ? 127 : i;
  336|       |    }
  337|       |    for (i = -112; i <= 112; ++i) {
  338|       |      sclip2[112 + i] = (i < -16) ? -16 : (i > 15) ? 15 : i;
  339|       |    }
  340|       |    for (i = -255; i <= 511; ++i) {
  341|       |      clip1[255 + i] = (i < 0) ? 0 : (i > 255) ? 255 : i;
  342|       |    }
  343|       |    tables_ok = 1;
  344|       |  }
  345|       |#endif  // USE_STATIC_TABLES
  346|      1|}

VP8DspInitSSE2:
 1190|      1|WEBP_TSAN_IGNORE_FUNCTION void VP8DspInitSSE2(void) {
 1191|      1|  VP8Transform = Transform_SSE2;
 1192|       |#if (USE_TRANSFORM_AC3 == 1)
 1193|       |  VP8TransformAC3 = TransformAC3_SSE2;
 1194|       |#endif
 1195|       |
 1196|      1|  VP8VFilter16 = VFilter16_SSE2;
 1197|      1|  VP8HFilter16 = HFilter16_SSE2;
 1198|      1|  VP8VFilter8 = VFilter8_SSE2;
 1199|      1|  VP8HFilter8 = HFilter8_SSE2;
 1200|      1|  VP8VFilter16i = VFilter16i_SSE2;
 1201|      1|  VP8HFilter16i = HFilter16i_SSE2;
 1202|      1|  VP8VFilter8i = VFilter8i_SSE2;
 1203|      1|  VP8HFilter8i = HFilter8i_SSE2;
 1204|       |
 1205|      1|  VP8SimpleVFilter16 = SimpleVFilter16_SSE2;
 1206|      1|  VP8SimpleHFilter16 = SimpleHFilter16_SSE2;
 1207|      1|  VP8SimpleVFilter16i = SimpleVFilter16i_SSE2;
 1208|      1|  VP8SimpleHFilter16i = SimpleHFilter16i_SSE2;
 1209|       |
 1210|      1|  VP8PredLuma4[1] = TM4_SSE2;
 1211|      1|  VP8PredLuma4[2] = VE4_SSE2;
 1212|      1|  VP8PredLuma4[4] = RD4_SSE2;
 1213|      1|  VP8PredLuma4[5] = VR4_SSE2;
 1214|      1|  VP8PredLuma4[6] = LD4_SSE2;
 1215|      1|  VP8PredLuma4[7] = VL4_SSE2;
 1216|       |
 1217|      1|  VP8PredLuma16[0] = DC16_SSE2;
 1218|      1|  VP8PredLuma16[1] = TM16_SSE2;
 1219|      1|  VP8PredLuma16[2] = VE16_SSE2;
 1220|      1|  VP8PredLuma16[3] = HE16_SSE2;
 1221|      1|  VP8PredLuma16[4] = DC16NoTop_SSE2;
 1222|      1|  VP8PredLuma16[5] = DC16NoLeft_SSE2;
 1223|      1|  VP8PredLuma16[6] = DC16NoTopLeft_SSE2;
 1224|       |
 1225|      1|  VP8PredChroma8[0] = DC8uv_SSE2;
 1226|      1|  VP8PredChroma8[1] = TM8uv_SSE2;
 1227|      1|  VP8PredChroma8[2] = VE8uv_SSE2;
 1228|      1|  VP8PredChroma8[4] = DC8uvNoTop_SSE2;
 1229|      1|  VP8PredChroma8[5] = DC8uvNoLeft_SSE2;
 1230|      1|  VP8PredChroma8[6] = DC8uvNoTopLeft_SSE2;
 1231|      1|}
dec_sse2.c:Transform_SSE2:
   37|  40.3k|                           uint8_t* WEBP_RESTRICT dst, int do_two) {
   38|       |  // This implementation makes use of 16-bit fixed point versions of two
   39|       |  // multiply constants:
   40|       |  //    K1 = sqrt(2) * cos (pi/8) ~= 85627 / 2^16
   41|       |  //    K2 = sqrt(2) * sin (pi/8) ~= 35468 / 2^16
   42|       |  //
   43|       |  // To be able to use signed 16-bit integers, we use the following trick to
   44|       |  // have constants within range:
   45|       |  // - Associated constants are obtained by subtracting the 16-bit fixed point
   46|       |  //   version of one:
   47|       |  //      k = K - (1 << 16)  =>  K = k + (1 << 16)
   48|       |  //      K1 = 85627  =>  k1 =  20091
   49|       |  //      K2 = 35468  =>  k2 = -30068
   50|       |  // - The multiplication of a variable by a constant become the sum of the
   51|       |  //   variable and the multiplication of that variable by the associated
   52|       |  //   constant:
   53|       |  //      (x * K) >> 16 = (x * (k + (1 << 16))) >> 16 = ((x * k ) >> 16) + x
   54|  40.3k|  const __m128i k1 = _mm_set1_epi16(20091);
   55|  40.3k|  const __m128i k2 = _mm_set1_epi16(-30068);
   56|  40.3k|  __m128i T0, T1, T2, T3;
   57|       |
   58|       |  // Load and concatenate the transform coefficients (we'll do two transforms
   59|       |  // in parallel). In the case of only one transform, the second half of the
   60|       |  // vectors will just contain random value we'll never use nor store.
   61|  40.3k|  __m128i in0, in1, in2, in3;
   62|  40.3k|  {
   63|  40.3k|    in0 = _mm_loadl_epi64((const __m128i*)&in[0]);
   64|  40.3k|    in1 = _mm_loadl_epi64((const __m128i*)&in[4]);
   65|  40.3k|    in2 = _mm_loadl_epi64((const __m128i*)&in[8]);
   66|  40.3k|    in3 = _mm_loadl_epi64((const __m128i*)&in[12]);
   67|       |    // a00 a10 a20 a30   x x x x
   68|       |    // a01 a11 a21 a31   x x x x
   69|       |    // a02 a12 a22 a32   x x x x
   70|       |    // a03 a13 a23 a33   x x x x
   71|  40.3k|    if (do_two) {
  ------------------
  |  Branch (71:9): [True: 25.4k, False: 14.9k]
  ------------------
   72|  25.4k|      const __m128i inB0 = _mm_loadl_epi64((const __m128i*)&in[16]);
   73|  25.4k|      const __m128i inB1 = _mm_loadl_epi64((const __m128i*)&in[20]);
   74|  25.4k|      const __m128i inB2 = _mm_loadl_epi64((const __m128i*)&in[24]);
   75|  25.4k|      const __m128i inB3 = _mm_loadl_epi64((const __m128i*)&in[28]);
   76|  25.4k|      in0 = _mm_unpacklo_epi64(in0, inB0);
   77|  25.4k|      in1 = _mm_unpacklo_epi64(in1, inB1);
   78|  25.4k|      in2 = _mm_unpacklo_epi64(in2, inB2);
   79|  25.4k|      in3 = _mm_unpacklo_epi64(in3, inB3);
   80|       |      // a00 a10 a20 a30   b00 b10 b20 b30
   81|       |      // a01 a11 a21 a31   b01 b11 b21 b31
   82|       |      // a02 a12 a22 a32   b02 b12 b22 b32
   83|       |      // a03 a13 a23 a33   b03 b13 b23 b33
   84|  25.4k|    }
   85|  40.3k|  }
   86|       |
   87|       |  // Vertical pass and subsequent transpose.
   88|  40.3k|  {
   89|       |    // First pass, c and d calculations are longer because of the "trick"
   90|       |    // multiplications.
   91|  40.3k|    const __m128i a = _mm_add_epi16(in0, in2);
   92|  40.3k|    const __m128i b = _mm_sub_epi16(in0, in2);
   93|       |    // c = MUL(in1, K2) - MUL(in3, K1) = MUL(in1, k2) - MUL(in3, k1) + in1 - in3
   94|  40.3k|    const __m128i c1 = _mm_mulhi_epi16(in1, k2);
   95|  40.3k|    const __m128i c2 = _mm_mulhi_epi16(in3, k1);
   96|  40.3k|    const __m128i c3 = _mm_sub_epi16(in1, in3);
   97|  40.3k|    const __m128i c4 = _mm_sub_epi16(c1, c2);
   98|  40.3k|    const __m128i c = _mm_add_epi16(c3, c4);
   99|       |    // d = MUL(in1, K1) + MUL(in3, K2) = MUL(in1, k1) + MUL(in3, k2) + in1 + in3
  100|  40.3k|    const __m128i d1 = _mm_mulhi_epi16(in1, k1);
  101|  40.3k|    const __m128i d2 = _mm_mulhi_epi16(in3, k2);
  102|  40.3k|    const __m128i d3 = _mm_add_epi16(in1, in3);
  103|  40.3k|    const __m128i d4 = _mm_add_epi16(d1, d2);
  104|  40.3k|    const __m128i d = _mm_add_epi16(d3, d4);
  105|       |
  106|       |    // Second pass.
  107|  40.3k|    const __m128i tmp0 = _mm_add_epi16(a, d);
  108|  40.3k|    const __m128i tmp1 = _mm_add_epi16(b, c);
  109|  40.3k|    const __m128i tmp2 = _mm_sub_epi16(b, c);
  110|  40.3k|    const __m128i tmp3 = _mm_sub_epi16(a, d);
  111|       |
  112|       |    // Transpose the two 4x4.
  113|  40.3k|    VP8Transpose_2_4x4_16b(&tmp0, &tmp1, &tmp2, &tmp3, &T0, &T1, &T2, &T3);
  114|  40.3k|  }
  115|       |
  116|       |  // Horizontal pass and subsequent transpose.
  117|  40.3k|  {
  118|       |    // First pass, c and d calculations are longer because of the "trick"
  119|       |    // multiplications.
  120|  40.3k|    const __m128i four = _mm_set1_epi16(4);
  121|  40.3k|    const __m128i dc = _mm_add_epi16(T0, four);
  122|  40.3k|    const __m128i a = _mm_add_epi16(dc, T2);
  123|  40.3k|    const __m128i b = _mm_sub_epi16(dc, T2);
  124|       |    // c = MUL(T1, K2) - MUL(T3, K1) = MUL(T1, k2) - MUL(T3, k1) + T1 - T3
  125|  40.3k|    const __m128i c1 = _mm_mulhi_epi16(T1, k2);
  126|  40.3k|    const __m128i c2 = _mm_mulhi_epi16(T3, k1);
  127|  40.3k|    const __m128i c3 = _mm_sub_epi16(T1, T3);
  128|  40.3k|    const __m128i c4 = _mm_sub_epi16(c1, c2);
  129|  40.3k|    const __m128i c = _mm_add_epi16(c3, c4);
  130|       |    // d = MUL(T1, K1) + MUL(T3, K2) = MUL(T1, k1) + MUL(T3, k2) + T1 + T3
  131|  40.3k|    const __m128i d1 = _mm_mulhi_epi16(T1, k1);
  132|  40.3k|    const __m128i d2 = _mm_mulhi_epi16(T3, k2);
  133|  40.3k|    const __m128i d3 = _mm_add_epi16(T1, T3);
  134|  40.3k|    const __m128i d4 = _mm_add_epi16(d1, d2);
  135|  40.3k|    const __m128i d = _mm_add_epi16(d3, d4);
  136|       |
  137|       |    // Second pass.
  138|  40.3k|    const __m128i tmp0 = _mm_add_epi16(a, d);
  139|  40.3k|    const __m128i tmp1 = _mm_add_epi16(b, c);
  140|  40.3k|    const __m128i tmp2 = _mm_sub_epi16(b, c);
  141|  40.3k|    const __m128i tmp3 = _mm_sub_epi16(a, d);
  142|  40.3k|    const __m128i shifted0 = _mm_srai_epi16(tmp0, 3);
  143|  40.3k|    const __m128i shifted1 = _mm_srai_epi16(tmp1, 3);
  144|  40.3k|    const __m128i shifted2 = _mm_srai_epi16(tmp2, 3);
  145|  40.3k|    const __m128i shifted3 = _mm_srai_epi16(tmp3, 3);
  146|       |
  147|       |    // Transpose the two 4x4.
  148|  40.3k|    VP8Transpose_2_4x4_16b(&shifted0, &shifted1, &shifted2, &shifted3, &T0, &T1,
  149|  40.3k|                           &T2, &T3);
  150|  40.3k|  }
  151|       |
  152|       |  // Add inverse transform to 'dst' and store.
  153|  40.3k|  {
  154|  40.3k|    const __m128i zero = _mm_setzero_si128();
  155|       |    // Load the reference(s).
  156|  40.3k|    __m128i dst0, dst1, dst2, dst3;
  157|  40.3k|    if (do_two) {
  ------------------
  |  Branch (157:9): [True: 25.4k, False: 14.9k]
  ------------------
  158|       |      // Load eight bytes/pixels per line.
  159|  25.4k|      dst0 = _mm_loadl_epi64((__m128i*)(dst + 0 * BPS));
  ------------------
  |  |   33|  25.4k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  160|  25.4k|      dst1 = _mm_loadl_epi64((__m128i*)(dst + 1 * BPS));
  ------------------
  |  |   33|  25.4k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  161|  25.4k|      dst2 = _mm_loadl_epi64((__m128i*)(dst + 2 * BPS));
  ------------------
  |  |   33|  25.4k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  162|  25.4k|      dst3 = _mm_loadl_epi64((__m128i*)(dst + 3 * BPS));
  ------------------
  |  |   33|  25.4k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  163|  25.4k|    } else {
  164|       |      // Load four bytes/pixels per line.
  165|  14.9k|      dst0 = _mm_cvtsi32_si128(WebPMemToInt32(dst + 0 * BPS));
  ------------------
  |  |   33|  14.9k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  166|  14.9k|      dst1 = _mm_cvtsi32_si128(WebPMemToInt32(dst + 1 * BPS));
  ------------------
  |  |   33|  14.9k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  167|  14.9k|      dst2 = _mm_cvtsi32_si128(WebPMemToInt32(dst + 2 * BPS));
  ------------------
  |  |   33|  14.9k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  168|  14.9k|      dst3 = _mm_cvtsi32_si128(WebPMemToInt32(dst + 3 * BPS));
  ------------------
  |  |   33|  14.9k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  169|  14.9k|    }
  170|       |    // Convert to 16b.
  171|  40.3k|    dst0 = _mm_unpacklo_epi8(dst0, zero);
  172|  40.3k|    dst1 = _mm_unpacklo_epi8(dst1, zero);
  173|  40.3k|    dst2 = _mm_unpacklo_epi8(dst2, zero);
  174|  40.3k|    dst3 = _mm_unpacklo_epi8(dst3, zero);
  175|       |    // Add the inverse transform(s).
  176|  40.3k|    dst0 = _mm_add_epi16(dst0, T0);
  177|  40.3k|    dst1 = _mm_add_epi16(dst1, T1);
  178|  40.3k|    dst2 = _mm_add_epi16(dst2, T2);
  179|  40.3k|    dst3 = _mm_add_epi16(dst3, T3);
  180|       |    // Unsigned saturate to 8b.
  181|  40.3k|    dst0 = _mm_packus_epi16(dst0, dst0);
  182|  40.3k|    dst1 = _mm_packus_epi16(dst1, dst1);
  183|  40.3k|    dst2 = _mm_packus_epi16(dst2, dst2);
  184|  40.3k|    dst3 = _mm_packus_epi16(dst3, dst3);
  185|       |    // Store the results.
  186|  40.3k|    if (do_two) {
  ------------------
  |  Branch (186:9): [True: 25.4k, False: 14.9k]
  ------------------
  187|       |      // Store eight bytes/pixels per line.
  188|  25.4k|      _mm_storel_epi64((__m128i*)(dst + 0 * BPS), dst0);
  ------------------
  |  |   33|  25.4k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  189|  25.4k|      _mm_storel_epi64((__m128i*)(dst + 1 * BPS), dst1);
  ------------------
  |  |   33|  25.4k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  190|  25.4k|      _mm_storel_epi64((__m128i*)(dst + 2 * BPS), dst2);
  ------------------
  |  |   33|  25.4k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  191|  25.4k|      _mm_storel_epi64((__m128i*)(dst + 3 * BPS), dst3);
  ------------------
  |  |   33|  25.4k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  192|  25.4k|    } else {
  193|       |      // Store four bytes/pixels per line.
  194|  14.9k|      WebPInt32ToMem(dst + 0 * BPS, _mm_cvtsi128_si32(dst0));
  ------------------
  |  |   33|  14.9k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  195|  14.9k|      WebPInt32ToMem(dst + 1 * BPS, _mm_cvtsi128_si32(dst1));
  ------------------
  |  |   33|  14.9k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  196|  14.9k|      WebPInt32ToMem(dst + 2 * BPS, _mm_cvtsi128_si32(dst2));
  ------------------
  |  |   33|  14.9k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  197|  14.9k|      WebPInt32ToMem(dst + 3 * BPS, _mm_cvtsi128_si32(dst3));
  ------------------
  |  |   33|  14.9k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  198|  14.9k|    }
  199|  40.3k|  }
  200|  40.3k|}
dec_sse2.c:VFilter16_SSE2:
  697|  18.8k|                           int hev_thresh) {
  698|  18.8k|  __m128i t1;
  699|  18.8k|  __m128i mask;
  700|  18.8k|  __m128i p2, p1, p0, q0, q1, q2;
  701|       |
  702|       |  // Load p3, p2, p1, p0
  703|  18.8k|  LOAD_H_EDGES4(p - 4 * stride, stride, t1, p2, p1, p0);
  ------------------
  |  |  653|  18.8k|  do {                                                    \
  |  |  654|  18.8k|    (e1) = _mm_loadu_si128((__m128i*)&(p)[0 * (stride)]); \
  |  |  655|  18.8k|    (e2) = _mm_loadu_si128((__m128i*)&(p)[1 * (stride)]); \
  |  |  656|  18.8k|    (e3) = _mm_loadu_si128((__m128i*)&(p)[2 * (stride)]); \
  |  |  657|  18.8k|    (e4) = _mm_loadu_si128((__m128i*)&(p)[3 * (stride)]); \
  |  |  658|  18.8k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (658:12): [Folded, False: 18.8k]
  |  |  ------------------
  ------------------
  704|  18.8k|  MAX_DIFF1(t1, p2, p1, p0, mask);
  ------------------
  |  |  639|  18.8k|  do {                                     \
  |  |  640|  18.8k|    (m) = MM_ABS(p1, p0);                  \
  |  |  ------------------
  |  |  |  |  252|  18.8k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  641|  18.8k|    (m) = _mm_max_epu8(m, MM_ABS(p3, p2)); \
  |  |  ------------------
  |  |  |  |  252|  18.8k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  642|  18.8k|    (m) = _mm_max_epu8(m, MM_ABS(p2, p1)); \
  |  |  ------------------
  |  |  |  |  252|  18.8k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  643|  18.8k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (643:12): [Folded, False: 18.8k]
  |  |  ------------------
  ------------------
  705|       |
  706|       |  // Load q0, q1, q2, q3
  707|  18.8k|  LOAD_H_EDGES4(p, stride, q0, q1, q2, t1);
  ------------------
  |  |  653|  18.8k|  do {                                                    \
  |  |  654|  18.8k|    (e1) = _mm_loadu_si128((__m128i*)&(p)[0 * (stride)]); \
  |  |  655|  18.8k|    (e2) = _mm_loadu_si128((__m128i*)&(p)[1 * (stride)]); \
  |  |  656|  18.8k|    (e3) = _mm_loadu_si128((__m128i*)&(p)[2 * (stride)]); \
  |  |  657|  18.8k|    (e4) = _mm_loadu_si128((__m128i*)&(p)[3 * (stride)]); \
  |  |  658|  18.8k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (658:12): [Folded, False: 18.8k]
  |  |  ------------------
  ------------------
  708|  18.8k|  MAX_DIFF2(t1, q2, q1, q0, mask);
  ------------------
  |  |  646|  18.8k|  do {                                     \
  |  |  647|  18.8k|    (m) = _mm_max_epu8(m, MM_ABS(p1, p0)); \
  |  |  ------------------
  |  |  |  |  252|  18.8k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  648|  18.8k|    (m) = _mm_max_epu8(m, MM_ABS(p3, p2)); \
  |  |  ------------------
  |  |  |  |  252|  18.8k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  649|  18.8k|    (m) = _mm_max_epu8(m, MM_ABS(p2, p1)); \
  |  |  ------------------
  |  |  |  |  252|  18.8k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  650|  18.8k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (650:12): [Folded, False: 18.8k]
  |  |  ------------------
  ------------------
  709|       |
  710|  18.8k|  ComplexMask_SSE2(&p1, &p0, &q0, &q1, thresh, ithresh, &mask);
  711|  18.8k|  DoFilter6_SSE2(&p2, &p1, &p0, &q0, &q1, &q2, &mask, hev_thresh);
  712|       |
  713|       |  // Store
  714|  18.8k|  _mm_storeu_si128((__m128i*)&p[-3 * stride], p2);
  715|  18.8k|  _mm_storeu_si128((__m128i*)&p[-2 * stride], p1);
  716|  18.8k|  _mm_storeu_si128((__m128i*)&p[-1 * stride], p0);
  717|  18.8k|  _mm_storeu_si128((__m128i*)&p[+0 * stride], q0);
  718|  18.8k|  _mm_storeu_si128((__m128i*)&p[+1 * stride], q1);
  719|  18.8k|  _mm_storeu_si128((__m128i*)&p[+2 * stride], q2);
  720|  18.8k|}
dec_sse2.c:ComplexMask_SSE2:
  686|   194k|                                         int ithresh, __m128i* const mask) {
  687|   194k|  const __m128i it = _mm_set1_epi8(ithresh);
  688|   194k|  const __m128i diff = _mm_subs_epu8(*mask, it);
  689|   194k|  const __m128i thresh_mask = _mm_cmpeq_epi8(diff, _mm_setzero_si128());
  690|   194k|  __m128i filter_mask;
  691|   194k|  NeedsFilter_SSE2(p1, p0, q0, q1, thresh, &filter_mask);
  692|   194k|  *mask = _mm_and_si128(thresh_mask, filter_mask);
  693|   194k|}
dec_sse2.c:NeedsFilter_SSE2:
  344|   258k|                                         __m128i* const mask) {
  345|   258k|  const __m128i m_thresh = _mm_set1_epi8((char)thresh);
  346|   258k|  const __m128i t1 = MM_ABS(*p1, *q1);  // abs(p1 - q1)
  ------------------
  |  |  252|   258k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  ------------------
  347|   258k|  const __m128i kFE = _mm_set1_epi8((char)0xFE);
  348|   258k|  const __m128i t2 = _mm_and_si128(t1, kFE);  // set lsb of each byte to zero
  349|   258k|  const __m128i t3 = _mm_srli_epi16(t2, 1);   // abs(p1 - q1) / 2
  350|       |
  351|   258k|  const __m128i t4 = MM_ABS(*p0, *q0);       // abs(p0 - q0)
  ------------------
  |  |  252|   258k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  ------------------
  352|   258k|  const __m128i t5 = _mm_adds_epu8(t4, t4);  // abs(p0 - q0) * 2
  353|   258k|  const __m128i t6 = _mm_adds_epu8(t5, t3);  // abs(p0-q0)*2 + abs(p1-q1)/2
  354|       |
  355|   258k|  const __m128i t7 = _mm_subs_epu8(t6, m_thresh);  // mask <= m_thresh
  356|   258k|  *mask = _mm_cmpeq_epi8(t7, _mm_setzero_si128());
  357|   258k|}
dec_sse2.c:DoFilter6_SSE2:
  432|  55.2k|                                       int hev_thresh) {
  433|  55.2k|  const __m128i zero = _mm_setzero_si128();
  434|  55.2k|  const __m128i sign_bit = _mm_set1_epi8((char)0x80);
  435|  55.2k|  __m128i a, not_hev;
  436|       |
  437|       |  // compute hev mask
  438|  55.2k|  GetNotHEV_SSE2(p1, p0, q0, q1, hev_thresh, &not_hev);
  439|       |
  440|  55.2k|  FLIP_SIGN_BIT4(*p1, *p0, *q0, *q1);
  ------------------
  |  |  271|  55.2k|  do {                             \
  |  |  272|  55.2k|    FLIP_SIGN_BIT2(a, b);          \
  |  |  ------------------
  |  |  |  |  265|  55.2k|  do {                                \
  |  |  |  |  266|  55.2k|    (a) = _mm_xor_si128(a, sign_bit); \
  |  |  |  |  267|  55.2k|    (b) = _mm_xor_si128(b, sign_bit); \
  |  |  |  |  268|  55.2k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (268:12): [Folded, False: 55.2k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  273|  55.2k|    FLIP_SIGN_BIT2(c, d);          \
  |  |  ------------------
  |  |  |  |  265|  55.2k|  do {                                \
  |  |  |  |  266|  55.2k|    (a) = _mm_xor_si128(a, sign_bit); \
  |  |  |  |  267|  55.2k|    (b) = _mm_xor_si128(b, sign_bit); \
  |  |  |  |  268|  55.2k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (268:12): [Folded, False: 55.2k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  274|  55.2k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (274:12): [Folded, False: 55.2k]
  |  |  ------------------
  ------------------
  441|  55.2k|  FLIP_SIGN_BIT2(*p2, *q2);
  ------------------
  |  |  265|  55.2k|  do {                                \
  |  |  266|  55.2k|    (a) = _mm_xor_si128(a, sign_bit); \
  |  |  267|  55.2k|    (b) = _mm_xor_si128(b, sign_bit); \
  |  |  268|  55.2k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (268:12): [Folded, False: 55.2k]
  |  |  ------------------
  ------------------
  442|  55.2k|  GetBaseDelta_SSE2(p1, p0, q0, q1, &a);
  443|       |
  444|  55.2k|  {  // do simple filter on pixels with hev
  445|  55.2k|    const __m128i m = _mm_andnot_si128(not_hev, *mask);
  446|  55.2k|    const __m128i f = _mm_and_si128(a, m);
  447|  55.2k|    DoSimpleFilter_SSE2(p0, q0, &f);
  448|  55.2k|  }
  449|       |
  450|  55.2k|  {  // do strong filter on pixels with not hev
  451|  55.2k|    const __m128i k9 = _mm_set1_epi16(0x0900);
  452|  55.2k|    const __m128i k63 = _mm_set1_epi16(63);
  453|       |
  454|  55.2k|    const __m128i m = _mm_and_si128(not_hev, *mask);
  455|  55.2k|    const __m128i f = _mm_and_si128(a, m);
  456|       |
  457|  55.2k|    const __m128i f_lo = _mm_unpacklo_epi8(zero, f);
  458|  55.2k|    const __m128i f_hi = _mm_unpackhi_epi8(zero, f);
  459|       |
  460|  55.2k|    const __m128i f9_lo = _mm_mulhi_epi16(f_lo, k9);  // Filter (lo) * 9
  461|  55.2k|    const __m128i f9_hi = _mm_mulhi_epi16(f_hi, k9);  // Filter (hi) * 9
  462|       |
  463|  55.2k|    const __m128i a2_lo = _mm_add_epi16(f9_lo, k63);  // Filter * 9 + 63
  464|  55.2k|    const __m128i a2_hi = _mm_add_epi16(f9_hi, k63);  // Filter * 9 + 63
  465|       |
  466|  55.2k|    const __m128i a1_lo = _mm_add_epi16(a2_lo, f9_lo);  // Filter * 18 + 63
  467|  55.2k|    const __m128i a1_hi = _mm_add_epi16(a2_hi, f9_hi);  // Filter * 18 + 63
  468|       |
  469|  55.2k|    const __m128i a0_lo = _mm_add_epi16(a1_lo, f9_lo);  // Filter * 27 + 63
  470|  55.2k|    const __m128i a0_hi = _mm_add_epi16(a1_hi, f9_hi);  // Filter * 27 + 63
  471|       |
  472|  55.2k|    Update2Pixels_SSE2(p2, q2, &a2_lo, &a2_hi);
  473|  55.2k|    Update2Pixels_SSE2(p1, q1, &a1_lo, &a1_hi);
  474|  55.2k|    Update2Pixels_SSE2(p0, q0, &a0_lo, &a0_hi);
  475|  55.2k|  }
  476|  55.2k|}
dec_sse2.c:GetNotHEV_SSE2:
  281|   194k|                                       __m128i* const not_hev) {
  282|   194k|  const __m128i zero = _mm_setzero_si128();
  283|   194k|  const __m128i t_1 = MM_ABS(*p1, *p0);
  ------------------
  |  |  252|   194k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  ------------------
  284|   194k|  const __m128i t_2 = MM_ABS(*q1, *q0);
  ------------------
  |  |  252|   194k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  ------------------
  285|       |
  286|   194k|  const __m128i h = _mm_set1_epi8(hev_thresh);
  287|   194k|  const __m128i t_max = _mm_max_epu8(t_1, t_2);
  288|       |
  289|   194k|  const __m128i t_max_h = _mm_subs_epu8(t_max, h);
  290|   194k|  *not_hev = _mm_cmpeq_epi8(t_max_h, zero);  // not_hev <= t1 && not_hev <= t2
  291|   194k|}
dec_sse2.c:GetBaseDelta_SSE2:
  298|   118k|                                          __m128i* const delta) {
  299|       |  // beware of addition order, for saturation!
  300|   118k|  const __m128i p1_q1 = _mm_subs_epi8(*p1, *q1);   // p1 - q1
  301|   118k|  const __m128i q0_p0 = _mm_subs_epi8(*q0, *p0);   // q0 - p0
  302|   118k|  const __m128i s1 = _mm_adds_epi8(p1_q1, q0_p0);  // p1 - q1 + 1 * (q0 - p0)
  303|   118k|  const __m128i s2 = _mm_adds_epi8(q0_p0, s1);     // p1 - q1 + 2 * (q0 - p0)
  304|   118k|  const __m128i s3 = _mm_adds_epi8(q0_p0, s2);     // p1 - q1 + 3 * (q0 - p0)
  305|   118k|  *delta = s3;
  306|   118k|}
dec_sse2.c:DoSimpleFilter_SSE2:
  311|   118k|                                            const __m128i* const fl) {
  312|   118k|  const __m128i k3 = _mm_set1_epi8(3);
  313|   118k|  const __m128i k4 = _mm_set1_epi8(4);
  314|   118k|  __m128i v3 = _mm_adds_epi8(*fl, k3);
  315|   118k|  __m128i v4 = _mm_adds_epi8(*fl, k4);
  316|       |
  317|   118k|  SignedShift8b_SSE2(&v4);       // v4 >> 3
  318|   118k|  SignedShift8b_SSE2(&v3);       // v3 >> 3
  319|   118k|  *q0 = _mm_subs_epi8(*q0, v4);  // q0 -= v4
  320|   118k|  *p0 = _mm_adds_epi8(*p0, v3);  // p0 += v3
  321|   118k|}
dec_sse2.c:SignedShift8b_SSE2:
  255|   516k|static WEBP_INLINE void SignedShift8b_SSE2(__m128i* const x) {
  256|   516k|  const __m128i zero = _mm_setzero_si128();
  257|   516k|  const __m128i lo_0 = _mm_unpacklo_epi8(zero, *x);
  258|   516k|  const __m128i hi_0 = _mm_unpackhi_epi8(zero, *x);
  259|   516k|  const __m128i lo_1 = _mm_srai_epi16(lo_0, 3 + 8);
  260|   516k|  const __m128i hi_1 = _mm_srai_epi16(hi_0, 3 + 8);
  261|   516k|  *x = _mm_packs_epi16(lo_1, hi_1);
  262|   516k|}
dec_sse2.c:Update2Pixels_SSE2:
  329|   165k|                                           const __m128i* const a0_hi) {
  330|   165k|  const __m128i a1_lo = _mm_srai_epi16(*a0_lo, 7);
  331|   165k|  const __m128i a1_hi = _mm_srai_epi16(*a0_hi, 7);
  332|   165k|  const __m128i delta = _mm_packs_epi16(a1_lo, a1_hi);
  333|   165k|  const __m128i sign_bit = _mm_set1_epi8((char)0x80);
  334|   165k|  *pi = _mm_adds_epi8(*pi, delta);
  335|   165k|  *qi = _mm_subs_epi8(*qi, delta);
  336|   165k|  FLIP_SIGN_BIT2(*pi, *qi);
  ------------------
  |  |  265|   165k|  do {                                \
  |  |  266|   165k|    (a) = _mm_xor_si128(a, sign_bit); \
  |  |  267|   165k|    (b) = _mm_xor_si128(b, sign_bit); \
  |  |  268|   165k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (268:12): [Folded, False: 165k]
  |  |  ------------------
  ------------------
  337|   165k|}
dec_sse2.c:HFilter16_SSE2:
  723|  8.72k|                           int hev_thresh) {
  724|  8.72k|  __m128i mask;
  725|  8.72k|  __m128i p3, p2, p1, p0, q0, q1, q2, q3;
  726|       |
  727|  8.72k|  uint8_t* const b = p - 4;
  728|  8.72k|  Load16x4_SSE2(b, b + 8 * stride, stride, &p3, &p2, &p1, &p0);
  729|  8.72k|  MAX_DIFF1(p3, p2, p1, p0, mask);
  ------------------
  |  |  639|  8.72k|  do {                                     \
  |  |  640|  8.72k|    (m) = MM_ABS(p1, p0);                  \
  |  |  ------------------
  |  |  |  |  252|  8.72k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  641|  8.72k|    (m) = _mm_max_epu8(m, MM_ABS(p3, p2)); \
  |  |  ------------------
  |  |  |  |  252|  8.72k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  642|  8.72k|    (m) = _mm_max_epu8(m, MM_ABS(p2, p1)); \
  |  |  ------------------
  |  |  |  |  252|  8.72k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  643|  8.72k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (643:12): [Folded, False: 8.72k]
  |  |  ------------------
  ------------------
  730|       |
  731|  8.72k|  Load16x4_SSE2(p, p + 8 * stride, stride, &q0, &q1, &q2, &q3);
  732|  8.72k|  MAX_DIFF2(q3, q2, q1, q0, mask);
  ------------------
  |  |  646|  8.72k|  do {                                     \
  |  |  647|  8.72k|    (m) = _mm_max_epu8(m, MM_ABS(p1, p0)); \
  |  |  ------------------
  |  |  |  |  252|  8.72k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  648|  8.72k|    (m) = _mm_max_epu8(m, MM_ABS(p3, p2)); \
  |  |  ------------------
  |  |  |  |  252|  8.72k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  649|  8.72k|    (m) = _mm_max_epu8(m, MM_ABS(p2, p1)); \
  |  |  ------------------
  |  |  |  |  252|  8.72k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  650|  8.72k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (650:12): [Folded, False: 8.72k]
  |  |  ------------------
  ------------------
  733|       |
  734|  8.72k|  ComplexMask_SSE2(&p1, &p0, &q0, &q1, thresh, ithresh, &mask);
  735|  8.72k|  DoFilter6_SSE2(&p2, &p1, &p0, &q0, &q1, &q2, &mask, hev_thresh);
  736|       |
  737|  8.72k|  Store16x4_SSE2(&p3, &p2, &p1, &p0, b, b + 8 * stride, stride);
  738|  8.72k|  Store16x4_SSE2(&q0, &q1, &q2, &q3, p, p + 8 * stride, stride);
  739|  8.72k|}
dec_sse2.c:Load16x4_SSE2:
  509|   170k|                                      __m128i* const q0, __m128i* const q1) {
  510|       |  // Assume the pixels around the edge (|) are numbered as follows
  511|       |  //                00 01 | 02 03
  512|       |  //                10 11 | 12 13
  513|       |  //                 ...  |  ...
  514|       |  //                e0 e1 | e2 e3
  515|       |  //                f0 f1 | f2 f3
  516|       |  //
  517|       |  // r0 is pointing to the 0th row (00)
  518|       |  // r8 is pointing to the 8th row (80)
  519|       |
  520|       |  // Load
  521|       |  // p1 = 71 61 51 41 31 21 11 01 70 60 50 40 30 20 10 00
  522|       |  // q0 = 73 63 53 43 33 23 13 03 72 62 52 42 32 22 12 02
  523|       |  // p0 = f1 e1 d1 c1 b1 a1 91 81 f0 e0 d0 c0 b0 a0 90 80
  524|       |  // q1 = f3 e3 d3 c3 b3 a3 93 83 f2 e2 d2 c2 b2 a2 92 82
  525|   170k|  Load8x4_SSE2(r0, stride, p1, q0);
  526|   170k|  Load8x4_SSE2(r8, stride, p0, q1);
  527|       |
  528|   170k|  {
  529|       |    // p1 = f0 e0 d0 c0 b0 a0 90 80 70 60 50 40 30 20 10 00
  530|       |    // p0 = f1 e1 d1 c1 b1 a1 91 81 71 61 51 41 31 21 11 01
  531|       |    // q0 = f2 e2 d2 c2 b2 a2 92 82 72 62 52 42 32 22 12 02
  532|       |    // q1 = f3 e3 d3 c3 b3 a3 93 83 73 63 53 43 33 23 13 03
  533|   170k|    const __m128i t1 = *p1;
  534|   170k|    const __m128i t2 = *q0;
  535|   170k|    *p1 = _mm_unpacklo_epi64(t1, *p0);
  536|   170k|    *p0 = _mm_unpackhi_epi64(t1, *p0);
  537|   170k|    *q0 = _mm_unpacklo_epi64(t2, *q1);
  538|   170k|    *q1 = _mm_unpackhi_epi64(t2, *q1);
  539|   170k|  }
  540|   170k|}
dec_sse2.c:Load8x4_SSE2:
  480|   340k|                                     __m128i* const p, __m128i* const q) {
  481|       |  // A0 = 63 62 61 60 23 22 21 20 43 42 41 40 03 02 01 00
  482|       |  // A1 = 73 72 71 70 33 32 31 30 53 52 51 50 13 12 11 10
  483|   340k|  const __m128i A0 = _mm_set_epi32(
  484|   340k|      WebPMemToInt32(&b[6 * stride]), WebPMemToInt32(&b[2 * stride]),
  485|   340k|      WebPMemToInt32(&b[4 * stride]), WebPMemToInt32(&b[0 * stride]));
  486|   340k|  const __m128i A1 = _mm_set_epi32(
  487|   340k|      WebPMemToInt32(&b[7 * stride]), WebPMemToInt32(&b[3 * stride]),
  488|   340k|      WebPMemToInt32(&b[5 * stride]), WebPMemToInt32(&b[1 * stride]));
  489|       |
  490|       |  // B0 = 53 43 52 42 51 41 50 40 13 03 12 02 11 01 10 00
  491|       |  // B1 = 73 63 72 62 71 61 70 60 33 23 32 22 31 21 30 20
  492|   340k|  const __m128i B0 = _mm_unpacklo_epi8(A0, A1);
  493|   340k|  const __m128i B1 = _mm_unpackhi_epi8(A0, A1);
  494|       |
  495|       |  // C0 = 33 23 13 03 32 22 12 02 31 21 11 01 30 20 10 00
  496|       |  // C1 = 73 63 53 43 72 62 52 42 71 61 51 41 70 60 50 40
  497|   340k|  const __m128i C0 = _mm_unpacklo_epi16(B0, B1);
  498|   340k|  const __m128i C1 = _mm_unpackhi_epi16(B0, B1);
  499|       |
  500|       |  // *p = 71 61 51 41 31 21 11 01 70 60 50 40 30 20 10 00
  501|       |  // *q = 73 63 53 43 33 23 13 03 72 62 52 42 32 22 12 02
  502|   340k|  *p = _mm_unpacklo_epi32(C0, C1);
  503|   340k|  *q = _mm_unpackhi_epi32(C0, C1);
  504|   340k|}
dec_sse2.c:Store16x4_SSE2:
  556|   135k|                                       uint8_t* r8, int stride) {
  557|   135k|  __m128i t1, p1_s, p0_s, q0_s, q1_s;
  558|       |
  559|       |  // p0 = 71 70 61 60 51 50 41 40 31 30 21 20 11 10 01 00
  560|       |  // p1 = f1 f0 e1 e0 d1 d0 c1 c0 b1 b0 a1 a0 91 90 81 80
  561|   135k|  t1 = *p0;
  562|   135k|  p0_s = _mm_unpacklo_epi8(*p1, t1);
  563|   135k|  p1_s = _mm_unpackhi_epi8(*p1, t1);
  564|       |
  565|       |  // q0 = 73 72 63 62 53 52 43 42 33 32 23 22 13 12 03 02
  566|       |  // q1 = f3 f2 e3 e2 d3 d2 c3 c2 b3 b2 a3 a2 93 92 83 82
  567|   135k|  t1 = *q0;
  568|   135k|  q0_s = _mm_unpacklo_epi8(t1, *q1);
  569|   135k|  q1_s = _mm_unpackhi_epi8(t1, *q1);
  570|       |
  571|       |  // p0 = 33 32 31 30 23 22 21 20 13 12 11 10 03 02 01 00
  572|       |  // q0 = 73 72 71 70 63 62 61 60 53 52 51 50 43 42 41 40
  573|   135k|  t1 = p0_s;
  574|   135k|  p0_s = _mm_unpacklo_epi16(t1, q0_s);
  575|   135k|  q0_s = _mm_unpackhi_epi16(t1, q0_s);
  576|       |
  577|       |  // p1 = b3 b2 b1 b0 a3 a2 a1 a0 93 92 91 90 83 82 81 80
  578|       |  // q1 = f3 f2 f1 f0 e3 e2 e1 e0 d3 d2 d1 d0 c3 c2 c1 c0
  579|   135k|  t1 = p1_s;
  580|   135k|  p1_s = _mm_unpacklo_epi16(t1, q1_s);
  581|   135k|  q1_s = _mm_unpackhi_epi16(t1, q1_s);
  582|       |
  583|   135k|  Store4x4_SSE2(&p0_s, r0, stride);
  584|   135k|  r0 += 4 * stride;
  585|   135k|  Store4x4_SSE2(&q0_s, r0, stride);
  586|       |
  587|   135k|  Store4x4_SSE2(&p1_s, r8, stride);
  588|   135k|  r8 += 4 * stride;
  589|   135k|  Store4x4_SSE2(&q1_s, r8, stride);
  590|   135k|}
dec_sse2.c:Store4x4_SSE2:
  543|   540k|                                      int stride) {
  544|   540k|  int i;
  545|  2.70M|  for (i = 0; i < 4; ++i, dst += stride) {
  ------------------
  |  Branch (545:15): [True: 2.16M, False: 540k]
  ------------------
  546|  2.16M|    WebPInt32ToMem(dst, _mm_cvtsi128_si32(*x));
  547|       |    *x = _mm_srli_si128(*x, 4);
  548|  2.16M|  }
  549|   540k|}
dec_sse2.c:VFilter8_SSE2:
  805|  18.8k|                          int stride, int thresh, int ithresh, int hev_thresh) {
  806|  18.8k|  __m128i mask;
  807|  18.8k|  __m128i t1, p2, p1, p0, q0, q1, q2;
  808|       |
  809|       |  // Load p3, p2, p1, p0
  810|  18.8k|  LOADUV_H_EDGES4(u - 4 * stride, v - 4 * stride, stride, t1, p2, p1, p0);
  ------------------
  |  |  668|  18.8k|  do {                                                \
  |  |  669|  18.8k|    LOADUV_H_EDGE(e1, u, v, 0 * (stride));            \
  |  |  ------------------
  |  |  |  |  661|  18.8k|  do {                                                           \
  |  |  |  |  662|  18.8k|    const __m128i U = _mm_loadl_epi64((__m128i*)&(u)[(stride)]); \
  |  |  |  |  663|  18.8k|    const __m128i V = _mm_loadl_epi64((__m128i*)&(v)[(stride)]); \
  |  |  |  |  664|  18.8k|    (p) = _mm_unpacklo_epi64(U, V);                              \
  |  |  |  |  665|  18.8k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (665:12): [Folded, False: 18.8k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  670|  18.8k|    LOADUV_H_EDGE(e2, u, v, 1 * (stride));            \
  |  |  ------------------
  |  |  |  |  661|  18.8k|  do {                                                           \
  |  |  |  |  662|  18.8k|    const __m128i U = _mm_loadl_epi64((__m128i*)&(u)[(stride)]); \
  |  |  |  |  663|  18.8k|    const __m128i V = _mm_loadl_epi64((__m128i*)&(v)[(stride)]); \
  |  |  |  |  664|  18.8k|    (p) = _mm_unpacklo_epi64(U, V);                              \
  |  |  |  |  665|  18.8k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (665:12): [Folded, False: 18.8k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  671|  18.8k|    LOADUV_H_EDGE(e3, u, v, 2 * (stride));            \
  |  |  ------------------
  |  |  |  |  661|  18.8k|  do {                                                           \
  |  |  |  |  662|  18.8k|    const __m128i U = _mm_loadl_epi64((__m128i*)&(u)[(stride)]); \
  |  |  |  |  663|  18.8k|    const __m128i V = _mm_loadl_epi64((__m128i*)&(v)[(stride)]); \
  |  |  |  |  664|  18.8k|    (p) = _mm_unpacklo_epi64(U, V);                              \
  |  |  |  |  665|  18.8k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (665:12): [Folded, False: 18.8k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  672|  18.8k|    LOADUV_H_EDGE(e4, u, v, 3 * (stride));            \
  |  |  ------------------
  |  |  |  |  661|  18.8k|  do {                                                           \
  |  |  |  |  662|  18.8k|    const __m128i U = _mm_loadl_epi64((__m128i*)&(u)[(stride)]); \
  |  |  |  |  663|  18.8k|    const __m128i V = _mm_loadl_epi64((__m128i*)&(v)[(stride)]); \
  |  |  |  |  664|  18.8k|    (p) = _mm_unpacklo_epi64(U, V);                              \
  |  |  |  |  665|  18.8k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (665:12): [Folded, False: 18.8k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  673|  18.8k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (673:12): [Folded, False: 18.8k]
  |  |  ------------------
  ------------------
  811|  18.8k|  MAX_DIFF1(t1, p2, p1, p0, mask);
  ------------------
  |  |  639|  18.8k|  do {                                     \
  |  |  640|  18.8k|    (m) = MM_ABS(p1, p0);                  \
  |  |  ------------------
  |  |  |  |  252|  18.8k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  641|  18.8k|    (m) = _mm_max_epu8(m, MM_ABS(p3, p2)); \
  |  |  ------------------
  |  |  |  |  252|  18.8k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  642|  18.8k|    (m) = _mm_max_epu8(m, MM_ABS(p2, p1)); \
  |  |  ------------------
  |  |  |  |  252|  18.8k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  643|  18.8k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (643:12): [Folded, False: 18.8k]
  |  |  ------------------
  ------------------
  812|       |
  813|       |  // Load q0, q1, q2, q3
  814|  18.8k|  LOADUV_H_EDGES4(u, v, stride, q0, q1, q2, t1);
  ------------------
  |  |  668|  18.8k|  do {                                                \
  |  |  669|  18.8k|    LOADUV_H_EDGE(e1, u, v, 0 * (stride));            \
  |  |  ------------------
  |  |  |  |  661|  18.8k|  do {                                                           \
  |  |  |  |  662|  18.8k|    const __m128i U = _mm_loadl_epi64((__m128i*)&(u)[(stride)]); \
  |  |  |  |  663|  18.8k|    const __m128i V = _mm_loadl_epi64((__m128i*)&(v)[(stride)]); \
  |  |  |  |  664|  18.8k|    (p) = _mm_unpacklo_epi64(U, V);                              \
  |  |  |  |  665|  18.8k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (665:12): [Folded, False: 18.8k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  670|  18.8k|    LOADUV_H_EDGE(e2, u, v, 1 * (stride));            \
  |  |  ------------------
  |  |  |  |  661|  18.8k|  do {                                                           \
  |  |  |  |  662|  18.8k|    const __m128i U = _mm_loadl_epi64((__m128i*)&(u)[(stride)]); \
  |  |  |  |  663|  18.8k|    const __m128i V = _mm_loadl_epi64((__m128i*)&(v)[(stride)]); \
  |  |  |  |  664|  18.8k|    (p) = _mm_unpacklo_epi64(U, V);                              \
  |  |  |  |  665|  18.8k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (665:12): [Folded, False: 18.8k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  671|  18.8k|    LOADUV_H_EDGE(e3, u, v, 2 * (stride));            \
  |  |  ------------------
  |  |  |  |  661|  18.8k|  do {                                                           \
  |  |  |  |  662|  18.8k|    const __m128i U = _mm_loadl_epi64((__m128i*)&(u)[(stride)]); \
  |  |  |  |  663|  18.8k|    const __m128i V = _mm_loadl_epi64((__m128i*)&(v)[(stride)]); \
  |  |  |  |  664|  18.8k|    (p) = _mm_unpacklo_epi64(U, V);                              \
  |  |  |  |  665|  18.8k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (665:12): [Folded, False: 18.8k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  672|  18.8k|    LOADUV_H_EDGE(e4, u, v, 3 * (stride));            \
  |  |  ------------------
  |  |  |  |  661|  18.8k|  do {                                                           \
  |  |  |  |  662|  18.8k|    const __m128i U = _mm_loadl_epi64((__m128i*)&(u)[(stride)]); \
  |  |  |  |  663|  18.8k|    const __m128i V = _mm_loadl_epi64((__m128i*)&(v)[(stride)]); \
  |  |  |  |  664|  18.8k|    (p) = _mm_unpacklo_epi64(U, V);                              \
  |  |  |  |  665|  18.8k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (665:12): [Folded, False: 18.8k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  673|  18.8k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (673:12): [Folded, False: 18.8k]
  |  |  ------------------
  ------------------
  815|  18.8k|  MAX_DIFF2(t1, q2, q1, q0, mask);
  ------------------
  |  |  646|  18.8k|  do {                                     \
  |  |  647|  18.8k|    (m) = _mm_max_epu8(m, MM_ABS(p1, p0)); \
  |  |  ------------------
  |  |  |  |  252|  18.8k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  648|  18.8k|    (m) = _mm_max_epu8(m, MM_ABS(p3, p2)); \
  |  |  ------------------
  |  |  |  |  252|  18.8k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  649|  18.8k|    (m) = _mm_max_epu8(m, MM_ABS(p2, p1)); \
  |  |  ------------------
  |  |  |  |  252|  18.8k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  650|  18.8k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (650:12): [Folded, False: 18.8k]
  |  |  ------------------
  ------------------
  816|       |
  817|  18.8k|  ComplexMask_SSE2(&p1, &p0, &q0, &q1, thresh, ithresh, &mask);
  818|  18.8k|  DoFilter6_SSE2(&p2, &p1, &p0, &q0, &q1, &q2, &mask, hev_thresh);
  819|       |
  820|       |  // Store
  821|  18.8k|  STOREUV(p2, u, v, -3 * stride);
  ------------------
  |  |  676|  18.8k|  do {                                             \
  |  |  677|  18.8k|    _mm_storel_epi64((__m128i*)&(u)[(stride)], p); \
  |  |  678|  18.8k|    (p) = _mm_srli_si128(p, 8);                    \
  |  |  679|  18.8k|    _mm_storel_epi64((__m128i*)&(v)[(stride)], p); \
  |  |  680|  18.8k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (680:12): [Folded, False: 18.8k]
  |  |  ------------------
  ------------------
  822|  18.8k|  STOREUV(p1, u, v, -2 * stride);
  ------------------
  |  |  676|  18.8k|  do {                                             \
  |  |  677|  18.8k|    _mm_storel_epi64((__m128i*)&(u)[(stride)], p); \
  |  |  678|  18.8k|    (p) = _mm_srli_si128(p, 8);                    \
  |  |  679|  18.8k|    _mm_storel_epi64((__m128i*)&(v)[(stride)], p); \
  |  |  680|  18.8k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (680:12): [Folded, False: 18.8k]
  |  |  ------------------
  ------------------
  823|  18.8k|  STOREUV(p0, u, v, -1 * stride);
  ------------------
  |  |  676|  18.8k|  do {                                             \
  |  |  677|  18.8k|    _mm_storel_epi64((__m128i*)&(u)[(stride)], p); \
  |  |  678|  18.8k|    (p) = _mm_srli_si128(p, 8);                    \
  |  |  679|  18.8k|    _mm_storel_epi64((__m128i*)&(v)[(stride)], p); \
  |  |  680|  18.8k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (680:12): [Folded, False: 18.8k]
  |  |  ------------------
  ------------------
  824|  18.8k|  STOREUV(q0, u, v, 0 * stride);
  ------------------
  |  |  676|  18.8k|  do {                                             \
  |  |  677|  18.8k|    _mm_storel_epi64((__m128i*)&(u)[(stride)], p); \
  |  |  678|  18.8k|    (p) = _mm_srli_si128(p, 8);                    \
  |  |  679|  18.8k|    _mm_storel_epi64((__m128i*)&(v)[(stride)], p); \
  |  |  680|  18.8k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (680:12): [Folded, False: 18.8k]
  |  |  ------------------
  ------------------
  825|  18.8k|  STOREUV(q1, u, v, 1 * stride);
  ------------------
  |  |  676|  18.8k|  do {                                             \
  |  |  677|  18.8k|    _mm_storel_epi64((__m128i*)&(u)[(stride)], p); \
  |  |  678|  18.8k|    (p) = _mm_srli_si128(p, 8);                    \
  |  |  679|  18.8k|    _mm_storel_epi64((__m128i*)&(v)[(stride)], p); \
  |  |  680|  18.8k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (680:12): [Folded, False: 18.8k]
  |  |  ------------------
  ------------------
  826|       |  STOREUV(q2, u, v, 2 * stride);
  ------------------
  |  |  676|  18.8k|  do {                                             \
  |  |  677|  18.8k|    _mm_storel_epi64((__m128i*)&(u)[(stride)], p); \
  |  |  678|  18.8k|    (p) = _mm_srli_si128(p, 8);                    \
  |  |  679|  18.8k|    _mm_storel_epi64((__m128i*)&(v)[(stride)], p); \
  |  |  680|  18.8k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (680:12): [Folded, False: 18.8k]
  |  |  ------------------
  ------------------
  827|  18.8k|}
dec_sse2.c:HFilter8_SSE2:
  830|  8.72k|                          int stride, int thresh, int ithresh, int hev_thresh) {
  831|  8.72k|  __m128i mask;
  832|  8.72k|  __m128i p3, p2, p1, p0, q0, q1, q2, q3;
  833|       |
  834|  8.72k|  uint8_t* const tu = u - 4;
  835|  8.72k|  uint8_t* const tv = v - 4;
  836|  8.72k|  Load16x4_SSE2(tu, tv, stride, &p3, &p2, &p1, &p0);
  837|  8.72k|  MAX_DIFF1(p3, p2, p1, p0, mask);
  ------------------
  |  |  639|  8.72k|  do {                                     \
  |  |  640|  8.72k|    (m) = MM_ABS(p1, p0);                  \
  |  |  ------------------
  |  |  |  |  252|  8.72k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  641|  8.72k|    (m) = _mm_max_epu8(m, MM_ABS(p3, p2)); \
  |  |  ------------------
  |  |  |  |  252|  8.72k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  642|  8.72k|    (m) = _mm_max_epu8(m, MM_ABS(p2, p1)); \
  |  |  ------------------
  |  |  |  |  252|  8.72k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  643|  8.72k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (643:12): [Folded, False: 8.72k]
  |  |  ------------------
  ------------------
  838|       |
  839|  8.72k|  Load16x4_SSE2(u, v, stride, &q0, &q1, &q2, &q3);
  840|  8.72k|  MAX_DIFF2(q3, q2, q1, q0, mask);
  ------------------
  |  |  646|  8.72k|  do {                                     \
  |  |  647|  8.72k|    (m) = _mm_max_epu8(m, MM_ABS(p1, p0)); \
  |  |  ------------------
  |  |  |  |  252|  8.72k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  648|  8.72k|    (m) = _mm_max_epu8(m, MM_ABS(p3, p2)); \
  |  |  ------------------
  |  |  |  |  252|  8.72k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  649|  8.72k|    (m) = _mm_max_epu8(m, MM_ABS(p2, p1)); \
  |  |  ------------------
  |  |  |  |  252|  8.72k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  650|  8.72k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (650:12): [Folded, False: 8.72k]
  |  |  ------------------
  ------------------
  841|       |
  842|  8.72k|  ComplexMask_SSE2(&p1, &p0, &q0, &q1, thresh, ithresh, &mask);
  843|  8.72k|  DoFilter6_SSE2(&p2, &p1, &p0, &q0, &q1, &q2, &mask, hev_thresh);
  844|       |
  845|  8.72k|  Store16x4_SSE2(&p3, &p2, &p1, &p0, tu, tv, stride);
  846|  8.72k|  Store16x4_SSE2(&q0, &q1, &q2, &q3, u, v, stride);
  847|  8.72k|}
dec_sse2.c:VFilter16i_SSE2:
  743|  17.4k|                            int hev_thresh) {
  744|  17.4k|  int k;
  745|  17.4k|  __m128i p3, p2, p1, p0;  // loop invariants
  746|       |
  747|  17.4k|  LOAD_H_EDGES4(p, stride, p3, p2, p1, p0);  // prologue
  ------------------
  |  |  653|  17.4k|  do {                                                    \
  |  |  654|  17.4k|    (e1) = _mm_loadu_si128((__m128i*)&(p)[0 * (stride)]); \
  |  |  655|  17.4k|    (e2) = _mm_loadu_si128((__m128i*)&(p)[1 * (stride)]); \
  |  |  656|  17.4k|    (e3) = _mm_loadu_si128((__m128i*)&(p)[2 * (stride)]); \
  |  |  657|  17.4k|    (e4) = _mm_loadu_si128((__m128i*)&(p)[3 * (stride)]); \
  |  |  658|  17.4k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (658:12): [Folded, False: 17.4k]
  |  |  ------------------
  ------------------
  748|       |
  749|  69.8k|  for (k = 3; k > 0; --k) {
  ------------------
  |  Branch (749:15): [True: 52.4k, False: 17.4k]
  ------------------
  750|  52.4k|    __m128i mask, tmp1, tmp2;
  751|  52.4k|    uint8_t* const b = p + 2 * stride;  // beginning of p1
  752|  52.4k|    p += 4 * stride;
  753|       |
  754|  52.4k|    MAX_DIFF1(p3, p2, p1, p0, mask);  // compute partial mask
  ------------------
  |  |  639|  52.4k|  do {                                     \
  |  |  640|  52.4k|    (m) = MM_ABS(p1, p0);                  \
  |  |  ------------------
  |  |  |  |  252|  52.4k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  641|  52.4k|    (m) = _mm_max_epu8(m, MM_ABS(p3, p2)); \
  |  |  ------------------
  |  |  |  |  252|  52.4k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  642|  52.4k|    (m) = _mm_max_epu8(m, MM_ABS(p2, p1)); \
  |  |  ------------------
  |  |  |  |  252|  52.4k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  643|  52.4k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (643:12): [Folded, False: 52.4k]
  |  |  ------------------
  ------------------
  755|  52.4k|    LOAD_H_EDGES4(p, stride, p3, p2, tmp1, tmp2);
  ------------------
  |  |  653|  52.4k|  do {                                                    \
  |  |  654|  52.4k|    (e1) = _mm_loadu_si128((__m128i*)&(p)[0 * (stride)]); \
  |  |  655|  52.4k|    (e2) = _mm_loadu_si128((__m128i*)&(p)[1 * (stride)]); \
  |  |  656|  52.4k|    (e3) = _mm_loadu_si128((__m128i*)&(p)[2 * (stride)]); \
  |  |  657|  52.4k|    (e4) = _mm_loadu_si128((__m128i*)&(p)[3 * (stride)]); \
  |  |  658|  52.4k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (658:12): [Folded, False: 52.4k]
  |  |  ------------------
  ------------------
  756|  52.4k|    MAX_DIFF2(p3, p2, tmp1, tmp2, mask);
  ------------------
  |  |  646|  52.4k|  do {                                     \
  |  |  647|  52.4k|    (m) = _mm_max_epu8(m, MM_ABS(p1, p0)); \
  |  |  ------------------
  |  |  |  |  252|  52.4k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  648|  52.4k|    (m) = _mm_max_epu8(m, MM_ABS(p3, p2)); \
  |  |  ------------------
  |  |  |  |  252|  52.4k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  649|  52.4k|    (m) = _mm_max_epu8(m, MM_ABS(p2, p1)); \
  |  |  ------------------
  |  |  |  |  252|  52.4k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  650|  52.4k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (650:12): [Folded, False: 52.4k]
  |  |  ------------------
  ------------------
  757|       |
  758|       |    // p3 and p2 are not just temporary variables here: they will be
  759|       |    // re-used for next span. And q2/q3 will become p1/p0 accordingly.
  760|  52.4k|    ComplexMask_SSE2(&p1, &p0, &p3, &p2, thresh, ithresh, &mask);
  761|  52.4k|    DoFilter4_SSE2(&p1, &p0, &p3, &p2, &mask, hev_thresh);
  762|       |
  763|       |    // Store
  764|  52.4k|    _mm_storeu_si128((__m128i*)&b[0 * stride], p1);
  765|  52.4k|    _mm_storeu_si128((__m128i*)&b[1 * stride], p0);
  766|  52.4k|    _mm_storeu_si128((__m128i*)&b[2 * stride], p3);
  767|  52.4k|    _mm_storeu_si128((__m128i*)&b[3 * stride], p2);
  768|       |
  769|       |    // rotate samples
  770|  52.4k|    p1 = tmp1;
  771|  52.4k|    p0 = tmp2;
  772|  52.4k|  }
  773|  17.4k|}
dec_sse2.c:DoFilter4_SSE2:
  385|   139k|                                       int hev_thresh) {
  386|   139k|  const __m128i zero = _mm_setzero_si128();
  387|   139k|  const __m128i sign_bit = _mm_set1_epi8((char)0x80);
  388|   139k|  const __m128i k64 = _mm_set1_epi8(64);
  389|   139k|  const __m128i k3 = _mm_set1_epi8(3);
  390|   139k|  const __m128i k4 = _mm_set1_epi8(4);
  391|   139k|  __m128i not_hev;
  392|   139k|  __m128i t1, t2, t3;
  393|       |
  394|       |  // compute hev mask
  395|   139k|  GetNotHEV_SSE2(p1, p0, q0, q1, hev_thresh, &not_hev);
  396|       |
  397|       |  // convert to signed values
  398|   139k|  FLIP_SIGN_BIT4(*p1, *p0, *q0, *q1);
  ------------------
  |  |  271|   139k|  do {                             \
  |  |  272|   139k|    FLIP_SIGN_BIT2(a, b);          \
  |  |  ------------------
  |  |  |  |  265|   139k|  do {                                \
  |  |  |  |  266|   139k|    (a) = _mm_xor_si128(a, sign_bit); \
  |  |  |  |  267|   139k|    (b) = _mm_xor_si128(b, sign_bit); \
  |  |  |  |  268|   139k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (268:12): [Folded, False: 139k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  273|   139k|    FLIP_SIGN_BIT2(c, d);          \
  |  |  ------------------
  |  |  |  |  265|   139k|  do {                                \
  |  |  |  |  266|   139k|    (a) = _mm_xor_si128(a, sign_bit); \
  |  |  |  |  267|   139k|    (b) = _mm_xor_si128(b, sign_bit); \
  |  |  |  |  268|   139k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (268:12): [Folded, False: 139k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  274|   139k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (274:12): [Folded, False: 139k]
  |  |  ------------------
  ------------------
  399|       |
  400|   139k|  t1 = _mm_subs_epi8(*p1, *q1);        // p1 - q1
  401|   139k|  t1 = _mm_andnot_si128(not_hev, t1);  // hev(p1 - q1)
  402|   139k|  t2 = _mm_subs_epi8(*q0, *p0);        // q0 - p0
  403|   139k|  t1 = _mm_adds_epi8(t1, t2);          // hev(p1 - q1) + 1 * (q0 - p0)
  404|   139k|  t1 = _mm_adds_epi8(t1, t2);          // hev(p1 - q1) + 2 * (q0 - p0)
  405|   139k|  t1 = _mm_adds_epi8(t1, t2);          // hev(p1 - q1) + 3 * (q0 - p0)
  406|   139k|  t1 = _mm_and_si128(t1, *mask);       // mask filter values we don't care about
  407|       |
  408|   139k|  t2 = _mm_adds_epi8(t1, k3);    // 3 * (q0 - p0) + hev(p1 - q1) + 3
  409|   139k|  t3 = _mm_adds_epi8(t1, k4);    // 3 * (q0 - p0) + hev(p1 - q1) + 4
  410|   139k|  SignedShift8b_SSE2(&t2);       // (3 * (q0 - p0) + hev(p1 - q1) + 3) >> 3
  411|   139k|  SignedShift8b_SSE2(&t3);       // (3 * (q0 - p0) + hev(p1 - q1) + 4) >> 3
  412|   139k|  *p0 = _mm_adds_epi8(*p0, t2);  // p0 += t2
  413|   139k|  *q0 = _mm_subs_epi8(*q0, t3);  // q0 -= t3
  414|   139k|  FLIP_SIGN_BIT2(*p0, *q0);
  ------------------
  |  |  265|   139k|  do {                                \
  |  |  266|   139k|    (a) = _mm_xor_si128(a, sign_bit); \
  |  |  267|   139k|    (b) = _mm_xor_si128(b, sign_bit); \
  |  |  268|   139k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (268:12): [Folded, False: 139k]
  |  |  ------------------
  ------------------
  415|       |
  416|       |  // this is equivalent to signed (a + 1) >> 1 calculation
  417|   139k|  t2 = _mm_add_epi8(t3, sign_bit);
  418|   139k|  t3 = _mm_avg_epu8(t2, zero);
  419|   139k|  t3 = _mm_sub_epi8(t3, k64);
  420|       |
  421|   139k|  t3 = _mm_and_si128(not_hev, t3);  // if !hev
  422|   139k|  *q1 = _mm_subs_epi8(*q1, t3);     // q1 -= t3
  423|   139k|  *p1 = _mm_adds_epi8(*p1, t3);     // p1 += t3
  424|   139k|  FLIP_SIGN_BIT2(*p1, *q1);
  ------------------
  |  |  265|   139k|  do {                                \
  |  |  266|   139k|    (a) = _mm_xor_si128(a, sign_bit); \
  |  |  267|   139k|    (b) = _mm_xor_si128(b, sign_bit); \
  |  |  268|   139k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (268:12): [Folded, False: 139k]
  |  |  ------------------
  ------------------
  425|   139k|}
dec_sse2.c:HFilter16i_SSE2:
  776|  17.4k|                            int hev_thresh) {
  777|  17.4k|  int k;
  778|  17.4k|  __m128i p3, p2, p1, p0;  // loop invariants
  779|       |
  780|  17.4k|  Load16x4_SSE2(p, p + 8 * stride, stride, &p3, &p2, &p1, &p0);  // prologue
  781|       |
  782|  69.8k|  for (k = 3; k > 0; --k) {
  ------------------
  |  Branch (782:15): [True: 52.4k, False: 17.4k]
  ------------------
  783|  52.4k|    __m128i mask, tmp1, tmp2;
  784|  52.4k|    uint8_t* const b = p + 2;  // beginning of p1
  785|       |
  786|  52.4k|    p += 4;  // beginning of q0 (and next span)
  787|       |
  788|  52.4k|    MAX_DIFF1(p3, p2, p1, p0, mask);  // compute partial mask
  ------------------
  |  |  639|  52.4k|  do {                                     \
  |  |  640|  52.4k|    (m) = MM_ABS(p1, p0);                  \
  |  |  ------------------
  |  |  |  |  252|  52.4k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  641|  52.4k|    (m) = _mm_max_epu8(m, MM_ABS(p3, p2)); \
  |  |  ------------------
  |  |  |  |  252|  52.4k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  642|  52.4k|    (m) = _mm_max_epu8(m, MM_ABS(p2, p1)); \
  |  |  ------------------
  |  |  |  |  252|  52.4k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  643|  52.4k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (643:12): [Folded, False: 52.4k]
  |  |  ------------------
  ------------------
  789|  52.4k|    Load16x4_SSE2(p, p + 8 * stride, stride, &p3, &p2, &tmp1, &tmp2);
  790|  52.4k|    MAX_DIFF2(p3, p2, tmp1, tmp2, mask);
  ------------------
  |  |  646|  52.4k|  do {                                     \
  |  |  647|  52.4k|    (m) = _mm_max_epu8(m, MM_ABS(p1, p0)); \
  |  |  ------------------
  |  |  |  |  252|  52.4k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  648|  52.4k|    (m) = _mm_max_epu8(m, MM_ABS(p3, p2)); \
  |  |  ------------------
  |  |  |  |  252|  52.4k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  649|  52.4k|    (m) = _mm_max_epu8(m, MM_ABS(p2, p1)); \
  |  |  ------------------
  |  |  |  |  252|  52.4k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  650|  52.4k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (650:12): [Folded, False: 52.4k]
  |  |  ------------------
  ------------------
  791|       |
  792|  52.4k|    ComplexMask_SSE2(&p1, &p0, &p3, &p2, thresh, ithresh, &mask);
  793|  52.4k|    DoFilter4_SSE2(&p1, &p0, &p3, &p2, &mask, hev_thresh);
  794|       |
  795|  52.4k|    Store16x4_SSE2(&p1, &p0, &p3, &p2, b, b + 8 * stride, stride);
  796|       |
  797|       |    // rotate samples
  798|  52.4k|    p1 = tmp1;
  799|  52.4k|    p0 = tmp2;
  800|  52.4k|  }
  801|  17.4k|}
dec_sse2.c:VFilter8i_SSE2:
  851|  17.4k|                           int hev_thresh) {
  852|  17.4k|  __m128i mask;
  853|  17.4k|  __m128i t1, t2, p1, p0, q0, q1;
  854|       |
  855|       |  // Load p3, p2, p1, p0
  856|  17.4k|  LOADUV_H_EDGES4(u, v, stride, t2, t1, p1, p0);
  ------------------
  |  |  668|  17.4k|  do {                                                \
  |  |  669|  17.4k|    LOADUV_H_EDGE(e1, u, v, 0 * (stride));            \
  |  |  ------------------
  |  |  |  |  661|  17.4k|  do {                                                           \
  |  |  |  |  662|  17.4k|    const __m128i U = _mm_loadl_epi64((__m128i*)&(u)[(stride)]); \
  |  |  |  |  663|  17.4k|    const __m128i V = _mm_loadl_epi64((__m128i*)&(v)[(stride)]); \
  |  |  |  |  664|  17.4k|    (p) = _mm_unpacklo_epi64(U, V);                              \
  |  |  |  |  665|  17.4k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (665:12): [Folded, False: 17.4k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  670|  17.4k|    LOADUV_H_EDGE(e2, u, v, 1 * (stride));            \
  |  |  ------------------
  |  |  |  |  661|  17.4k|  do {                                                           \
  |  |  |  |  662|  17.4k|    const __m128i U = _mm_loadl_epi64((__m128i*)&(u)[(stride)]); \
  |  |  |  |  663|  17.4k|    const __m128i V = _mm_loadl_epi64((__m128i*)&(v)[(stride)]); \
  |  |  |  |  664|  17.4k|    (p) = _mm_unpacklo_epi64(U, V);                              \
  |  |  |  |  665|  17.4k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (665:12): [Folded, False: 17.4k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  671|  17.4k|    LOADUV_H_EDGE(e3, u, v, 2 * (stride));            \
  |  |  ------------------
  |  |  |  |  661|  17.4k|  do {                                                           \
  |  |  |  |  662|  17.4k|    const __m128i U = _mm_loadl_epi64((__m128i*)&(u)[(stride)]); \
  |  |  |  |  663|  17.4k|    const __m128i V = _mm_loadl_epi64((__m128i*)&(v)[(stride)]); \
  |  |  |  |  664|  17.4k|    (p) = _mm_unpacklo_epi64(U, V);                              \
  |  |  |  |  665|  17.4k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (665:12): [Folded, False: 17.4k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  672|  17.4k|    LOADUV_H_EDGE(e4, u, v, 3 * (stride));            \
  |  |  ------------------
  |  |  |  |  661|  17.4k|  do {                                                           \
  |  |  |  |  662|  17.4k|    const __m128i U = _mm_loadl_epi64((__m128i*)&(u)[(stride)]); \
  |  |  |  |  663|  17.4k|    const __m128i V = _mm_loadl_epi64((__m128i*)&(v)[(stride)]); \
  |  |  |  |  664|  17.4k|    (p) = _mm_unpacklo_epi64(U, V);                              \
  |  |  |  |  665|  17.4k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (665:12): [Folded, False: 17.4k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  673|  17.4k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (673:12): [Folded, False: 17.4k]
  |  |  ------------------
  ------------------
  857|  17.4k|  MAX_DIFF1(t2, t1, p1, p0, mask);
  ------------------
  |  |  639|  17.4k|  do {                                     \
  |  |  640|  17.4k|    (m) = MM_ABS(p1, p0);                  \
  |  |  ------------------
  |  |  |  |  252|  17.4k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  641|  17.4k|    (m) = _mm_max_epu8(m, MM_ABS(p3, p2)); \
  |  |  ------------------
  |  |  |  |  252|  17.4k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  642|  17.4k|    (m) = _mm_max_epu8(m, MM_ABS(p2, p1)); \
  |  |  ------------------
  |  |  |  |  252|  17.4k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  643|  17.4k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (643:12): [Folded, False: 17.4k]
  |  |  ------------------
  ------------------
  858|       |
  859|  17.4k|  u += 4 * stride;
  860|  17.4k|  v += 4 * stride;
  861|       |
  862|       |  // Load q0, q1, q2, q3
  863|  17.4k|  LOADUV_H_EDGES4(u, v, stride, q0, q1, t1, t2);
  ------------------
  |  |  668|  17.4k|  do {                                                \
  |  |  669|  17.4k|    LOADUV_H_EDGE(e1, u, v, 0 * (stride));            \
  |  |  ------------------
  |  |  |  |  661|  17.4k|  do {                                                           \
  |  |  |  |  662|  17.4k|    const __m128i U = _mm_loadl_epi64((__m128i*)&(u)[(stride)]); \
  |  |  |  |  663|  17.4k|    const __m128i V = _mm_loadl_epi64((__m128i*)&(v)[(stride)]); \
  |  |  |  |  664|  17.4k|    (p) = _mm_unpacklo_epi64(U, V);                              \
  |  |  |  |  665|  17.4k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (665:12): [Folded, False: 17.4k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  670|  17.4k|    LOADUV_H_EDGE(e2, u, v, 1 * (stride));            \
  |  |  ------------------
  |  |  |  |  661|  17.4k|  do {                                                           \
  |  |  |  |  662|  17.4k|    const __m128i U = _mm_loadl_epi64((__m128i*)&(u)[(stride)]); \
  |  |  |  |  663|  17.4k|    const __m128i V = _mm_loadl_epi64((__m128i*)&(v)[(stride)]); \
  |  |  |  |  664|  17.4k|    (p) = _mm_unpacklo_epi64(U, V);                              \
  |  |  |  |  665|  17.4k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (665:12): [Folded, False: 17.4k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  671|  17.4k|    LOADUV_H_EDGE(e3, u, v, 2 * (stride));            \
  |  |  ------------------
  |  |  |  |  661|  17.4k|  do {                                                           \
  |  |  |  |  662|  17.4k|    const __m128i U = _mm_loadl_epi64((__m128i*)&(u)[(stride)]); \
  |  |  |  |  663|  17.4k|    const __m128i V = _mm_loadl_epi64((__m128i*)&(v)[(stride)]); \
  |  |  |  |  664|  17.4k|    (p) = _mm_unpacklo_epi64(U, V);                              \
  |  |  |  |  665|  17.4k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (665:12): [Folded, False: 17.4k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  672|  17.4k|    LOADUV_H_EDGE(e4, u, v, 3 * (stride));            \
  |  |  ------------------
  |  |  |  |  661|  17.4k|  do {                                                           \
  |  |  |  |  662|  17.4k|    const __m128i U = _mm_loadl_epi64((__m128i*)&(u)[(stride)]); \
  |  |  |  |  663|  17.4k|    const __m128i V = _mm_loadl_epi64((__m128i*)&(v)[(stride)]); \
  |  |  |  |  664|  17.4k|    (p) = _mm_unpacklo_epi64(U, V);                              \
  |  |  |  |  665|  17.4k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (665:12): [Folded, False: 17.4k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  673|  17.4k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (673:12): [Folded, False: 17.4k]
  |  |  ------------------
  ------------------
  864|  17.4k|  MAX_DIFF2(t2, t1, q1, q0, mask);
  ------------------
  |  |  646|  17.4k|  do {                                     \
  |  |  647|  17.4k|    (m) = _mm_max_epu8(m, MM_ABS(p1, p0)); \
  |  |  ------------------
  |  |  |  |  252|  17.4k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  648|  17.4k|    (m) = _mm_max_epu8(m, MM_ABS(p3, p2)); \
  |  |  ------------------
  |  |  |  |  252|  17.4k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  649|  17.4k|    (m) = _mm_max_epu8(m, MM_ABS(p2, p1)); \
  |  |  ------------------
  |  |  |  |  252|  17.4k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  650|  17.4k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (650:12): [Folded, False: 17.4k]
  |  |  ------------------
  ------------------
  865|       |
  866|  17.4k|  ComplexMask_SSE2(&p1, &p0, &q0, &q1, thresh, ithresh, &mask);
  867|  17.4k|  DoFilter4_SSE2(&p1, &p0, &q0, &q1, &mask, hev_thresh);
  868|       |
  869|       |  // Store
  870|  17.4k|  STOREUV(p1, u, v, -2 * stride);
  ------------------
  |  |  676|  17.4k|  do {                                             \
  |  |  677|  17.4k|    _mm_storel_epi64((__m128i*)&(u)[(stride)], p); \
  |  |  678|  17.4k|    (p) = _mm_srli_si128(p, 8);                    \
  |  |  679|  17.4k|    _mm_storel_epi64((__m128i*)&(v)[(stride)], p); \
  |  |  680|  17.4k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (680:12): [Folded, False: 17.4k]
  |  |  ------------------
  ------------------
  871|  17.4k|  STOREUV(p0, u, v, -1 * stride);
  ------------------
  |  |  676|  17.4k|  do {                                             \
  |  |  677|  17.4k|    _mm_storel_epi64((__m128i*)&(u)[(stride)], p); \
  |  |  678|  17.4k|    (p) = _mm_srli_si128(p, 8);                    \
  |  |  679|  17.4k|    _mm_storel_epi64((__m128i*)&(v)[(stride)], p); \
  |  |  680|  17.4k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (680:12): [Folded, False: 17.4k]
  |  |  ------------------
  ------------------
  872|  17.4k|  STOREUV(q0, u, v, 0 * stride);
  ------------------
  |  |  676|  17.4k|  do {                                             \
  |  |  677|  17.4k|    _mm_storel_epi64((__m128i*)&(u)[(stride)], p); \
  |  |  678|  17.4k|    (p) = _mm_srli_si128(p, 8);                    \
  |  |  679|  17.4k|    _mm_storel_epi64((__m128i*)&(v)[(stride)], p); \
  |  |  680|  17.4k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (680:12): [Folded, False: 17.4k]
  |  |  ------------------
  ------------------
  873|       |  STOREUV(q1, u, v, 1 * stride);
  ------------------
  |  |  676|  17.4k|  do {                                             \
  |  |  677|  17.4k|    _mm_storel_epi64((__m128i*)&(u)[(stride)], p); \
  |  |  678|  17.4k|    (p) = _mm_srli_si128(p, 8);                    \
  |  |  679|  17.4k|    _mm_storel_epi64((__m128i*)&(v)[(stride)], p); \
  |  |  680|  17.4k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (680:12): [Folded, False: 17.4k]
  |  |  ------------------
  ------------------
  874|  17.4k|}
dec_sse2.c:HFilter8i_SSE2:
  878|  17.4k|                           int hev_thresh) {
  879|  17.4k|  __m128i mask;
  880|  17.4k|  __m128i t1, t2, p1, p0, q0, q1;
  881|  17.4k|  Load16x4_SSE2(u, v, stride, &t2, &t1, &p1, &p0);  // p3, p2, p1, p0
  882|  17.4k|  MAX_DIFF1(t2, t1, p1, p0, mask);
  ------------------
  |  |  639|  17.4k|  do {                                     \
  |  |  640|  17.4k|    (m) = MM_ABS(p1, p0);                  \
  |  |  ------------------
  |  |  |  |  252|  17.4k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  641|  17.4k|    (m) = _mm_max_epu8(m, MM_ABS(p3, p2)); \
  |  |  ------------------
  |  |  |  |  252|  17.4k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  642|  17.4k|    (m) = _mm_max_epu8(m, MM_ABS(p2, p1)); \
  |  |  ------------------
  |  |  |  |  252|  17.4k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  643|  17.4k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (643:12): [Folded, False: 17.4k]
  |  |  ------------------
  ------------------
  883|       |
  884|  17.4k|  u += 4;  // beginning of q0
  885|  17.4k|  v += 4;
  886|  17.4k|  Load16x4_SSE2(u, v, stride, &q0, &q1, &t1, &t2);  // q0, q1, q2, q3
  887|  17.4k|  MAX_DIFF2(t2, t1, q1, q0, mask);
  ------------------
  |  |  646|  17.4k|  do {                                     \
  |  |  647|  17.4k|    (m) = _mm_max_epu8(m, MM_ABS(p1, p0)); \
  |  |  ------------------
  |  |  |  |  252|  17.4k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  648|  17.4k|    (m) = _mm_max_epu8(m, MM_ABS(p3, p2)); \
  |  |  ------------------
  |  |  |  |  252|  17.4k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  649|  17.4k|    (m) = _mm_max_epu8(m, MM_ABS(p2, p1)); \
  |  |  ------------------
  |  |  |  |  252|  17.4k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  650|  17.4k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (650:12): [Folded, False: 17.4k]
  |  |  ------------------
  ------------------
  888|       |
  889|  17.4k|  ComplexMask_SSE2(&p1, &p0, &q0, &q1, thresh, ithresh, &mask);
  890|  17.4k|  DoFilter4_SSE2(&p1, &p0, &q0, &q1, &mask, hev_thresh);
  891|       |
  892|  17.4k|  u -= 2;  // beginning of p1
  893|  17.4k|  v -= 2;
  894|  17.4k|  Store16x4_SSE2(&p1, &p0, &q0, &q1, u, v, stride);
  895|  17.4k|}
dec_sse2.c:SimpleVFilter16_SSE2:
  595|  33.0k|static void SimpleVFilter16_SSE2(uint8_t* p, int stride, int thresh) {
  596|       |  // Load
  597|  33.0k|  __m128i p1 = _mm_loadu_si128((__m128i*)&p[-2 * stride]);
  598|  33.0k|  __m128i p0 = _mm_loadu_si128((__m128i*)&p[-stride]);
  599|  33.0k|  __m128i q0 = _mm_loadu_si128((__m128i*)&p[0]);
  600|  33.0k|  __m128i q1 = _mm_loadu_si128((__m128i*)&p[stride]);
  601|       |
  602|  33.0k|  DoFilter2_SSE2(&p1, &p0, &q0, &q1, thresh);
  603|       |
  604|       |  // Store
  605|  33.0k|  _mm_storeu_si128((__m128i*)&p[-stride], p0);
  606|  33.0k|  _mm_storeu_si128((__m128i*)&p[0], q0);
  607|  33.0k|}
dec_sse2.c:DoFilter2_SSE2:
  365|  63.4k|                                       int thresh) {
  366|  63.4k|  __m128i a, mask;
  367|  63.4k|  const __m128i sign_bit = _mm_set1_epi8((char)0x80);
  368|       |  // convert p1/q1 to int8_t (for GetBaseDelta_SSE2)
  369|  63.4k|  const __m128i p1s = _mm_xor_si128(*p1, sign_bit);
  370|  63.4k|  const __m128i q1s = _mm_xor_si128(*q1, sign_bit);
  371|       |
  372|  63.4k|  NeedsFilter_SSE2(p1, p0, q0, q1, thresh, &mask);
  373|       |
  374|  63.4k|  FLIP_SIGN_BIT2(*p0, *q0);
  ------------------
  |  |  265|  63.4k|  do {                                \
  |  |  266|  63.4k|    (a) = _mm_xor_si128(a, sign_bit); \
  |  |  267|  63.4k|    (b) = _mm_xor_si128(b, sign_bit); \
  |  |  268|  63.4k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (268:12): [Folded, False: 63.4k]
  |  |  ------------------
  ------------------
  375|  63.4k|  GetBaseDelta_SSE2(&p1s, p0, q0, &q1s, &a);
  376|  63.4k|  a = _mm_and_si128(a, mask);  // mask filter values we don't care about
  377|  63.4k|  DoSimpleFilter_SSE2(p0, q0, &a);
  378|  63.4k|  FLIP_SIGN_BIT2(*p0, *q0);
  ------------------
  |  |  265|  63.4k|  do {                                \
  |  |  266|  63.4k|    (a) = _mm_xor_si128(a, sign_bit); \
  |  |  267|  63.4k|    (b) = _mm_xor_si128(b, sign_bit); \
  |  |  268|  63.4k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (268:12): [Folded, False: 63.4k]
  |  |  ------------------
  ------------------
  379|  63.4k|}
dec_sse2.c:SimpleHFilter16_SSE2:
  609|  30.3k|static void SimpleHFilter16_SSE2(uint8_t* p, int stride, int thresh) {
  610|  30.3k|  __m128i p1, p0, q0, q1;
  611|       |
  612|  30.3k|  p -= 2;  // beginning of p1
  613|       |
  614|  30.3k|  Load16x4_SSE2(p, p + 8 * stride, stride, &p1, &p0, &q0, &q1);
  615|  30.3k|  DoFilter2_SSE2(&p1, &p0, &q0, &q1, thresh);
  616|  30.3k|  Store16x4_SSE2(&p1, &p0, &q0, &q1, p, p + 8 * stride, stride);
  617|  30.3k|}
dec_sse2.c:SimpleVFilter16i_SSE2:
  619|  8.36k|static void SimpleVFilter16i_SSE2(uint8_t* p, int stride, int thresh) {
  620|  8.36k|  int k;
  621|  33.4k|  for (k = 3; k > 0; --k) {
  ------------------
  |  Branch (621:15): [True: 25.0k, False: 8.36k]
  ------------------
  622|  25.0k|    p += 4 * stride;
  623|  25.0k|    SimpleVFilter16_SSE2(p, stride, thresh);
  624|  25.0k|  }
  625|  8.36k|}
dec_sse2.c:SimpleHFilter16i_SSE2:
  627|  8.36k|static void SimpleHFilter16i_SSE2(uint8_t* p, int stride, int thresh) {
  628|  8.36k|  int k;
  629|  33.4k|  for (k = 3; k > 0; --k) {
  ------------------
  |  Branch (629:15): [True: 25.0k, False: 8.36k]
  ------------------
  630|  25.0k|    p += 4;
  631|  25.0k|    SimpleHFilter16_SSE2(p, stride, thresh);
  632|  25.0k|  }
  633|  8.36k|}
dec_sse2.c:TM4_SSE2:
 1060|  23.9k|static void TM4_SSE2(uint8_t* dst) { TrueMotion_SSE2(dst, 4); }
dec_sse2.c:TrueMotion_SSE2:
 1023|  51.7k|static WEBP_INLINE void TrueMotion_SSE2(uint8_t* dst, int size) {
 1024|  51.7k|  const uint8_t* top = dst - BPS;
  ------------------
  |  |   33|  51.7k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
 1025|  51.7k|  const __m128i zero = _mm_setzero_si128();
 1026|  51.7k|  int y;
 1027|  51.7k|  if (size == 4) {
  ------------------
  |  Branch (1027:7): [True: 23.9k, False: 27.8k]
  ------------------
 1028|  23.9k|    const __m128i top_values = _mm_cvtsi32_si128(WebPMemToInt32(top));
 1029|  23.9k|    const __m128i top_base = _mm_unpacklo_epi8(top_values, zero);
 1030|   119k|    for (y = 0; y < 4; ++y, dst += BPS) {
  ------------------
  |  |   33|  95.8k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  |  Branch (1030:17): [True: 95.8k, False: 23.9k]
  ------------------
 1031|  95.8k|      const int val = dst[-1] - top[-1];
 1032|  95.8k|      const __m128i base = _mm_set1_epi16(val);
 1033|  95.8k|      const __m128i out = _mm_packus_epi16(_mm_add_epi16(base, top_base), zero);
 1034|  95.8k|      WebPInt32ToMem(dst, _mm_cvtsi128_si32(out));
 1035|  95.8k|    }
 1036|  27.8k|  } else if (size == 8) {
  ------------------
  |  Branch (1036:14): [True: 16.8k, False: 10.9k]
  ------------------
 1037|  16.8k|    const __m128i top_values = _mm_loadl_epi64((const __m128i*)top);
 1038|  16.8k|    const __m128i top_base = _mm_unpacklo_epi8(top_values, zero);
 1039|   151k|    for (y = 0; y < 8; ++y, dst += BPS) {
  ------------------
  |  |   33|   134k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  |  Branch (1039:17): [True: 134k, False: 16.8k]
  ------------------
 1040|   134k|      const int val = dst[-1] - top[-1];
 1041|   134k|      const __m128i base = _mm_set1_epi16(val);
 1042|   134k|      const __m128i out = _mm_packus_epi16(_mm_add_epi16(base, top_base), zero);
 1043|   134k|      _mm_storel_epi64((__m128i*)dst, out);
 1044|   134k|    }
 1045|  16.8k|  } else {
 1046|  10.9k|    const __m128i top_values = _mm_loadu_si128((const __m128i*)top);
 1047|  10.9k|    const __m128i top_base_0 = _mm_unpacklo_epi8(top_values, zero);
 1048|  10.9k|    const __m128i top_base_1 = _mm_unpackhi_epi8(top_values, zero);
 1049|   186k|    for (y = 0; y < 16; ++y, dst += BPS) {
  ------------------
  |  |   33|   175k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  |  Branch (1049:17): [True: 175k, False: 10.9k]
  ------------------
 1050|   175k|      const int val = dst[-1] - top[-1];
 1051|   175k|      const __m128i base = _mm_set1_epi16(val);
 1052|   175k|      const __m128i out_0 = _mm_add_epi16(base, top_base_0);
 1053|   175k|      const __m128i out_1 = _mm_add_epi16(base, top_base_1);
 1054|   175k|      const __m128i out = _mm_packus_epi16(out_0, out_1);
 1055|   175k|      _mm_storeu_si128((__m128i*)dst, out);
 1056|   175k|    }
 1057|  10.9k|  }
 1058|  51.7k|}
dec_sse2.c:VE4_SSE2:
  911|  8.93k|static void VE4_SSE2(uint8_t* dst) {  // vertical
  912|  8.93k|  const __m128i one = _mm_set1_epi8(1);
  913|  8.93k|  const __m128i ABCDEFGH = _mm_loadl_epi64((__m128i*)(dst - BPS - 1));
  ------------------
  |  |   33|  8.93k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  914|  8.93k|  const __m128i BCDEFGH0 = _mm_srli_si128(ABCDEFGH, 1);
  915|  8.93k|  const __m128i CDEFGH00 = _mm_srli_si128(ABCDEFGH, 2);
  916|  8.93k|  const __m128i a = _mm_avg_epu8(ABCDEFGH, CDEFGH00);
  917|  8.93k|  const __m128i lsb = _mm_and_si128(_mm_xor_si128(ABCDEFGH, CDEFGH00), one);
  918|  8.93k|  const __m128i b = _mm_subs_epu8(a, lsb);
  919|  8.93k|  const __m128i avg = _mm_avg_epu8(b, BCDEFGH0);
  920|  8.93k|  const int vals = _mm_cvtsi128_si32(avg);
  921|  8.93k|  int i;
  922|  44.6k|  for (i = 0; i < 4; ++i) {
  ------------------
  |  Branch (922:15): [True: 35.7k, False: 8.93k]
  ------------------
  923|  35.7k|    WebPInt32ToMem(dst + i * BPS, vals);
  ------------------
  |  |   33|  35.7k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  924|  35.7k|  }
  925|  8.93k|}
dec_sse2.c:RD4_SSE2:
  994|  2.56k|static void RD4_SSE2(uint8_t* dst) {  // Down-right
  995|  2.56k|  const __m128i one = _mm_set1_epi8(1);
  996|  2.56k|  const __m128i XABCD = _mm_loadl_epi64((__m128i*)(dst - BPS - 1));
  ------------------
  |  |   33|  2.56k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  997|  2.56k|  const __m128i ____XABCD = _mm_slli_si128(XABCD, 4);
  998|  2.56k|  const uint32_t I = dst[-1 + 0 * BPS];
  ------------------
  |  |   33|  2.56k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  999|  2.56k|  const uint32_t J = dst[-1 + 1 * BPS];
  ------------------
  |  |   33|  2.56k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
 1000|  2.56k|  const uint32_t K = dst[-1 + 2 * BPS];
  ------------------
  |  |   33|  2.56k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
 1001|  2.56k|  const uint32_t L = dst[-1 + 3 * BPS];
  ------------------
  |  |   33|  2.56k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
 1002|  2.56k|  const __m128i LKJI_____ =
 1003|  2.56k|      _mm_cvtsi32_si128((int)(L | (K << 8) | (J << 16) | (I << 24)));
 1004|  2.56k|  const __m128i LKJIXABCD = _mm_or_si128(LKJI_____, ____XABCD);
 1005|  2.56k|  const __m128i KJIXABCD_ = _mm_srli_si128(LKJIXABCD, 1);
 1006|  2.56k|  const __m128i JIXABCD__ = _mm_srli_si128(LKJIXABCD, 2);
 1007|  2.56k|  const __m128i avg1 = _mm_avg_epu8(JIXABCD__, LKJIXABCD);
 1008|  2.56k|  const __m128i lsb = _mm_and_si128(_mm_xor_si128(JIXABCD__, LKJIXABCD), one);
 1009|  2.56k|  const __m128i avg2 = _mm_subs_epu8(avg1, lsb);
 1010|  2.56k|  const __m128i abcdefg = _mm_avg_epu8(avg2, KJIXABCD_);
 1011|  2.56k|  WebPInt32ToMem(dst + 3 * BPS, _mm_cvtsi128_si32(abcdefg));
  ------------------
  |  |   33|  2.56k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
 1012|  2.56k|  WebPInt32ToMem(dst + 2 * BPS, _mm_cvtsi128_si32(_mm_srli_si128(abcdefg, 1)));
  ------------------
  |  |   33|  2.56k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
 1013|  2.56k|  WebPInt32ToMem(dst + 1 * BPS, _mm_cvtsi128_si32(_mm_srli_si128(abcdefg, 2)));
  ------------------
  |  |   33|  2.56k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
 1014|  2.56k|  WebPInt32ToMem(dst + 0 * BPS, _mm_cvtsi128_si32(_mm_srli_si128(abcdefg, 3)));
  ------------------
  |  |   33|  2.56k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
 1015|  2.56k|}
dec_sse2.c:VR4_SSE2:
  943|  3.40k|static void VR4_SSE2(uint8_t* dst) {  // Vertical-Right
  944|  3.40k|  const __m128i one = _mm_set1_epi8(1);
  945|  3.40k|  const int I = dst[-1 + 0 * BPS];
  ------------------
  |  |   33|  3.40k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  946|  3.40k|  const int J = dst[-1 + 1 * BPS];
  ------------------
  |  |   33|  3.40k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  947|  3.40k|  const int K = dst[-1 + 2 * BPS];
  ------------------
  |  |   33|  3.40k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  948|  3.40k|  const int X = dst[-1 - BPS];
  ------------------
  |  |   33|  3.40k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  949|  3.40k|  const __m128i XABCD = _mm_loadl_epi64((__m128i*)(dst - BPS - 1));
  ------------------
  |  |   33|  3.40k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  950|  3.40k|  const __m128i ABCD0 = _mm_srli_si128(XABCD, 1);
  951|  3.40k|  const __m128i abcd = _mm_avg_epu8(XABCD, ABCD0);
  952|  3.40k|  const __m128i _XABCD = _mm_slli_si128(XABCD, 1);
  953|  3.40k|  const __m128i IXABCD = _mm_insert_epi16(_XABCD, (short)(I | (X << 8)), 0);
  954|  3.40k|  const __m128i avg1 = _mm_avg_epu8(IXABCD, ABCD0);
  955|  3.40k|  const __m128i lsb = _mm_and_si128(_mm_xor_si128(IXABCD, ABCD0), one);
  956|  3.40k|  const __m128i avg2 = _mm_subs_epu8(avg1, lsb);
  957|  3.40k|  const __m128i efgh = _mm_avg_epu8(avg2, XABCD);
  958|  3.40k|  WebPInt32ToMem(dst + 0 * BPS, _mm_cvtsi128_si32(abcd));
  ------------------
  |  |   33|  3.40k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  959|  3.40k|  WebPInt32ToMem(dst + 1 * BPS, _mm_cvtsi128_si32(efgh));
  ------------------
  |  |   33|  3.40k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  960|  3.40k|  WebPInt32ToMem(dst + 2 * BPS, _mm_cvtsi128_si32(_mm_slli_si128(abcd, 1)));
  ------------------
  |  |   33|  3.40k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  961|  3.40k|  WebPInt32ToMem(dst + 3 * BPS, _mm_cvtsi128_si32(_mm_slli_si128(efgh, 1)));
  ------------------
  |  |   33|  3.40k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  962|       |
  963|       |  // these two are hard to implement in SSE2, so we keep the C-version:
  964|  3.40k|  DST(0, 2) = AVG3(J, I, X);
  ------------------
  |  |  900|  3.40k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  3.40k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(0, 2) = AVG3(J, I, X);
  ------------------
  |  |  901|  3.40k|#define AVG3(a, b, c) (((a) + 2 * (b) + (c) + 2) >> 2)
  ------------------
  965|  3.40k|  DST(0, 3) = AVG3(K, J, I);
  ------------------
  |  |  900|  3.40k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  3.40k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(0, 3) = AVG3(K, J, I);
  ------------------
  |  |  901|  3.40k|#define AVG3(a, b, c) (((a) + 2 * (b) + (c) + 2) >> 2)
  ------------------
  966|  3.40k|}
dec_sse2.c:LD4_SSE2:
  927|  3.79k|static void LD4_SSE2(uint8_t* dst) {  // Down-Left
  928|  3.79k|  const __m128i one = _mm_set1_epi8(1);
  929|  3.79k|  const __m128i ABCDEFGH = _mm_loadl_epi64((__m128i*)(dst - BPS));
  ------------------
  |  |   33|  3.79k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  930|  3.79k|  const __m128i BCDEFGH0 = _mm_srli_si128(ABCDEFGH, 1);
  931|  3.79k|  const __m128i CDEFGH00 = _mm_srli_si128(ABCDEFGH, 2);
  932|  3.79k|  const __m128i CDEFGHH0 = _mm_insert_epi16(CDEFGH00, dst[-BPS + 7], 3);
  933|  3.79k|  const __m128i avg1 = _mm_avg_epu8(ABCDEFGH, CDEFGHH0);
  934|  3.79k|  const __m128i lsb = _mm_and_si128(_mm_xor_si128(ABCDEFGH, CDEFGHH0), one);
  935|  3.79k|  const __m128i avg2 = _mm_subs_epu8(avg1, lsb);
  936|  3.79k|  const __m128i abcdefg = _mm_avg_epu8(avg2, BCDEFGH0);
  937|  3.79k|  WebPInt32ToMem(dst + 0 * BPS, _mm_cvtsi128_si32(abcdefg));
  ------------------
  |  |   33|  3.79k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  938|  3.79k|  WebPInt32ToMem(dst + 1 * BPS, _mm_cvtsi128_si32(_mm_srli_si128(abcdefg, 1)));
  ------------------
  |  |   33|  3.79k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  939|  3.79k|  WebPInt32ToMem(dst + 2 * BPS, _mm_cvtsi128_si32(_mm_srli_si128(abcdefg, 2)));
  ------------------
  |  |   33|  3.79k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  940|  3.79k|  WebPInt32ToMem(dst + 3 * BPS, _mm_cvtsi128_si32(_mm_srli_si128(abcdefg, 3)));
  ------------------
  |  |   33|  3.79k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  941|  3.79k|}
dec_sse2.c:VL4_SSE2:
  968|  4.17k|static void VL4_SSE2(uint8_t* dst) {  // Vertical-Left
  969|  4.17k|  const __m128i one = _mm_set1_epi8(1);
  970|  4.17k|  const __m128i ABCDEFGH = _mm_loadl_epi64((__m128i*)(dst - BPS));
  ------------------
  |  |   33|  4.17k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  971|  4.17k|  const __m128i BCDEFGH_ = _mm_srli_si128(ABCDEFGH, 1);
  972|  4.17k|  const __m128i CDEFGH__ = _mm_srli_si128(ABCDEFGH, 2);
  973|  4.17k|  const __m128i avg1 = _mm_avg_epu8(ABCDEFGH, BCDEFGH_);
  974|  4.17k|  const __m128i avg2 = _mm_avg_epu8(CDEFGH__, BCDEFGH_);
  975|  4.17k|  const __m128i avg3 = _mm_avg_epu8(avg1, avg2);
  976|  4.17k|  const __m128i lsb1 = _mm_and_si128(_mm_xor_si128(avg1, avg2), one);
  977|  4.17k|  const __m128i ab = _mm_xor_si128(ABCDEFGH, BCDEFGH_);
  978|  4.17k|  const __m128i bc = _mm_xor_si128(CDEFGH__, BCDEFGH_);
  979|  4.17k|  const __m128i abbc = _mm_or_si128(ab, bc);
  980|  4.17k|  const __m128i lsb2 = _mm_and_si128(abbc, lsb1);
  981|  4.17k|  const __m128i avg4 = _mm_subs_epu8(avg3, lsb2);
  982|  4.17k|  const uint32_t extra_out =
  983|  4.17k|      (uint32_t)_mm_cvtsi128_si32(_mm_srli_si128(avg4, 4));
  984|  4.17k|  WebPInt32ToMem(dst + 0 * BPS, _mm_cvtsi128_si32(avg1));
  ------------------
  |  |   33|  4.17k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  985|  4.17k|  WebPInt32ToMem(dst + 1 * BPS, _mm_cvtsi128_si32(avg4));
  ------------------
  |  |   33|  4.17k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  986|  4.17k|  WebPInt32ToMem(dst + 2 * BPS, _mm_cvtsi128_si32(_mm_srli_si128(avg1, 1)));
  ------------------
  |  |   33|  4.17k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  987|  4.17k|  WebPInt32ToMem(dst + 3 * BPS, _mm_cvtsi128_si32(_mm_srli_si128(avg4, 1)));
  ------------------
  |  |   33|  4.17k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  988|       |
  989|       |  // these two are hard to get and irregular
  990|  4.17k|  DST(3, 2) = (extra_out >> 0) & 0xff;
  ------------------
  |  |  900|  4.17k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  4.17k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
  991|  4.17k|  DST(3, 3) = (extra_out >> 8) & 0xff;
  ------------------
  |  |  900|  4.17k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  4.17k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
  992|  4.17k|}
dec_sse2.c:DC16_SSE2:
 1089|    527|static void DC16_SSE2(uint8_t* dst) {  // DC
 1090|    527|  const __m128i zero = _mm_setzero_si128();
 1091|    527|  const __m128i top = _mm_loadu_si128((const __m128i*)(dst - BPS));
  ------------------
  |  |   33|    527|#define BPS 32  // this is the common stride for enc/dec
  ------------------
 1092|    527|  const __m128i sad8x2 = _mm_sad_epu8(top, zero);
 1093|       |  // sum the two sads: sad8x2[0:1] + sad8x2[8:9]
 1094|    527|  const __m128i sum = _mm_add_epi16(sad8x2, _mm_shuffle_epi32(sad8x2, 2));
 1095|    527|  int left = 0;
 1096|    527|  int j;
 1097|  8.95k|  for (j = 0; j < 16; ++j) {
  ------------------
  |  Branch (1097:15): [True: 8.43k, False: 527]
  ------------------
 1098|  8.43k|    left += dst[-1 + j * BPS];
  ------------------
  |  |   33|  8.43k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
 1099|  8.43k|  }
 1100|    527|  {
 1101|    527|    const int DC = _mm_cvtsi128_si32(sum) + left + 16;
 1102|    527|    Put16_SSE2(DC >> 5, dst);
 1103|    527|  }
 1104|    527|}
dec_sse2.c:Put16_SSE2:
 1081|  13.6k|static WEBP_INLINE void Put16_SSE2(uint8_t v, uint8_t* dst) {
 1082|  13.6k|  int j;
 1083|  13.6k|  const __m128i values = _mm_set1_epi8((char)v);
 1084|   232k|  for (j = 0; j < 16; ++j) {
  ------------------
  |  Branch (1084:15): [True: 218k, False: 13.6k]
  ------------------
 1085|   218k|    _mm_storeu_si128((__m128i*)(dst + j * BPS), values);
  ------------------
  |  |   33|   218k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
 1086|   218k|  }
 1087|  13.6k|}
dec_sse2.c:TM16_SSE2:
 1062|  10.9k|static void TM16_SSE2(uint8_t* dst) { TrueMotion_SSE2(dst, 16); }
dec_sse2.c:VE16_SSE2:
 1064|  3.98k|static void VE16_SSE2(uint8_t* dst) {
 1065|  3.98k|  const __m128i top = _mm_loadu_si128((const __m128i*)(dst - BPS));
  ------------------
  |  |   33|  3.98k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
 1066|  3.98k|  int j;
 1067|  67.7k|  for (j = 0; j < 16; ++j) {
  ------------------
  |  Branch (1067:15): [True: 63.7k, False: 3.98k]
  ------------------
 1068|  63.7k|    _mm_storeu_si128((__m128i*)(dst + j * BPS), top);
  ------------------
  |  |   33|  63.7k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
 1069|  63.7k|  }
 1070|  3.98k|}
dec_sse2.c:DC16NoTop_SSE2:
 1106|  5.05k|static void DC16NoTop_SSE2(uint8_t* dst) {  // DC with top samples unavailable
 1107|  5.05k|  int DC = 8;
 1108|  5.05k|  int j;
 1109|  85.9k|  for (j = 0; j < 16; ++j) {
  ------------------
  |  Branch (1109:15): [True: 80.8k, False: 5.05k]
  ------------------
 1110|  80.8k|    DC += dst[-1 + j * BPS];
  ------------------
  |  |   33|  80.8k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
 1111|  80.8k|  }
 1112|  5.05k|  Put16_SSE2(DC >> 4, dst);
 1113|  5.05k|}
dec_sse2.c:DC16NoLeft_SSE2:
 1115|  7.58k|static void DC16NoLeft_SSE2(uint8_t* dst) {  // DC with left samples unavailable
 1116|  7.58k|  const __m128i zero = _mm_setzero_si128();
 1117|  7.58k|  const __m128i top = _mm_loadu_si128((const __m128i*)(dst - BPS));
  ------------------
  |  |   33|  7.58k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
 1118|  7.58k|  const __m128i sad8x2 = _mm_sad_epu8(top, zero);
 1119|       |  // sum the two sads: sad8x2[0:1] + sad8x2[8:9]
 1120|       |  const __m128i sum = _mm_add_epi16(sad8x2, _mm_shuffle_epi32(sad8x2, 2));
 1121|  7.58k|  const int DC = _mm_cvtsi128_si32(sum) + 8;
 1122|  7.58k|  Put16_SSE2(DC >> 4, dst);
 1123|  7.58k|}
dec_sse2.c:DC16NoTopLeft_SSE2:
 1125|    483|static void DC16NoTopLeft_SSE2(uint8_t* dst) {  // DC with no top & left samples
 1126|    483|  Put16_SSE2(0x80, dst);
 1127|    483|}
dec_sse2.c:DC8uv_SSE2:
 1149|  2.29k|static void DC8uv_SSE2(uint8_t* dst) {  // DC
 1150|  2.29k|  const __m128i zero = _mm_setzero_si128();
 1151|  2.29k|  const __m128i top = _mm_loadl_epi64((const __m128i*)(dst - BPS));
  ------------------
  |  |   33|  2.29k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
 1152|  2.29k|  const __m128i sum = _mm_sad_epu8(top, zero);
 1153|  2.29k|  int left = 0;
 1154|  2.29k|  int j;
 1155|  20.6k|  for (j = 0; j < 8; ++j) {
  ------------------
  |  Branch (1155:15): [True: 18.3k, False: 2.29k]
  ------------------
 1156|  18.3k|    left += dst[-1 + j * BPS];
  ------------------
  |  |   33|  18.3k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
 1157|  18.3k|  }
 1158|  2.29k|  {
 1159|  2.29k|    const int DC = _mm_cvtsi128_si32(sum) + left + 8;
 1160|  2.29k|    Put8x8uv_SSE2(DC >> 4, dst);
 1161|  2.29k|  }
 1162|  2.29k|}
dec_sse2.c:Put8x8uv_SSE2:
 1141|  59.9k|static WEBP_INLINE void Put8x8uv_SSE2(uint8_t v, uint8_t* dst) {
 1142|  59.9k|  int j;
 1143|  59.9k|  const __m128i values = _mm_set1_epi8((char)v);
 1144|   539k|  for (j = 0; j < 8; ++j) {
  ------------------
  |  Branch (1144:15): [True: 479k, False: 59.9k]
  ------------------
 1145|   479k|    _mm_storel_epi64((__m128i*)(dst + j * BPS), values);
  ------------------
  |  |   33|   479k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
 1146|   479k|  }
 1147|  59.9k|}
dec_sse2.c:TM8uv_SSE2:
 1061|  16.8k|static void TM8uv_SSE2(uint8_t* dst) { TrueMotion_SSE2(dst, 8); }
dec_sse2.c:VE8uv_SSE2:
 1132|  14.7k|static void VE8uv_SSE2(uint8_t* dst) {  // vertical
 1133|  14.7k|  int j;
 1134|  14.7k|  const __m128i top = _mm_loadl_epi64((const __m128i*)(dst - BPS));
  ------------------
  |  |   33|  14.7k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
 1135|   133k|  for (j = 0; j < 8; ++j) {
  ------------------
  |  Branch (1135:15): [True: 118k, False: 14.7k]
  ------------------
 1136|   118k|    _mm_storel_epi64((__m128i*)(dst + j * BPS), top);
  ------------------
  |  |   33|   118k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
 1137|   118k|  }
 1138|  14.7k|}
dec_sse2.c:DC8uvNoTop_SSE2:
 1172|  22.1k|static void DC8uvNoTop_SSE2(uint8_t* dst) {  // DC with no top samples
 1173|  22.1k|  int dc0 = 4;
 1174|  22.1k|  int i;
 1175|   199k|  for (i = 0; i < 8; ++i) {
  ------------------
  |  Branch (1175:15): [True: 177k, False: 22.1k]
  ------------------
 1176|   177k|    dc0 += dst[-1 + i * BPS];
  ------------------
  |  |   33|   177k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
 1177|   177k|  }
 1178|  22.1k|  Put8x8uv_SSE2(dc0 >> 3, dst);
 1179|  22.1k|}
dec_sse2.c:DC8uvNoLeft_SSE2:
 1164|  33.2k|static void DC8uvNoLeft_SSE2(uint8_t* dst) {  // DC with no left samples
 1165|  33.2k|  const __m128i zero = _mm_setzero_si128();
 1166|  33.2k|  const __m128i top = _mm_loadl_epi64((const __m128i*)(dst - BPS));
  ------------------
  |  |   33|  33.2k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
 1167|  33.2k|  const __m128i sum = _mm_sad_epu8(top, zero);
 1168|  33.2k|  const int DC = _mm_cvtsi128_si32(sum) + 4;
 1169|  33.2k|  Put8x8uv_SSE2(DC >> 3, dst);
 1170|  33.2k|}
dec_sse2.c:DC8uvNoTopLeft_SSE2:
 1181|  2.32k|static void DC8uvNoTopLeft_SSE2(uint8_t* dst) {  // DC with nothing
 1182|  2.32k|  Put8x8uv_SSE2(0x80, dst);
 1183|  2.32k|}

VP8DspInitSSE41:
   41|      1|WEBP_TSAN_IGNORE_FUNCTION void VP8DspInitSSE41(void) {
   42|      1|  VP8PredLuma16[3] = HE16_SSE41;
   43|      1|}
dec_sse41.c:HE16_SSE41:
   25|  4.86k|static void HE16_SSE41(uint8_t* dst) {  // horizontal
   26|  4.86k|  int j;
   27|  4.86k|  const __m128i kShuffle3 = _mm_set1_epi8(3);
   28|  82.6k|  for (j = 16; j > 0; --j) {
  ------------------
  |  Branch (28:16): [True: 77.7k, False: 4.86k]
  ------------------
   29|  77.7k|    const __m128i in = _mm_cvtsi32_si128(WebPMemToInt32(dst - 4));
   30|  77.7k|    const __m128i values = _mm_shuffle_epi8(in, kShuffle3);
   31|  77.7k|    _mm_storeu_si128((__m128i*)dst, values);
   32|  77.7k|    dst += BPS;
  ------------------
  |  |   33|  77.7k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
   33|  77.7k|  }
   34|  4.86k|}

VP8LPredictor2_C:
  126|   372k|                          const uint32_t* const top) {
  127|   372k|  (void)left;
  128|   372k|  return top[0];
  129|   372k|}
VP8LPredictor3_C:
  131|  19.1k|                          const uint32_t* const top) {
  132|  19.1k|  (void)left;
  133|  19.1k|  return top[1];
  134|  19.1k|}
VP8LPredictor4_C:
  136|  13.5k|                          const uint32_t* const top) {
  137|  13.5k|  (void)left;
  138|  13.5k|  return top[-1];
  139|  13.5k|}
VP8LPredictor8_C:
  156|  19.7k|                          const uint32_t* const top) {
  157|  19.7k|  const uint32_t pred = Average2(top[-1], top[0]);
  158|  19.7k|  (void)left;
  159|  19.7k|  return pred;
  160|  19.7k|}
VP8LPredictor9_C:
  162|  25.4k|                          const uint32_t* const top) {
  163|  25.4k|  const uint32_t pred = Average2(top[0], top[1]);
  164|  25.4k|  (void)left;
  165|  25.4k|  return pred;
  166|  25.4k|}
VP8LPredictor10_C:
  168|  37.0k|                           const uint32_t* const top) {
  169|  37.0k|  const uint32_t pred = Average4(*left, top[-1], top[0], top[1]);
  170|  37.0k|  return pred;
  171|  37.0k|}
VP8LPredictor11_C:
  173|  53.8k|                           const uint32_t* const top) {
  174|  53.8k|  const uint32_t pred = Select(top[0], *left, top[-1]);
  175|  53.8k|  return pred;
  176|  53.8k|}
VP8LPredictor12_C:
  178|  33.5k|                           const uint32_t* const top) {
  179|  33.5k|  const uint32_t pred = ClampedAddSubtractFull(*left, top[0], top[-1]);
  180|  33.5k|  return pred;
  181|  33.5k|}
VP8LAddGreenToBlueAndRed_C:
  266|     57|                                uint32_t* dst) {
  267|     57|  int i;
  268|    187|  for (i = 0; i < num_pixels; ++i) {
  ------------------
  |  Branch (268:15): [True: 130, False: 57]
  ------------------
  269|    130|    const uint32_t argb = src[i];
  270|    130|    const uint32_t green = ((argb >> 8) & 0xff);
  271|    130|    uint32_t red_blue = (argb & 0x00ff00ffu);
  272|    130|    red_blue += (green << 16) | green;
  273|    130|    red_blue &= 0x00ff00ffu;
  274|    130|    dst[i] = (argb & 0xff00ff00u) | red_blue;
  275|    130|  }
  276|     57|}
VP8LTransformColorInverse_C:
  291|  55.6k|                                 uint32_t* dst) {
  292|  55.6k|  int i;
  293|   155k|  for (i = 0; i < num_pixels; ++i) {
  ------------------
  |  Branch (293:15): [True: 100k, False: 55.6k]
  ------------------
  294|   100k|    const uint32_t argb = src[i];
  295|   100k|    const int8_t green = (int8_t)(argb >> 8);
  296|   100k|    const uint32_t red = argb >> 16;
  297|   100k|    int new_red = red & 0xff;
  298|   100k|    int new_blue = argb & 0xff;
  299|   100k|    new_red += ColorTransformDelta((int8_t)m->green_to_red, green);
  300|   100k|    new_red &= 0xff;
  301|   100k|    new_blue += ColorTransformDelta((int8_t)m->green_to_blue, green);
  302|   100k|    new_blue += ColorTransformDelta((int8_t)m->red_to_blue, (int8_t)new_red);
  303|   100k|    new_blue &= 0xff;
  304|   100k|    dst[i] = (argb & 0xff00ff00u) | (new_red << 16) | (new_blue);
  305|   100k|  }
  306|  55.6k|}
VP8LInverseTransform:
  426|  59.8k|                          uint32_t* const out) {
  427|  59.8k|  const int width = transform->xsize;
  428|  59.8k|  assert(row_start < row_end);
  429|  59.8k|  assert(row_end <= transform->ysize);
  430|  59.8k|  switch (transform->type) {
  ------------------
  |  Branch (430:11): [True: 59.8k, False: 0]
  ------------------
  431|  10.7k|    case SUBTRACT_GREEN_TRANSFORM:
  ------------------
  |  Branch (431:5): [True: 10.7k, False: 49.0k]
  ------------------
  432|  10.7k|      VP8LAddGreenToBlueAndRed(in, (row_end - row_start) * width, out);
  433|  10.7k|      break;
  434|  19.6k|    case PREDICTOR_TRANSFORM:
  ------------------
  |  Branch (434:5): [True: 19.6k, False: 40.1k]
  ------------------
  435|  19.6k|      PredictorInverseTransform_C(transform, row_start, row_end, in, out);
  436|  19.6k|      if (row_end != transform->ysize) {
  ------------------
  |  Branch (436:11): [True: 19.2k, False: 461]
  ------------------
  437|       |        // The last predicted row in this iteration will be the top-pred row
  438|       |        // for the first row in next iteration.
  439|  19.2k|        memcpy(out - width, out + (row_end - row_start - 1) * width,
  440|  19.2k|               width * sizeof(*out));
  441|  19.2k|      }
  442|  19.6k|      break;
  443|  4.47k|    case CROSS_COLOR_TRANSFORM:
  ------------------
  |  Branch (443:5): [True: 4.47k, False: 55.3k]
  ------------------
  444|  4.47k|      ColorSpaceInverseTransform_C(transform, row_start, row_end, in, out);
  445|  4.47k|      break;
  446|  24.8k|    case COLOR_INDEXING_TRANSFORM:
  ------------------
  |  Branch (446:5): [True: 24.8k, False: 34.9k]
  ------------------
  447|  24.8k|      if (in == out && transform->bits > 0) {
  ------------------
  |  Branch (447:11): [True: 4.15k, False: 20.7k]
  |  Branch (447:24): [True: 1.32k, False: 2.82k]
  ------------------
  448|       |        // Move packed pixels to the end of unpacked region, so that unpacking
  449|       |        // can occur seamlessly.
  450|       |        // Also, note that this is the only transform that applies on
  451|       |        // the effective width of VP8LSubSampleSize(xsize, bits). All other
  452|       |        // transforms work on effective width of 'xsize'.
  453|  1.32k|        const int out_stride = (row_end - row_start) * width;
  454|  1.32k|        const int in_stride =
  455|  1.32k|            (row_end - row_start) *
  456|  1.32k|            VP8LSubSampleSize(transform->xsize, transform->bits);
  457|  1.32k|        uint32_t* const src = out + out_stride - in_stride;
  458|  1.32k|        memmove(src, out, in_stride * sizeof(*src));
  459|  1.32k|        ColorIndexInverseTransform_C(transform, row_start, row_end, src, out);
  460|  23.5k|      } else {
  461|  23.5k|        ColorIndexInverseTransform_C(transform, row_start, row_end, in, out);
  462|  23.5k|      }
  463|  24.8k|      break;
  464|  59.8k|  }
  465|  59.8k|}
VP8LConvertBGRAToRGB_C:
  479|   138k|                            uint8_t* WEBP_RESTRICT dst) {
  480|   138k|  const uint32_t* const src_end = src + num_pixels;
  481|   645k|  while (src < src_end) {
  ------------------
  |  Branch (481:10): [True: 507k, False: 138k]
  ------------------
  482|   507k|    const uint32_t argb = *src++;
  483|   507k|    *dst++ = (argb >> 16) & 0xff;
  484|   507k|    *dst++ = (argb >> 8) & 0xff;
  485|   507k|    *dst++ = (argb >> 0) & 0xff;
  486|   507k|  }
  487|   138k|}
VP8LConvertBGRAToRGBA_C:
  490|   189k|                             uint8_t* WEBP_RESTRICT dst) {
  491|   189k|  const uint32_t* const src_end = src + num_pixels;
  492|   680k|  while (src < src_end) {
  ------------------
  |  Branch (492:10): [True: 491k, False: 189k]
  ------------------
  493|   491k|    const uint32_t argb = *src++;
  494|   491k|    *dst++ = (argb >> 16) & 0xff;
  495|   491k|    *dst++ = (argb >> 8) & 0xff;
  496|   491k|    *dst++ = (argb >> 0) & 0xff;
  497|   491k|    *dst++ = (argb >> 24) & 0xff;
  498|   491k|  }
  499|   189k|}
VP8LConvertBGRAToBGR_C:
  536|   156k|                            uint8_t* WEBP_RESTRICT dst) {
  537|   156k|  const uint32_t* const src_end = src + num_pixels;
  538|   889k|  while (src < src_end) {
  ------------------
  |  Branch (538:10): [True: 732k, False: 156k]
  ------------------
  539|   732k|    const uint32_t argb = *src++;
  540|   732k|    *dst++ = (argb >> 0) & 0xff;
  541|   732k|    *dst++ = (argb >> 8) & 0xff;
  542|   732k|    *dst++ = (argb >> 16) & 0xff;
  543|   732k|  }
  544|   156k|}
VP8LConvertFromBGRA:
  561|   755k|                         WEBP_CSP_MODE out_colorspace, uint8_t* const rgba) {
  562|   755k|  switch (out_colorspace) {
  563|   141k|    case MODE_RGB:
  ------------------
  |  Branch (563:5): [True: 141k, False: 614k]
  ------------------
  564|   141k|      VP8LConvertBGRAToRGB(in_data, num_pixels, rgba);
  565|   141k|      break;
  566|   205k|    case MODE_RGBA:
  ------------------
  |  Branch (566:5): [True: 205k, False: 549k]
  ------------------
  567|   205k|      VP8LConvertBGRAToRGBA(in_data, num_pixels, rgba);
  568|   205k|      break;
  569|      0|    case MODE_rgbA:
  ------------------
  |  Branch (569:5): [True: 0, False: 755k]
  ------------------
  570|      0|      VP8LConvertBGRAToRGBA(in_data, num_pixels, rgba);
  571|      0|      WebPApplyAlphaMultiply(rgba, 0, num_pixels, 1, 0);
  572|      0|      break;
  573|   163k|    case MODE_BGR:
  ------------------
  |  Branch (573:5): [True: 163k, False: 591k]
  ------------------
  574|   163k|      VP8LConvertBGRAToBGR(in_data, num_pixels, rgba);
  575|   163k|      break;
  576|  57.1k|    case MODE_BGRA:
  ------------------
  |  Branch (576:5): [True: 57.1k, False: 698k]
  ------------------
  577|  57.1k|      CopyOrSwap(in_data, num_pixels, rgba, 1);
  578|  57.1k|      break;
  579|      0|    case MODE_bgrA:
  ------------------
  |  Branch (579:5): [True: 0, False: 755k]
  ------------------
  580|      0|      CopyOrSwap(in_data, num_pixels, rgba, 1);
  581|      0|      WebPApplyAlphaMultiply(rgba, 0, num_pixels, 1, 0);
  582|      0|      break;
  583|   187k|    case MODE_ARGB:
  ------------------
  |  Branch (583:5): [True: 187k, False: 567k]
  ------------------
  584|   187k|      CopyOrSwap(in_data, num_pixels, rgba, 0);
  585|   187k|      break;
  586|      0|    case MODE_Argb:
  ------------------
  |  Branch (586:5): [True: 0, False: 755k]
  ------------------
  587|      0|      CopyOrSwap(in_data, num_pixels, rgba, 0);
  588|      0|      WebPApplyAlphaMultiply(rgba, 1, num_pixels, 1, 0);
  589|      0|      break;
  590|      0|    case MODE_RGBA_4444:
  ------------------
  |  Branch (590:5): [True: 0, False: 755k]
  ------------------
  591|      0|      VP8LConvertBGRAToRGBA4444(in_data, num_pixels, rgba);
  592|      0|      break;
  593|      0|    case MODE_rgbA_4444:
  ------------------
  |  Branch (593:5): [True: 0, False: 755k]
  ------------------
  594|      0|      VP8LConvertBGRAToRGBA4444(in_data, num_pixels, rgba);
  595|      0|      WebPApplyAlphaMultiply4444(rgba, num_pixels, 1, 0);
  596|      0|      break;
  597|      0|    case MODE_RGB_565:
  ------------------
  |  Branch (597:5): [True: 0, False: 755k]
  ------------------
  598|      0|      VP8LConvertBGRAToRGB565(in_data, num_pixels, rgba);
  599|      0|      break;
  600|      0|    default:
  ------------------
  |  Branch (600:5): [True: 0, False: 755k]
  ------------------
  601|       |      assert(0);  // Code flow should not reach here.
  602|   755k|  }
  603|   755k|}
lossless.c:Average2:
   35|   156k|static WEBP_INLINE uint32_t Average2(uint32_t a0, uint32_t a1) {
   36|   156k|  return (((a0 ^ a1) & 0xfefefefeu) >> 1) + (a0 & a1);
   37|   156k|}
lossless.c:Average4:
   44|  37.0k|                                     uint32_t a3) {
   45|  37.0k|  return Average2(Average2(a0, a1), Average2(a2, a3));
   46|  37.0k|}
lossless.c:Select:
  102|  53.8k|static WEBP_INLINE uint32_t Select(uint32_t a, uint32_t b, uint32_t c) {
  103|  53.8k|  const int pa_minus_pb =
  104|  53.8k|      Sub3((a >> 24), (b >> 24), (c >> 24)) +
  105|  53.8k|      Sub3((a >> 16) & 0xff, (b >> 16) & 0xff, (c >> 16) & 0xff) +
  106|  53.8k|      Sub3((a >> 8) & 0xff, (b >> 8) & 0xff, (c >> 8) & 0xff) +
  107|  53.8k|      Sub3((a) & 0xff, (b) & 0xff, (c) & 0xff);
  108|  53.8k|  return (pa_minus_pb <= 0) ? a : b;
  ------------------
  |  Branch (108:10): [True: 53.4k, False: 342]
  ------------------
  109|  53.8k|}
lossless.c:Sub3:
   94|   215k|static LOCAL_INLINE int Sub3(int a, int b, int c) {
   95|   215k|  const int pb = b - c;
   96|   215k|  const int pa = a - c;
   97|   215k|  return abs(pb) - abs(pa);
   98|   215k|}
lossless.c:ClampedAddSubtractFull:
   62|  33.5k|                                                   uint32_t c2) {
   63|  33.5k|  const int a = AddSubtractComponentFull(c0 >> 24, c1 >> 24, c2 >> 24);
   64|  33.5k|  const int r = AddSubtractComponentFull((c0 >> 16) & 0xff, (c1 >> 16) & 0xff,
   65|  33.5k|                                         (c2 >> 16) & 0xff);
   66|  33.5k|  const int g = AddSubtractComponentFull((c0 >> 8) & 0xff, (c1 >> 8) & 0xff,
   67|  33.5k|                                         (c2 >> 8) & 0xff);
   68|  33.5k|  const int b = AddSubtractComponentFull(c0 & 0xff, c1 & 0xff, c2 & 0xff);
   69|  33.5k|  return ((uint32_t)a << 24) | (r << 16) | (g << 8) | b;
   70|  33.5k|}
lossless.c:AddSubtractComponentFull:
   57|   134k|static WEBP_INLINE int AddSubtractComponentFull(int a, int b, int c) {
   58|   134k|  return Clip255((uint32_t)(a + b - c));
   59|   134k|}
lossless.c:Clip255:
   48|   134k|static WEBP_INLINE uint32_t Clip255(uint32_t a) {
   49|   134k|  if (a < 256) {
  ------------------
  |  Branch (49:7): [True: 130k, False: 3.82k]
  ------------------
   50|   130k|    return a;
   51|   130k|  }
   52|       |  // return 0, when a is a negative integer.
   53|       |  // return 255, when a is positive.
   54|  3.82k|  return ~a >> 24;
   55|   134k|}
lossless.c:ColorTransformDelta:
  278|   300k|static WEBP_INLINE int ColorTransformDelta(int8_t color_pred, int8_t color) {
  279|   300k|  return ((int)color_pred * color) >> 5;
  280|   300k|}
lossless.c:PredictorInverseTransform_C:
  221|  19.6k|                                        const uint32_t* in, uint32_t* out) {
  222|  19.6k|  const int width = transform->xsize;
  223|  19.6k|  if (y_start == 0) {  // First Row follows the L (mode=1) mode.
  ------------------
  |  Branch (223:7): [True: 462, False: 19.2k]
  ------------------
  224|    462|    PredictorAdd0_C(in, NULL, 1, out);
  225|    462|    PredictorAdd1_C(in + 1, NULL, width - 1, out + 1);
  226|    462|    in += width;
  227|    462|    out += width;
  228|    462|    ++y_start;
  229|    462|  }
  230|       |
  231|  19.6k|  {
  232|  19.6k|    int y = y_start;
  233|  19.6k|    const int tile_width = 1 << transform->bits;
  234|  19.6k|    const int mask = tile_width - 1;
  235|  19.6k|    const int tiles_per_row = VP8LSubSampleSize(width, transform->bits);
  236|  19.6k|    const uint32_t* pred_mode_base =
  237|  19.6k|        transform->data + (y >> transform->bits) * tiles_per_row;
  238|       |
  239|   329k|    while (y < y_end) {
  ------------------
  |  Branch (239:12): [True: 309k, False: 19.6k]
  ------------------
  240|   309k|      const uint32_t* pred_mode_src = pred_mode_base;
  241|   309k|      int x = 1;
  242|       |      // First pixel follows the T (mode=2) mode.
  243|   309k|      PredictorAdd2_C(in, out - width, 1, out);
  244|       |      // .. the rest:
  245|  1.05M|      while (x < width) {
  ------------------
  |  Branch (245:14): [True: 740k, False: 309k]
  ------------------
  246|   740k|        const VP8LPredictorAddSubFunc pred_func =
  247|   740k|            VP8LPredictorsAdd[((*pred_mode_src++) >> 8) & 0xf];
  248|   740k|        int x_end = (x & ~mask) + tile_width;
  249|   740k|        if (x_end > width) x_end = width;
  ------------------
  |  Branch (249:13): [True: 207k, False: 532k]
  ------------------
  250|   740k|        pred_func(in + x, out + x - width, x_end - x, out + x);
  251|   740k|        x = x_end;
  252|   740k|      }
  253|   309k|      in += width;
  254|   309k|      out += width;
  255|   309k|      ++y;
  256|   309k|      if ((y & mask) == 0) {  // Use the same mask, since tiles are squares.
  ------------------
  |  Branch (256:11): [True: 21.9k, False: 287k]
  ------------------
  257|  21.9k|        pred_mode_base += tiles_per_row;
  258|  21.9k|      }
  259|   309k|    }
  260|  19.6k|  }
  261|  19.6k|}
lossless.c:PredictorAdd0_C:
  189|  77.2k|                            int num_pixels, uint32_t* WEBP_RESTRICT out) {
  190|  77.2k|  int x;
  191|  77.2k|  (void)upper;
  192|   259k|  for (x = 0; x < num_pixels; ++x) out[x] = VP8LAddPixels(in[x], ARGB_BLACK);
  ------------------
  |  |   38|   182k|#define ARGB_BLACK 0xff000000
  ------------------
  |  Branch (192:15): [True: 182k, False: 77.2k]
  ------------------
  193|  77.2k|}
lossless.c:PredictorAdd1_C:
  195|  41.9k|                            int num_pixels, uint32_t* WEBP_RESTRICT out) {
  196|  41.9k|  int i;
  197|  41.9k|  uint32_t left = out[-1];
  198|  41.9k|  (void)upper;
  199|  1.19M|  for (i = 0; i < num_pixels; ++i) {
  ------------------
  |  Branch (199:15): [True: 1.15M, False: 41.9k]
  ------------------
  200|  1.15M|    out[i] = left = VP8LAddPixels(in[i], left);
  201|  1.15M|  }
  202|  41.9k|}
lossless.c:ColorSpaceInverseTransform_C:
  311|  4.47k|                                         const uint32_t* src, uint32_t* dst) {
  312|  4.47k|  const int width = transform->xsize;
  313|  4.47k|  const int tile_width = 1 << transform->bits;
  314|  4.47k|  const int mask = tile_width - 1;
  315|  4.47k|  const int safe_width = width & ~mask;
  316|  4.47k|  const int remaining_width = width - safe_width;
  317|  4.47k|  const int tiles_per_row = VP8LSubSampleSize(width, transform->bits);
  318|  4.47k|  int y = y_start;
  319|  4.47k|  const uint32_t* pred_row =
  320|  4.47k|      transform->data + (y >> transform->bits) * tiles_per_row;
  321|       |
  322|  75.0k|  while (y < y_end) {
  ------------------
  |  Branch (322:10): [True: 70.5k, False: 4.47k]
  ------------------
  323|  70.5k|    const uint32_t* pred = pred_row;
  324|  70.5k|    VP8LMultipliers m = {0, 0, 0};
  325|  70.5k|    const uint32_t* const src_safe_end = src + safe_width;
  326|  70.5k|    const uint32_t* const src_end = src + width;
  327|   223k|    while (src < src_safe_end) {
  ------------------
  |  Branch (327:12): [True: 153k, False: 70.5k]
  ------------------
  328|   153k|      ColorCodeToMultipliers(*pred++, &m);
  329|   153k|      VP8LTransformColorInverse(&m, src, tile_width, dst);
  330|   153k|      src += tile_width;
  331|   153k|      dst += tile_width;
  332|   153k|    }
  333|  70.5k|    if (src < src_end) {  // Left-overs using C-version.
  ------------------
  |  Branch (333:9): [True: 59.0k, False: 11.5k]
  ------------------
  334|  59.0k|      ColorCodeToMultipliers(*pred++, &m);
  335|  59.0k|      VP8LTransformColorInverse(&m, src, remaining_width, dst);
  336|  59.0k|      src += remaining_width;
  337|  59.0k|      dst += remaining_width;
  338|  59.0k|    }
  339|  70.5k|    ++y;
  340|  70.5k|    if ((y & mask) == 0) pred_row += tiles_per_row;
  ------------------
  |  Branch (340:9): [True: 3.44k, False: 67.1k]
  ------------------
  341|  70.5k|  }
  342|  4.47k|}
lossless.c:ColorCodeToMultipliers:
  283|   212k|                                               VP8LMultipliers* const m) {
  284|   212k|  m->green_to_red = (color_code >> 0) & 0xff;
  285|   212k|  m->green_to_blue = (color_code >> 8) & 0xff;
  286|   212k|  m->red_to_blue = (color_code >> 16) & 0xff;
  287|   212k|}
lossless.c:ColorIndexInverseTransform_C:
  361|  24.8k|                           TYPE* dst) {                                        \
  362|  24.8k|  int y;                                                                       \
  363|  24.8k|  const int bits_per_pixel = 8 >> transform->bits;                             \
  364|  24.8k|  const int width = transform->xsize;                                          \
  365|  24.8k|  const uint32_t* const color_map = transform->data;                           \
  366|  24.8k|  if (bits_per_pixel < 8) {                                                    \
  ------------------
  |  Branch (366:7): [True: 16.0k, False: 8.83k]
  ------------------
  367|  16.0k|    const int pixels_per_byte = 1 << transform->bits;                          \
  368|  16.0k|    const uint32_t bit_mask = (1 << bits_per_pixel) - 1;                       \
  369|   271k|    for (y = y_start; y < y_end; ++y) {                                        \
  ------------------
  |  Branch (369:23): [True: 255k, False: 16.0k]
  ------------------
  370|   255k|      int x;                                                                   \
  371|   864k|      for (x = 0; x + pixels_per_byte <= width; x += pixels_per_byte) {        \
  ------------------
  |  Branch (371:19): [True: 609k, False: 255k]
  ------------------
  372|   609k|        uint32_t packed = GET_INDEX(*src++);                                   \
  373|   609k|        if (bits_per_pixel == 1) {                                             \
  ------------------
  |  Branch (373:13): [True: 64.8k, False: 544k]
  ------------------
  374|  64.8k|          *dst++ = GET_VALUE(color_map[packed & 1]);                           \
  375|  64.8k|          packed >>= 1;                                                        \
  376|  64.8k|          *dst++ = GET_VALUE(color_map[packed & 1]);                           \
  377|  64.8k|          packed >>= 1;                                                        \
  378|  64.8k|          *dst++ = GET_VALUE(color_map[packed & 1]);                           \
  379|  64.8k|          packed >>= 1;                                                        \
  380|  64.8k|          *dst++ = GET_VALUE(color_map[packed & 1]);                           \
  381|  64.8k|          packed >>= 1;                                                        \
  382|  64.8k|          *dst++ = GET_VALUE(color_map[packed & 1]);                           \
  383|  64.8k|          packed >>= 1;                                                        \
  384|  64.8k|          *dst++ = GET_VALUE(color_map[packed & 1]);                           \
  385|  64.8k|          packed >>= 1;                                                        \
  386|  64.8k|          *dst++ = GET_VALUE(color_map[packed & 1]);                           \
  387|  64.8k|          packed >>= 1;                                                        \
  388|  64.8k|          *dst++ = GET_VALUE(color_map[packed & 1]);                           \
  389|   544k|        } else if (bits_per_pixel == 2) {                                      \
  ------------------
  |  Branch (389:20): [True: 161k, False: 382k]
  ------------------
  390|   161k|          *dst++ = GET_VALUE(color_map[packed & 3]);                           \
  391|   161k|          packed >>= 2;                                                        \
  392|   161k|          *dst++ = GET_VALUE(color_map[packed & 3]);                           \
  393|   161k|          packed >>= 2;                                                        \
  394|   161k|          *dst++ = GET_VALUE(color_map[packed & 3]);                           \
  395|   161k|          packed >>= 2;                                                        \
  396|   161k|          *dst++ = GET_VALUE(color_map[packed & 3]);                           \
  397|   382k|        } else {                                                               \
  398|   382k|          *dst++ = GET_VALUE(color_map[packed & 15]);                          \
  399|   382k|          packed >>= 4;                                                        \
  400|   382k|          *dst++ = GET_VALUE(color_map[packed & 15]);                          \
  401|   382k|        }                                                                      \
  402|   609k|      }                                                                        \
  403|   255k|      if (x < width) {                                                         \
  ------------------
  |  Branch (403:11): [True: 198k, False: 57.1k]
  ------------------
  404|   198k|        uint32_t packed = GET_INDEX(*src++);                                   \
  405|   729k|        for (; x < width; ++x) {                                               \
  ------------------
  |  Branch (405:16): [True: 531k, False: 198k]
  ------------------
  406|   531k|          *dst++ = GET_VALUE(color_map[packed & bit_mask]);                    \
  407|   531k|          packed >>= bits_per_pixel;                                           \
  408|   531k|        }                                                                      \
  409|   198k|      }                                                                        \
  410|   255k|    }                                                                          \
  411|  16.0k|  } else {                                                                     \
  412|  8.83k|    VP8LMapColor##BIT_SUFFIX(src, color_map, dst, y_start, y_end, width);      \
  413|  8.83k|  }                                                                            \
  414|  24.8k|}
lossless.c:CopyOrSwap:
  547|   245k|                       uint8_t* WEBP_RESTRICT dst, int swap_on_big_endian) {
  548|   245k|  if (is_big_endian() == swap_on_big_endian) {
  ------------------
  |  Branch (548:7): [True: 187k, False: 57.1k]
  ------------------
  549|   187k|    const uint32_t* const src_end = src + num_pixels;
  550|  3.31M|    while (src < src_end) {
  ------------------
  |  Branch (550:12): [True: 3.12M, False: 187k]
  ------------------
  551|  3.12M|      const uint32_t argb = *src++;
  552|  3.12M|      WebPUint32ToMem(dst, BSwap32(argb));
  553|  3.12M|      dst += sizeof(argb);
  554|  3.12M|    }
  555|   187k|  } else {
  556|  57.1k|    memcpy(dst, src, num_pixels * sizeof(*src));
  557|  57.1k|  }
  558|   245k|}
lossless.c:is_big_endian:
  470|   245k|static int is_big_endian(void) {
  471|   245k|  static const union {
  472|   245k|    uint16_t w;
  473|   245k|    uint8_t b[2];
  474|   245k|  } tmp = {1};
  475|   245k|  return (tmp.b[0] != 1);
  476|   245k|}
lossless.c:VP8LDspInit_body:
  659|      1|WEBP_DSP_INIT_FUNC(VP8LDspInit) {
  660|      1|  COPY_PREDICTOR_ARRAY(VP8LPredictor, VP8LPredictors)
  ------------------
  |  |  640|      1|  do {                                                      \
  |  |  641|      1|    (OUT)[0] = IN##0_C;                                     \
  |  |  642|      1|    (OUT)[1] = IN##1_C;                                     \
  |  |  643|      1|    (OUT)[2] = IN##2_C;                                     \
  |  |  644|      1|    (OUT)[3] = IN##3_C;                                     \
  |  |  645|      1|    (OUT)[4] = IN##4_C;                                     \
  |  |  646|      1|    (OUT)[5] = IN##5_C;                                     \
  |  |  647|      1|    (OUT)[6] = IN##6_C;                                     \
  |  |  648|      1|    (OUT)[7] = IN##7_C;                                     \
  |  |  649|      1|    (OUT)[8] = IN##8_C;                                     \
  |  |  650|      1|    (OUT)[9] = IN##9_C;                                     \
  |  |  651|      1|    (OUT)[10] = IN##10_C;                                   \
  |  |  652|      1|    (OUT)[11] = IN##11_C;                                   \
  |  |  653|      1|    (OUT)[12] = IN##12_C;                                   \
  |  |  654|      1|    (OUT)[13] = IN##13_C;                                   \
  |  |  655|      1|    (OUT)[14] = IN##0_C; /* <- padding security sentinels*/ \
  |  |  656|      1|    (OUT)[15] = IN##0_C;                                    \
  |  |  657|      1|  } while (0);
  |  |  ------------------
  |  |  |  Branch (657:12): [Folded, False: 1]
  |  |  ------------------
  ------------------
  661|      1|  COPY_PREDICTOR_ARRAY(PredictorAdd, VP8LPredictorsAdd)
  ------------------
  |  |  640|      1|  do {                                                      \
  |  |  641|      1|    (OUT)[0] = IN##0_C;                                     \
  |  |  642|      1|    (OUT)[1] = IN##1_C;                                     \
  |  |  643|      1|    (OUT)[2] = IN##2_C;                                     \
  |  |  644|      1|    (OUT)[3] = IN##3_C;                                     \
  |  |  645|      1|    (OUT)[4] = IN##4_C;                                     \
  |  |  646|      1|    (OUT)[5] = IN##5_C;                                     \
  |  |  647|      1|    (OUT)[6] = IN##6_C;                                     \
  |  |  648|      1|    (OUT)[7] = IN##7_C;                                     \
  |  |  649|      1|    (OUT)[8] = IN##8_C;                                     \
  |  |  650|      1|    (OUT)[9] = IN##9_C;                                     \
  |  |  651|      1|    (OUT)[10] = IN##10_C;                                   \
  |  |  652|      1|    (OUT)[11] = IN##11_C;                                   \
  |  |  653|      1|    (OUT)[12] = IN##12_C;                                   \
  |  |  654|      1|    (OUT)[13] = IN##13_C;                                   \
  |  |  655|      1|    (OUT)[14] = IN##0_C; /* <- padding security sentinels*/ \
  |  |  656|      1|    (OUT)[15] = IN##0_C;                                    \
  |  |  657|      1|  } while (0);
  |  |  ------------------
  |  |  |  Branch (657:12): [Folded, False: 1]
  |  |  ------------------
  ------------------
  662|      1|  COPY_PREDICTOR_ARRAY(PredictorAdd, VP8LPredictorsAdd_C)
  ------------------
  |  |  640|      1|  do {                                                      \
  |  |  641|      1|    (OUT)[0] = IN##0_C;                                     \
  |  |  642|      1|    (OUT)[1] = IN##1_C;                                     \
  |  |  643|      1|    (OUT)[2] = IN##2_C;                                     \
  |  |  644|      1|    (OUT)[3] = IN##3_C;                                     \
  |  |  645|      1|    (OUT)[4] = IN##4_C;                                     \
  |  |  646|      1|    (OUT)[5] = IN##5_C;                                     \
  |  |  647|      1|    (OUT)[6] = IN##6_C;                                     \
  |  |  648|      1|    (OUT)[7] = IN##7_C;                                     \
  |  |  649|      1|    (OUT)[8] = IN##8_C;                                     \
  |  |  650|      1|    (OUT)[9] = IN##9_C;                                     \
  |  |  651|      1|    (OUT)[10] = IN##10_C;                                   \
  |  |  652|      1|    (OUT)[11] = IN##11_C;                                   \
  |  |  653|      1|    (OUT)[12] = IN##12_C;                                   \
  |  |  654|      1|    (OUT)[13] = IN##13_C;                                   \
  |  |  655|      1|    (OUT)[14] = IN##0_C; /* <- padding security sentinels*/ \
  |  |  656|      1|    (OUT)[15] = IN##0_C;                                    \
  |  |  657|      1|  } while (0);
  |  |  ------------------
  |  |  |  Branch (657:12): [Folded, False: 1]
  |  |  ------------------
  ------------------
  663|       |
  664|      1|#if !WEBP_NEON_OMIT_C_CODE
  665|      1|  VP8LAddGreenToBlueAndRed = VP8LAddGreenToBlueAndRed_C;
  666|       |
  667|      1|  VP8LTransformColorInverse = VP8LTransformColorInverse_C;
  668|       |
  669|      1|  VP8LConvertBGRAToRGBA = VP8LConvertBGRAToRGBA_C;
  670|      1|  VP8LConvertBGRAToRGB = VP8LConvertBGRAToRGB_C;
  671|      1|  VP8LConvertBGRAToBGR = VP8LConvertBGRAToBGR_C;
  672|      1|#endif
  673|       |
  674|      1|  VP8LConvertBGRAToRGBA4444 = VP8LConvertBGRAToRGBA4444_C;
  675|      1|  VP8LConvertBGRAToRGB565 = VP8LConvertBGRAToRGB565_C;
  676|       |
  677|      1|  VP8LMapColor32b = MapARGB_C;
  678|      1|  VP8LMapColor8b = MapAlpha_C;
  679|       |
  680|       |  // If defined, use CPUInfo() to overwrite some pointers with faster versions.
  681|      1|  if (VP8GetCPUInfo != NULL) {
  ------------------
  |  Branch (681:7): [True: 1, False: 0]
  ------------------
  682|      1|#if defined(WEBP_HAVE_SSE2)
  683|      1|    if (VP8GetCPUInfo(kSSE2)) {
  ------------------
  |  Branch (683:9): [True: 1, False: 0]
  ------------------
  684|      1|      VP8LDspInitSSE2();
  685|      1|#if defined(WEBP_HAVE_SSE41)
  686|      1|      if (VP8GetCPUInfo(kSSE4_1)) {
  ------------------
  |  Branch (686:11): [True: 1, False: 0]
  ------------------
  687|      1|        VP8LDspInitSSE41();
  688|      1|#if defined(WEBP_HAVE_AVX2)
  689|      1|        if (VP8GetCPUInfo(kAVX2)) {
  ------------------
  |  Branch (689:13): [True: 1, False: 0]
  ------------------
  690|      1|          VP8LDspInitAVX2();
  691|      1|        }
  692|      1|#endif
  693|      1|      }
  694|      1|#endif
  695|      1|    }
  696|      1|#endif
  697|       |#if defined(WEBP_USE_MIPS_DSP_R2)
  698|       |    if (VP8GetCPUInfo(kMIPSdspR2)) {
  699|       |      VP8LDspInitMIPSdspR2();
  700|       |    }
  701|       |#endif
  702|       |#if defined(WEBP_USE_MSA)
  703|       |    if (VP8GetCPUInfo(kMSA)) {
  704|       |      VP8LDspInitMSA();
  705|       |    }
  706|       |#endif
  707|      1|  }
  708|       |
  709|       |#if defined(WEBP_HAVE_NEON)
  710|       |  if (WEBP_NEON_OMIT_C_CODE ||
  711|       |      (VP8GetCPUInfo != NULL && VP8GetCPUInfo(kNEON))) {
  712|       |    VP8LDspInitNEON();
  713|       |  }
  714|       |#endif
  715|       |
  716|      1|  assert(VP8LAddGreenToBlueAndRed != NULL);
  717|      1|  assert(VP8LTransformColorInverse != NULL);
  718|      1|  assert(VP8LConvertBGRAToRGBA != NULL);
  719|      1|  assert(VP8LConvertBGRAToRGB != NULL);
  720|      1|  assert(VP8LConvertBGRAToBGR != NULL);
  721|      1|  assert(VP8LConvertBGRAToRGBA4444 != NULL);
  722|      1|  assert(VP8LConvertBGRAToRGB565 != NULL);
  723|      1|  assert(VP8LMapColor32b != NULL);
  724|       |  assert(VP8LMapColor8b != NULL);
  725|      1|}
lossless.c:MapARGB_C:
  350|  8.83k|                   TYPE* dst, int y_start, int y_end, int width) {             \
  351|  8.83k|  int y;                                                                       \
  352|   149k|  for (y = y_start; y < y_end; ++y) {                                          \
  ------------------
  |  Branch (352:21): [True: 140k, False: 8.83k]
  ------------------
  353|   140k|    int x;                                                                     \
  354|  1.30M|    for (x = 0; x < width; ++x) {                                              \
  ------------------
  |  Branch (354:17): [True: 1.16M, False: 140k]
  ------------------
  355|  1.16M|      *dst++ = GET_VALUE(color_map[GET_INDEX(*src++)]);                        \
  356|  1.16M|    }                                                                          \
  357|   140k|  }                                                                            \
  358|  8.83k|}                                                                              \

VP8LDspInitAVX2:
  485|      1|WEBP_TSAN_IGNORE_FUNCTION void VP8LDspInitAVX2(void) {
  486|      1|  VP8LPredictorsAdd[0] = PredictorAdd0_AVX2;
  487|      1|  VP8LPredictorsAdd[1] = PredictorAdd1_AVX2;
  488|      1|  VP8LPredictorsAdd[2] = PredictorAdd2_AVX2;
  489|      1|  VP8LPredictorsAdd[3] = PredictorAdd3_AVX2;
  490|      1|  VP8LPredictorsAdd[4] = PredictorAdd4_AVX2;
  491|      1|  VP8LPredictorsAdd[8] = PredictorAdd8_AVX2;
  492|      1|  VP8LPredictorsAdd[9] = PredictorAdd9_AVX2;
  493|      1|  VP8LPredictorsAdd[10] = PredictorAdd10_AVX2;
  494|      1|  VP8LPredictorsAdd[11] = PredictorAdd11_AVX2;
  495|      1|  VP8LPredictorsAdd[12] = PredictorAdd12_AVX2;
  496|       |
  497|      1|  VP8LAddGreenToBlueAndRed = AddGreenToBlueAndRed_AVX2;
  498|      1|  VP8LTransformColorInverse = TransformColorInverse_AVX2;
  499|      1|  VP8LConvertBGRAToRGB = ConvertBGRAToRGB_AVX2;
  500|      1|  VP8LConvertBGRAToRGBA = ConvertBGRAToRGBA_AVX2;
  501|      1|  VP8LConvertBGRAToBGR = ConvertBGRAToBGR_AVX2;
  502|      1|}
lossless_avx2.c:PredictorAdd0_AVX2:
   43|   130k|                               int num_pixels, uint32_t* WEBP_RESTRICT out) {
   44|   130k|  int i;
   45|   130k|  const __m256i black = _mm256_set1_epi32((int)ARGB_BLACK);
  ------------------
  |  |   38|   130k|#define ARGB_BLACK 0xff000000
  ------------------
   46|   243k|  for (i = 0; i + 8 <= num_pixels; i += 8) {
  ------------------
  |  Branch (46:15): [True: 112k, False: 130k]
  ------------------
   47|   112k|    const __m256i src = _mm256_loadu_si256((const __m256i*)&in[i]);
   48|   112k|    const __m256i res = _mm256_add_epi8(src, black);
   49|   112k|    _mm256_storeu_si256((__m256i*)&out[i], res);
   50|   112k|  }
   51|   130k|  if (i != num_pixels) {
  ------------------
  |  Branch (51:7): [True: 90.3k, False: 39.8k]
  ------------------
   52|       |    VP8LPredictorsAdd_SSE[0](in + i, NULL, num_pixels - i, out + i);
   53|  90.3k|  }
   54|   130k|  (void)upper;
   55|   130k|}
lossless_avx2.c:PredictorAdd1_AVX2:
   59|  87.5k|                               int num_pixels, uint32_t* WEBP_RESTRICT out) {
   60|  87.5k|  int i;
   61|  87.5k|  __m256i prev = _mm256_set1_epi32((int)out[-1]);
   62|   152k|  for (i = 0; i + 8 <= num_pixels; i += 8) {
  ------------------
  |  Branch (62:15): [True: 64.7k, False: 87.5k]
  ------------------
   63|       |    // h | g | f | e | d | c | b | a
   64|  64.7k|    const __m256i src = _mm256_loadu_si256((const __m256i*)&in[i]);
   65|       |    // g | f | e | 0 | c | b | a | 0
   66|  64.7k|    const __m256i shift0 = _mm256_slli_si256(src, 4);
   67|       |    // g + h | f + g | e + f | e | c + d | b + c | a + b | a
   68|  64.7k|    const __m256i sum0 = _mm256_add_epi8(src, shift0);
   69|       |    // e + f | e | 0 | 0 | a + b | a | 0 | 0
   70|  64.7k|    const __m256i shift1 = _mm256_slli_si256(sum0, 8);
   71|       |    // e + f + g + h | e + f + g | e + f | e | a + b + c + d | a + b + c | a + b
   72|       |    // | a
   73|  64.7k|    const __m256i sum1 = _mm256_add_epi8(sum0, shift1);
   74|       |    // Add a + b + c + d to the upper lane.
   75|  64.7k|    const int32_t sum_abcd = _mm256_extract_epi32(sum1, 3);
   76|  64.7k|    const __m256i sum2 = _mm256_add_epi8(
   77|  64.7k|        sum1,
   78|  64.7k|        _mm256_set_epi32(sum_abcd, sum_abcd, sum_abcd, sum_abcd, 0, 0, 0, 0));
   79|       |
   80|  64.7k|    const __m256i res = _mm256_add_epi8(sum2, prev);
   81|  64.7k|    _mm256_storeu_si256((__m256i*)&out[i], res);
   82|       |    // replicate last res output in prev.
   83|  64.7k|    prev = _mm256_permutevar8x32_epi32(
   84|  64.7k|        res, _mm256_set_epi32(7, 7, 7, 7, 7, 7, 7, 7));
   85|  64.7k|  }
   86|  87.5k|  if (i != num_pixels) {
  ------------------
  |  Branch (86:7): [True: 78.8k, False: 8.70k]
  ------------------
   87|  78.8k|    VP8LPredictorsAdd_SSE[1](in + i, upper + i, num_pixels - i, out + i);
   88|  78.8k|  }
   89|  87.5k|}
lossless_avx2.c:PredictorAdd2_AVX2:
   96|  58.7k|                                     uint32_t* WEBP_RESTRICT out) {           \
   97|  58.7k|    int i;                                                                    \
   98|   104k|    for (i = 0; i + 8 <= num_pixels; i += 8) {                                \
  ------------------
  |  Branch (98:17): [True: 46.0k, False: 58.7k]
  ------------------
   99|  46.0k|      const __m256i src = _mm256_loadu_si256((const __m256i*)&in[i]);         \
  100|  46.0k|      const __m256i other = _mm256_loadu_si256((const __m256i*)&(IN));        \
  101|  46.0k|      const __m256i res = _mm256_add_epi8(src, other);                        \
  102|  46.0k|      _mm256_storeu_si256((__m256i*)&out[i], res);                            \
  103|  46.0k|    }                                                                         \
  104|  58.7k|    if (i != num_pixels) {                                                    \
  ------------------
  |  Branch (104:9): [True: 45.2k, False: 13.5k]
  ------------------
  105|  45.2k|      VP8LPredictorsAdd_SSE[(X)](in + i, upper + i, num_pixels - i, out + i); \
  106|  45.2k|    }                                                                         \
  107|  58.7k|  }
lossless_avx2.c:PredictorAdd3_AVX2:
   96|  49.6k|                                     uint32_t* WEBP_RESTRICT out) {           \
   97|  49.6k|    int i;                                                                    \
   98|  76.8k|    for (i = 0; i + 8 <= num_pixels; i += 8) {                                \
  ------------------
  |  Branch (98:17): [True: 27.1k, False: 49.6k]
  ------------------
   99|  27.1k|      const __m256i src = _mm256_loadu_si256((const __m256i*)&in[i]);         \
  100|  27.1k|      const __m256i other = _mm256_loadu_si256((const __m256i*)&(IN));        \
  101|  27.1k|      const __m256i res = _mm256_add_epi8(src, other);                        \
  102|  27.1k|      _mm256_storeu_si256((__m256i*)&out[i], res);                            \
  103|  27.1k|    }                                                                         \
  104|  49.6k|    if (i != num_pixels) {                                                    \
  ------------------
  |  Branch (104:9): [True: 45.3k, False: 4.25k]
  ------------------
  105|  45.3k|      VP8LPredictorsAdd_SSE[(X)](in + i, upper + i, num_pixels - i, out + i); \
  106|  45.3k|    }                                                                         \
  107|  49.6k|  }
lossless_avx2.c:PredictorAdd4_AVX2:
   96|  44.3k|                                     uint32_t* WEBP_RESTRICT out) {           \
   97|  44.3k|    int i;                                                                    \
   98|  96.7k|    for (i = 0; i + 8 <= num_pixels; i += 8) {                                \
  ------------------
  |  Branch (98:17): [True: 52.4k, False: 44.3k]
  ------------------
   99|  52.4k|      const __m256i src = _mm256_loadu_si256((const __m256i*)&in[i]);         \
  100|  52.4k|      const __m256i other = _mm256_loadu_si256((const __m256i*)&(IN));        \
  101|  52.4k|      const __m256i res = _mm256_add_epi8(src, other);                        \
  102|  52.4k|      _mm256_storeu_si256((__m256i*)&out[i], res);                            \
  103|  52.4k|    }                                                                         \
  104|  44.3k|    if (i != num_pixels) {                                                    \
  ------------------
  |  Branch (104:9): [True: 34.4k, False: 9.89k]
  ------------------
  105|  34.4k|      VP8LPredictorsAdd_SSE[(X)](in + i, upper + i, num_pixels - i, out + i); \
  106|  34.4k|    }                                                                         \
  107|  44.3k|  }
lossless_avx2.c:PredictorAdd8_AVX2:
  123|  43.1k|                                     uint32_t* WEBP_RESTRICT out) {           \
  124|  43.1k|    int i;                                                                    \
  125|   101k|    for (i = 0; i + 8 <= num_pixels; i += 8) {                                \
  ------------------
  |  Branch (125:17): [True: 58.5k, False: 43.1k]
  ------------------
  126|  58.5k|      const __m256i Tother = _mm256_loadu_si256((const __m256i*)&(IN));       \
  127|  58.5k|      const __m256i T = _mm256_loadu_si256((const __m256i*)&upper[i]);        \
  128|  58.5k|      const __m256i src = _mm256_loadu_si256((const __m256i*)&in[i]);         \
  129|  58.5k|      __m256i avg, res;                                                       \
  130|  58.5k|      Average2_m256i(&T, &Tother, &avg);                                      \
  131|  58.5k|      res = _mm256_add_epi8(avg, src);                                        \
  132|  58.5k|      _mm256_storeu_si256((__m256i*)&out[i], res);                            \
  133|  58.5k|    }                                                                         \
  134|  43.1k|    if (i != num_pixels) {                                                    \
  ------------------
  |  Branch (134:9): [True: 31.3k, False: 11.8k]
  ------------------
  135|  31.3k|      VP8LPredictorsAdd_SSE[(X)](in + i, upper + i, num_pixels - i, out + i); \
  136|  31.3k|    }                                                                         \
  137|  43.1k|  }
lossless_avx2.c:Average2_m256i:
   31|   727k|                                       __m256i* const avg) {
   32|       |  // (a + b) >> 1 = ((a + b + 1) >> 1) - ((a ^ b) & 1)
   33|   727k|  const __m256i ones = _mm256_set1_epi8(1);
   34|   727k|  const __m256i avg1 = _mm256_avg_epu8(*a0, *a1);
   35|   727k|  const __m256i one = _mm256_and_si256(_mm256_xor_si256(*a0, *a1), ones);
   36|   727k|  *avg = _mm256_sub_epi8(avg1, one);
   37|   727k|}
lossless_avx2.c:PredictorAdd9_AVX2:
  123|  54.9k|                                     uint32_t* WEBP_RESTRICT out) {           \
  124|  54.9k|    int i;                                                                    \
  125|  96.0k|    for (i = 0; i + 8 <= num_pixels; i += 8) {                                \
  ------------------
  |  Branch (125:17): [True: 41.1k, False: 54.9k]
  ------------------
  126|  41.1k|      const __m256i Tother = _mm256_loadu_si256((const __m256i*)&(IN));       \
  127|  41.1k|      const __m256i T = _mm256_loadu_si256((const __m256i*)&upper[i]);        \
  128|  41.1k|      const __m256i src = _mm256_loadu_si256((const __m256i*)&in[i]);         \
  129|  41.1k|      __m256i avg, res;                                                       \
  130|  41.1k|      Average2_m256i(&T, &Tother, &avg);                                      \
  131|  41.1k|      res = _mm256_add_epi8(avg, src);                                        \
  132|  41.1k|      _mm256_storeu_si256((__m256i*)&out[i], res);                            \
  133|  41.1k|    }                                                                         \
  134|  54.9k|    if (i != num_pixels) {                                                    \
  ------------------
  |  Branch (134:9): [True: 42.4k, False: 12.4k]
  ------------------
  135|  42.4k|      VP8LPredictorsAdd_SSE[(X)](in + i, upper + i, num_pixels - i, out + i); \
  136|  42.4k|    }                                                                         \
  137|  54.9k|  }
lossless_avx2.c:PredictorAdd10_AVX2:
  163|  78.9k|                                int num_pixels, uint32_t* WEBP_RESTRICT out) {
  164|  78.9k|  int i, j;
  165|  78.9k|  __m256i L = _mm256_setr_epi32((int)out[-1], 0, 0, 0, 0, 0, 0, 0);
  166|   115k|  for (i = 0; i + 8 <= num_pixels; i += 8) {
  ------------------
  |  Branch (166:15): [True: 36.9k, False: 78.9k]
  ------------------
  167|  36.9k|    __m256i src = _mm256_loadu_si256((const __m256i*)&in[i]);
  168|  36.9k|    __m256i TL = _mm256_loadu_si256((const __m256i*)&upper[i - 1]);
  169|  36.9k|    const __m256i T = _mm256_loadu_si256((const __m256i*)&upper[i]);
  170|  36.9k|    const __m256i TR = _mm256_loadu_si256((const __m256i*)&upper[i + 1]);
  171|  36.9k|    __m256i avgTTR;
  172|  36.9k|    Average2_m256i(&T, &TR, &avgTTR);
  173|  36.9k|    {
  174|  36.9k|      const __m256i avgTTR_bak = avgTTR;
  175|  36.9k|      const __m256i TL_bak = TL;
  176|  36.9k|      const __m256i src_bak = src;
  177|   184k|      for (j = 0; j < 4; ++j) {
  ------------------
  |  Branch (177:19): [True: 147k, False: 36.9k]
  ------------------
  178|   147k|        DO_PRED10(j);
  ------------------
  |  |  146|   147k|  do {                                                  \
  |  |  147|   147k|    __m256i avgLTL, avg;                                \
  |  |  148|   147k|    Average2_m256i(&L, &TL, &avgLTL);                   \
  |  |  149|   147k|    Average2_m256i(&avgTTR, &avgLTL, &avg);             \
  |  |  150|   147k|    L = _mm256_add_epi8(avg, src);                      \
  |  |  151|   147k|    out[i + (OUT)] = (uint32_t)_mm256_cvtsi256_si32(L); \
  |  |  152|   147k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (152:12): [Folded, False: 147k]
  |  |  ------------------
  ------------------
  179|   147k|        DO_PRED10_SHIFT;
  ------------------
  |  |  155|   147k|  do {                                                          \
  |  |  156|   147k|    /* Rotate the pre-computed values for the next iteration.*/ \
  |  |  157|   147k|    avgTTR = _mm256_srli_si256(avgTTR, 4);                      \
  |  |  158|   147k|    TL = _mm256_srli_si256(TL, 4);                              \
  |  |  159|   147k|    src = _mm256_srli_si256(src, 4);                            \
  |  |  160|   147k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (160:12): [Folded, False: 147k]
  |  |  ------------------
  ------------------
  180|   147k|      }
  181|  36.9k|      avgTTR = _mm256_permute2x128_si256(avgTTR_bak, avgTTR_bak, 1);
  182|  36.9k|      TL = _mm256_permute2x128_si256(TL_bak, TL_bak, 1);
  183|  36.9k|      src = _mm256_permute2x128_si256(src_bak, src_bak, 1);
  184|   184k|      for (; j < 8; ++j) {
  ------------------
  |  Branch (184:14): [True: 147k, False: 36.9k]
  ------------------
  185|   147k|        DO_PRED10(j);
  ------------------
  |  |  146|   147k|  do {                                                  \
  |  |  147|   147k|    __m256i avgLTL, avg;                                \
  |  |  148|   147k|    Average2_m256i(&L, &TL, &avgLTL);                   \
  |  |  149|   147k|    Average2_m256i(&avgTTR, &avgLTL, &avg);             \
  |  |  150|   147k|    L = _mm256_add_epi8(avg, src);                      \
  |  |  151|   147k|    out[i + (OUT)] = (uint32_t)_mm256_cvtsi256_si32(L); \
  |  |  152|   147k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (152:12): [Folded, False: 147k]
  |  |  ------------------
  ------------------
  186|   147k|        DO_PRED10_SHIFT;
  ------------------
  |  |  155|   147k|  do {                                                          \
  |  |  156|   147k|    /* Rotate the pre-computed values for the next iteration.*/ \
  |  |  157|   147k|    avgTTR = _mm256_srli_si256(avgTTR, 4);                      \
  |  |  158|   147k|    TL = _mm256_srli_si256(TL, 4);                              \
  |  |  159|   147k|    src = _mm256_srli_si256(src, 4);                            \
  |  |  160|   147k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (160:12): [Folded, False: 147k]
  |  |  ------------------
  ------------------
  187|   147k|      }
  188|  36.9k|    }
  189|  36.9k|  }
  190|  78.9k|  if (i != num_pixels) {
  ------------------
  |  Branch (190:7): [True: 76.0k, False: 2.95k]
  ------------------
  191|  76.0k|    VP8LPredictorsAdd_SSE[10](in + i, upper + i, num_pixels - i, out + i);
  192|  76.0k|  }
  193|  78.9k|}
lossless_avx2.c:PredictorAdd11_AVX2:
  221|  80.1k|                                int num_pixels, uint32_t* WEBP_RESTRICT out) {
  222|  80.1k|  int i, j;
  223|  80.1k|  __m256i pa;
  224|  80.1k|  __m256i L = _mm256_setr_epi32((int)out[-1], 0, 0, 0, 0, 0, 0, 0);
  225|   130k|  for (i = 0; i + 8 <= num_pixels; i += 8) {
  ------------------
  |  Branch (225:15): [True: 50.4k, False: 80.1k]
  ------------------
  226|  50.4k|    __m256i T = _mm256_loadu_si256((const __m256i*)&upper[i]);
  227|  50.4k|    __m256i TL = _mm256_loadu_si256((const __m256i*)&upper[i - 1]);
  228|  50.4k|    __m256i src = _mm256_loadu_si256((const __m256i*)&in[i]);
  229|  50.4k|    {
  230|       |      // We can unpack with any value on the upper 32 bits, provided it's the
  231|       |      // same on both operands (so that their sum of abs diff is zero). Here we
  232|       |      // use T.
  233|  50.4k|      const __m256i T_lo = _mm256_unpacklo_epi32(T, T);
  234|  50.4k|      const __m256i TL_lo = _mm256_unpacklo_epi32(TL, T);
  235|  50.4k|      const __m256i T_hi = _mm256_unpackhi_epi32(T, T);
  236|  50.4k|      const __m256i TL_hi = _mm256_unpackhi_epi32(TL, T);
  237|  50.4k|      const __m256i s_lo = _mm256_sad_epu8(T_lo, TL_lo);
  238|  50.4k|      const __m256i s_hi = _mm256_sad_epu8(T_hi, TL_hi);
  239|  50.4k|      pa = _mm256_packs_epi32(s_lo, s_hi);  // pa = sum |T-TL|
  240|  50.4k|    }
  241|  50.4k|    {
  242|  50.4k|      const __m256i T_bak = T;
  243|  50.4k|      const __m256i TL_bak = TL;
  244|  50.4k|      const __m256i src_bak = src;
  245|  50.4k|      const __m256i pa_bak = pa;
  246|   252k|      for (j = 0; j < 4; ++j) {
  ------------------
  |  Branch (246:19): [True: 201k, False: 50.4k]
  ------------------
  247|   201k|        DO_PRED11(j);
  ------------------
  |  |  199|   201k|  do {                                                                      \
  |  |  200|   201k|    const __m256i L_lo = _mm256_unpacklo_epi32(L, T);                       \
  |  |  201|   201k|    const __m256i TL_lo = _mm256_unpacklo_epi32(TL, T);                     \
  |  |  202|   201k|    const __m256i pb = _mm256_sad_epu8(L_lo, TL_lo); /* pb = sum |L-TL|*/   \
  |  |  203|   201k|    const __m256i mask = _mm256_cmpgt_epi32(pb, pa);                        \
  |  |  204|   201k|    const __m256i A = _mm256_and_si256(mask, L);                            \
  |  |  205|   201k|    const __m256i B = _mm256_andnot_si256(mask, T);                         \
  |  |  206|   201k|    const __m256i pred = _mm256_or_si256(A, B); /* pred = (pa > b)? L : T*/ \
  |  |  207|   201k|    L = _mm256_add_epi8(src, pred);                                         \
  |  |  208|   201k|    out[i + (OUT)] = (uint32_t)_mm256_cvtsi256_si32(L);                     \
  |  |  209|   201k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (209:12): [Folded, False: 201k]
  |  |  ------------------
  ------------------
  248|   201k|        DO_PRED11_SHIFT;
  ------------------
  |  |  212|   201k|  do {                                                        \
  |  |  213|   201k|    /* Shift the pre-computed value for the next iteration.*/ \
  |  |  214|   201k|    T = _mm256_srli_si256(T, 4);                              \
  |  |  215|   201k|    TL = _mm256_srli_si256(TL, 4);                            \
  |  |  216|   201k|    src = _mm256_srli_si256(src, 4);                          \
  |  |  217|   201k|    pa = _mm256_srli_si256(pa, 4);                            \
  |  |  218|   201k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (218:12): [Folded, False: 201k]
  |  |  ------------------
  ------------------
  249|   201k|      }
  250|  50.4k|      T = _mm256_permute2x128_si256(T_bak, T_bak, 1);
  251|  50.4k|      TL = _mm256_permute2x128_si256(TL_bak, TL_bak, 1);
  252|  50.4k|      src = _mm256_permute2x128_si256(src_bak, src_bak, 1);
  253|  50.4k|      pa = _mm256_permute2x128_si256(pa_bak, pa_bak, 1);
  254|   252k|      for (; j < 8; ++j) {
  ------------------
  |  Branch (254:14): [True: 201k, False: 50.4k]
  ------------------
  255|   201k|        DO_PRED11(j);
  ------------------
  |  |  199|   201k|  do {                                                                      \
  |  |  200|   201k|    const __m256i L_lo = _mm256_unpacklo_epi32(L, T);                       \
  |  |  201|   201k|    const __m256i TL_lo = _mm256_unpacklo_epi32(TL, T);                     \
  |  |  202|   201k|    const __m256i pb = _mm256_sad_epu8(L_lo, TL_lo); /* pb = sum |L-TL|*/   \
  |  |  203|   201k|    const __m256i mask = _mm256_cmpgt_epi32(pb, pa);                        \
  |  |  204|   201k|    const __m256i A = _mm256_and_si256(mask, L);                            \
  |  |  205|   201k|    const __m256i B = _mm256_andnot_si256(mask, T);                         \
  |  |  206|   201k|    const __m256i pred = _mm256_or_si256(A, B); /* pred = (pa > b)? L : T*/ \
  |  |  207|   201k|    L = _mm256_add_epi8(src, pred);                                         \
  |  |  208|   201k|    out[i + (OUT)] = (uint32_t)_mm256_cvtsi256_si32(L);                     \
  |  |  209|   201k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (209:12): [Folded, False: 201k]
  |  |  ------------------
  ------------------
  256|   201k|        DO_PRED11_SHIFT;
  ------------------
  |  |  212|   201k|  do {                                                        \
  |  |  213|   201k|    /* Shift the pre-computed value for the next iteration.*/ \
  |  |  214|   201k|    T = _mm256_srli_si256(T, 4);                              \
  |  |  215|   201k|    TL = _mm256_srli_si256(TL, 4);                            \
  |  |  216|   201k|    src = _mm256_srli_si256(src, 4);                          \
  |  |  217|   201k|    pa = _mm256_srli_si256(pa, 4);                            \
  |  |  218|   201k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (218:12): [Folded, False: 201k]
  |  |  ------------------
  ------------------
  257|   201k|      }
  258|  50.4k|    }
  259|  50.4k|  }
  260|  80.1k|  if (i != num_pixels) {
  ------------------
  |  Branch (260:7): [True: 75.3k, False: 4.79k]
  ------------------
  261|  75.3k|    VP8LPredictorsAdd_SSE[11](in + i, upper + i, num_pixels - i, out + i);
  262|  75.3k|  }
  263|  80.1k|}
lossless_avx2.c:PredictorAdd12_AVX2:
  285|  52.9k|                                int num_pixels, uint32_t* WEBP_RESTRICT out) {
  286|  52.9k|  int i;
  287|  52.9k|  const __m256i zero = _mm256_setzero_si256();
  288|  52.9k|  const __m256i L8 = _mm256_setr_epi32((int)out[-1], 0, 0, 0, 0, 0, 0, 0);
  289|  52.9k|  __m256i L = _mm256_unpacklo_epi8(L8, zero);
  290|   131k|  for (i = 0; i + 8 <= num_pixels; i += 8) {
  ------------------
  |  Branch (290:15): [True: 78.1k, False: 52.9k]
  ------------------
  291|       |    // Load 8 pixels at a time.
  292|  78.1k|    __m256i src = _mm256_loadu_si256((const __m256i*)&in[i]);
  293|  78.1k|    const __m256i T = _mm256_loadu_si256((const __m256i*)&upper[i]);
  294|  78.1k|    const __m256i T_lo = _mm256_unpacklo_epi8(T, zero);
  295|  78.1k|    const __m256i T_hi = _mm256_unpackhi_epi8(T, zero);
  296|  78.1k|    const __m256i TL = _mm256_loadu_si256((const __m256i*)&upper[i - 1]);
  297|  78.1k|    const __m256i TL_lo = _mm256_unpacklo_epi8(TL, zero);
  298|  78.1k|    const __m256i TL_hi = _mm256_unpackhi_epi8(TL, zero);
  299|  78.1k|    __m256i diff_lo = _mm256_sub_epi16(T_lo, TL_lo);
  300|  78.1k|    __m256i diff_hi = _mm256_sub_epi16(T_hi, TL_hi);
  301|  78.1k|    const __m256i diff_lo_bak = diff_lo;
  302|  78.1k|    const __m256i diff_hi_bak = diff_hi;
  303|  78.1k|    const __m256i src_bak = src;
  304|  78.1k|    DO_PRED12(diff_lo, 0);
  ------------------
  |  |  269|  78.1k|  do {                                                    \
  |  |  270|  78.1k|    const __m256i all = _mm256_add_epi16(L, (DIFF));      \
  |  |  271|  78.1k|    const __m256i alls = _mm256_packus_epi16(all, all);   \
  |  |  272|  78.1k|    const __m256i res = _mm256_add_epi8(src, alls);       \
  |  |  273|  78.1k|    out[i + (OUT)] = (uint32_t)_mm256_cvtsi256_si32(res); \
  |  |  274|  78.1k|    L = _mm256_unpacklo_epi8(res, zero);                  \
  |  |  275|  78.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (275:12): [Folded, False: 78.1k]
  |  |  ------------------
  ------------------
  305|  78.1k|    DO_PRED12_SHIFT(diff_lo, 0);
  ------------------
  |  |  278|  78.1k|  do {                                                        \
  |  |  279|  78.1k|    /* Shift the pre-computed value for the next iteration.*/ \
  |  |  280|  78.1k|    if ((LANE) == 0) (DIFF) = _mm256_srli_si256(DIFF, 8);     \
  |  |  ------------------
  |  |  |  Branch (280:9): [True: 78.1k, Folded]
  |  |  ------------------
  |  |  281|  78.1k|    src = _mm256_srli_si256(src, 4);                          \
  |  |  282|  78.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (282:12): [Folded, False: 78.1k]
  |  |  ------------------
  ------------------
  306|  78.1k|    DO_PRED12(diff_lo, 1);
  ------------------
  |  |  269|  78.1k|  do {                                                    \
  |  |  270|  78.1k|    const __m256i all = _mm256_add_epi16(L, (DIFF));      \
  |  |  271|  78.1k|    const __m256i alls = _mm256_packus_epi16(all, all);   \
  |  |  272|  78.1k|    const __m256i res = _mm256_add_epi8(src, alls);       \
  |  |  273|  78.1k|    out[i + (OUT)] = (uint32_t)_mm256_cvtsi256_si32(res); \
  |  |  274|  78.1k|    L = _mm256_unpacklo_epi8(res, zero);                  \
  |  |  275|  78.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (275:12): [Folded, False: 78.1k]
  |  |  ------------------
  ------------------
  307|  78.1k|    DO_PRED12_SHIFT(diff_lo, 1);
  ------------------
  |  |  278|  78.1k|  do {                                                        \
  |  |  279|  78.1k|    /* Shift the pre-computed value for the next iteration.*/ \
  |  |  280|  78.1k|    if ((LANE) == 0) (DIFF) = _mm256_srli_si256(DIFF, 8);     \
  |  |  ------------------
  |  |  |  Branch (280:9): [Folded, False: 78.1k]
  |  |  ------------------
  |  |  281|  78.1k|    src = _mm256_srli_si256(src, 4);                          \
  |  |  282|  78.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (282:12): [Folded, False: 78.1k]
  |  |  ------------------
  ------------------
  308|  78.1k|    DO_PRED12(diff_hi, 2);
  ------------------
  |  |  269|  78.1k|  do {                                                    \
  |  |  270|  78.1k|    const __m256i all = _mm256_add_epi16(L, (DIFF));      \
  |  |  271|  78.1k|    const __m256i alls = _mm256_packus_epi16(all, all);   \
  |  |  272|  78.1k|    const __m256i res = _mm256_add_epi8(src, alls);       \
  |  |  273|  78.1k|    out[i + (OUT)] = (uint32_t)_mm256_cvtsi256_si32(res); \
  |  |  274|  78.1k|    L = _mm256_unpacklo_epi8(res, zero);                  \
  |  |  275|  78.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (275:12): [Folded, False: 78.1k]
  |  |  ------------------
  ------------------
  309|  78.1k|    DO_PRED12_SHIFT(diff_hi, 0);
  ------------------
  |  |  278|  78.1k|  do {                                                        \
  |  |  279|  78.1k|    /* Shift the pre-computed value for the next iteration.*/ \
  |  |  280|  78.1k|    if ((LANE) == 0) (DIFF) = _mm256_srli_si256(DIFF, 8);     \
  |  |  ------------------
  |  |  |  Branch (280:9): [True: 78.1k, Folded]
  |  |  ------------------
  |  |  281|  78.1k|    src = _mm256_srli_si256(src, 4);                          \
  |  |  282|  78.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (282:12): [Folded, False: 78.1k]
  |  |  ------------------
  ------------------
  310|  78.1k|    DO_PRED12(diff_hi, 3);
  ------------------
  |  |  269|  78.1k|  do {                                                    \
  |  |  270|  78.1k|    const __m256i all = _mm256_add_epi16(L, (DIFF));      \
  |  |  271|  78.1k|    const __m256i alls = _mm256_packus_epi16(all, all);   \
  |  |  272|  78.1k|    const __m256i res = _mm256_add_epi8(src, alls);       \
  |  |  273|  78.1k|    out[i + (OUT)] = (uint32_t)_mm256_cvtsi256_si32(res); \
  |  |  274|  78.1k|    L = _mm256_unpacklo_epi8(res, zero);                  \
  |  |  275|  78.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (275:12): [Folded, False: 78.1k]
  |  |  ------------------
  ------------------
  311|       |
  312|       |    // Process the upper lane.
  313|  78.1k|    diff_lo = _mm256_permute2x128_si256(diff_lo_bak, diff_lo_bak, 1);
  314|  78.1k|    diff_hi = _mm256_permute2x128_si256(diff_hi_bak, diff_hi_bak, 1);
  315|  78.1k|    src = _mm256_permute2x128_si256(src_bak, src_bak, 1);
  316|       |
  317|  78.1k|    DO_PRED12(diff_lo, 4);
  ------------------
  |  |  269|  78.1k|  do {                                                    \
  |  |  270|  78.1k|    const __m256i all = _mm256_add_epi16(L, (DIFF));      \
  |  |  271|  78.1k|    const __m256i alls = _mm256_packus_epi16(all, all);   \
  |  |  272|  78.1k|    const __m256i res = _mm256_add_epi8(src, alls);       \
  |  |  273|  78.1k|    out[i + (OUT)] = (uint32_t)_mm256_cvtsi256_si32(res); \
  |  |  274|  78.1k|    L = _mm256_unpacklo_epi8(res, zero);                  \
  |  |  275|  78.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (275:12): [Folded, False: 78.1k]
  |  |  ------------------
  ------------------
  318|  78.1k|    DO_PRED12_SHIFT(diff_lo, 0);
  ------------------
  |  |  278|  78.1k|  do {                                                        \
  |  |  279|  78.1k|    /* Shift the pre-computed value for the next iteration.*/ \
  |  |  280|  78.1k|    if ((LANE) == 0) (DIFF) = _mm256_srli_si256(DIFF, 8);     \
  |  |  ------------------
  |  |  |  Branch (280:9): [True: 78.1k, Folded]
  |  |  ------------------
  |  |  281|  78.1k|    src = _mm256_srli_si256(src, 4);                          \
  |  |  282|  78.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (282:12): [Folded, False: 78.1k]
  |  |  ------------------
  ------------------
  319|  78.1k|    DO_PRED12(diff_lo, 5);
  ------------------
  |  |  269|  78.1k|  do {                                                    \
  |  |  270|  78.1k|    const __m256i all = _mm256_add_epi16(L, (DIFF));      \
  |  |  271|  78.1k|    const __m256i alls = _mm256_packus_epi16(all, all);   \
  |  |  272|  78.1k|    const __m256i res = _mm256_add_epi8(src, alls);       \
  |  |  273|  78.1k|    out[i + (OUT)] = (uint32_t)_mm256_cvtsi256_si32(res); \
  |  |  274|  78.1k|    L = _mm256_unpacklo_epi8(res, zero);                  \
  |  |  275|  78.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (275:12): [Folded, False: 78.1k]
  |  |  ------------------
  ------------------
  320|  78.1k|    DO_PRED12_SHIFT(diff_lo, 1);
  ------------------
  |  |  278|  78.1k|  do {                                                        \
  |  |  279|  78.1k|    /* Shift the pre-computed value for the next iteration.*/ \
  |  |  280|  78.1k|    if ((LANE) == 0) (DIFF) = _mm256_srli_si256(DIFF, 8);     \
  |  |  ------------------
  |  |  |  Branch (280:9): [Folded, False: 78.1k]
  |  |  ------------------
  |  |  281|  78.1k|    src = _mm256_srli_si256(src, 4);                          \
  |  |  282|  78.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (282:12): [Folded, False: 78.1k]
  |  |  ------------------
  ------------------
  321|  78.1k|    DO_PRED12(diff_hi, 6);
  ------------------
  |  |  269|  78.1k|  do {                                                    \
  |  |  270|  78.1k|    const __m256i all = _mm256_add_epi16(L, (DIFF));      \
  |  |  271|  78.1k|    const __m256i alls = _mm256_packus_epi16(all, all);   \
  |  |  272|  78.1k|    const __m256i res = _mm256_add_epi8(src, alls);       \
  |  |  273|  78.1k|    out[i + (OUT)] = (uint32_t)_mm256_cvtsi256_si32(res); \
  |  |  274|  78.1k|    L = _mm256_unpacklo_epi8(res, zero);                  \
  |  |  275|  78.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (275:12): [Folded, False: 78.1k]
  |  |  ------------------
  ------------------
  322|  78.1k|    DO_PRED12_SHIFT(diff_hi, 0);
  ------------------
  |  |  278|  78.1k|  do {                                                        \
  |  |  279|  78.1k|    /* Shift the pre-computed value for the next iteration.*/ \
  |  |  280|  78.1k|    if ((LANE) == 0) (DIFF) = _mm256_srli_si256(DIFF, 8);     \
  |  |  ------------------
  |  |  |  Branch (280:9): [True: 78.1k, Folded]
  |  |  ------------------
  |  |  281|  78.1k|    src = _mm256_srli_si256(src, 4);                          \
  |  |  282|  78.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (282:12): [Folded, False: 78.1k]
  |  |  ------------------
  ------------------
  323|  78.1k|    DO_PRED12(diff_hi, 7);
  ------------------
  |  |  269|  78.1k|  do {                                                    \
  |  |  270|  78.1k|    const __m256i all = _mm256_add_epi16(L, (DIFF));      \
  |  |  271|  78.1k|    const __m256i alls = _mm256_packus_epi16(all, all);   \
  |  |  272|  78.1k|    const __m256i res = _mm256_add_epi8(src, alls);       \
  |  |  273|  78.1k|    out[i + (OUT)] = (uint32_t)_mm256_cvtsi256_si32(res); \
  |  |  274|  78.1k|    L = _mm256_unpacklo_epi8(res, zero);                  \
  |  |  275|  78.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (275:12): [Folded, False: 78.1k]
  |  |  ------------------
  ------------------
  324|  78.1k|  }
  325|  52.9k|  if (i != num_pixels) {
  ------------------
  |  Branch (325:7): [True: 37.1k, False: 15.8k]
  ------------------
  326|  37.1k|    VP8LPredictorsAdd_SSE[12](in + i, upper + i, num_pixels - i, out + i);
  327|  37.1k|  }
  328|  52.9k|}
lossless_avx2.c:AddGreenToBlueAndRed_AVX2:
  339|  10.7k|                                      uint32_t* dst) {
  340|  10.7k|  int i;
  341|  10.7k|  const __m256i kCstShuffle = _mm256_set_epi8(
  342|  10.7k|      -1, 29, -1, 29, -1, 25, -1, 25, -1, 21, -1, 21, -1, 17, -1, 17, -1, 13,
  343|  10.7k|      -1, 13, -1, 9, -1, 9, -1, 5, -1, 5, -1, 1, -1, 1);
  344|   344k|  for (i = 0; i + 8 <= num_pixels; i += 8) {
  ------------------
  |  Branch (344:15): [True: 333k, False: 10.7k]
  ------------------
  345|   333k|    const __m256i in = _mm256_loadu_si256((const __m256i*)&src[i]);  // argb
  346|   333k|    const __m256i in_0g0g = _mm256_shuffle_epi8(in, kCstShuffle);    // 0g0g
  347|   333k|    const __m256i out = _mm256_add_epi8(in, in_0g0g);
  348|   333k|    _mm256_storeu_si256((__m256i*)&dst[i], out);
  349|   333k|  }
  350|       |  // fallthrough and finish off with SSE.
  351|  10.7k|  if (i != num_pixels) {
  ------------------
  |  Branch (351:7): [True: 78, False: 10.7k]
  ------------------
  352|     78|    VP8LAddGreenToBlueAndRed_SSE(src + i, num_pixels - i, dst + i);
  353|     78|  }
  354|  10.7k|}
lossless_avx2.c:TransformColorInverse_AVX2:
  361|   212k|                                       int num_pixels, uint32_t* dst) {
  362|       |// sign-extended multiplying constants, pre-shifted by 5.
  363|   212k|#define CST(X) (((int16_t)(m->X << 8)) >> 5)  // sign-extend
  364|   212k|  const __m256i mults_rb = _mm256_set1_epi32(
  365|   212k|      (int)((uint32_t)CST(green_to_red) << 16 | (CST(green_to_blue) & 0xffff)));
  ------------------
  |  |  363|   212k|#define CST(X) (((int16_t)(m->X << 8)) >> 5)  // sign-extend
  ------------------
                    (int)((uint32_t)CST(green_to_red) << 16 | (CST(green_to_blue) & 0xffff)));
  ------------------
  |  |  363|   212k|#define CST(X) (((int16_t)(m->X << 8)) >> 5)  // sign-extend
  ------------------
  366|   212k|  const __m256i mults_b2 = _mm256_set1_epi32(CST(red_to_blue));
  ------------------
  |  |  363|   212k|#define CST(X) (((int16_t)(m->X << 8)) >> 5)  // sign-extend
  ------------------
  367|   212k|#undef CST
  368|   212k|  const __m256i mask_ag = _mm256_set1_epi32((int)0xff00ff00);
  369|   212k|  const __m256i perm1 = _mm256_setr_epi8(
  370|   212k|      -1, 1, -1, 1, -1, 5, -1, 5, -1, 9, -1, 9, -1, 13, -1, 13, -1, 17, -1, 17,
  371|   212k|      -1, 21, -1, 21, -1, 25, -1, 25, -1, 29, -1, 29);
  372|   212k|  const __m256i perm2 = _mm256_setr_epi8(
  373|   212k|      -1, 2, -1, -1, -1, 6, -1, -1, -1, 10, -1, -1, -1, 14, -1, -1, -1, 18, -1,
  374|   212k|      -1, -1, 22, -1, -1, -1, 26, -1, -1, -1, 30, -1, -1);
  375|   212k|  int i;
  376|   368k|  for (i = 0; i + 8 <= num_pixels; i += 8) {
  ------------------
  |  Branch (376:15): [True: 156k, False: 212k]
  ------------------
  377|   156k|    const __m256i A = _mm256_loadu_si256((const __m256i*)(src + i));
  378|   156k|    const __m256i B = _mm256_shuffle_epi8(A, perm1);  // argb -> g0g0
  379|   156k|    const __m256i C = _mm256_mulhi_epi16(B, mults_rb);
  380|   156k|    const __m256i D = _mm256_add_epi8(A, C);
  381|   156k|    const __m256i E = _mm256_shuffle_epi8(D, perm2);
  382|   156k|    const __m256i F = _mm256_mulhi_epi16(E, mults_b2);
  383|   156k|    const __m256i G = _mm256_add_epi8(D, F);
  384|   156k|    const __m256i out = _mm256_blendv_epi8(G, A, mask_ag);
  385|   156k|    _mm256_storeu_si256((__m256i*)&dst[i], out);
  386|   156k|  }
  387|       |  // Fall-back to SSE-version for left-overs.
  388|   212k|  if (i != num_pixels) {
  ------------------
  |  Branch (388:7): [True: 144k, False: 67.5k]
  ------------------
  389|   144k|    VP8LTransformColorInverse_SSE(m, src + i, num_pixels - i, dst + i);
  390|   144k|  }
  391|   212k|}
lossless_avx2.c:ConvertBGRAToRGB_AVX2:
  432|   141k|                                  int num_pixels, uint8_t* WEBP_RESTRICT dst) {
  433|   141k|  const __m256i shuf =
  434|   141k|      _mm256_setr_epi8(2, 1, 0, 6, 5, 4, 10, 9, 8, 14, 13, 12, -1, -1, -1, -1,
  435|   141k|                       2, 1, 0, 6, 5, 4, 10, 9, 8, 14, 13, 12, -1, -1, -1, -1);
  436|       |
  437|   141k|  ARGB_TO_RGB_AVX2;
  ------------------
  |  |  401|   141k|  do {                                                                    \
  |  |  402|   141k|    const __m256i perm0 = _mm256_setr_epi32(0, 1, 2, 4, 5, 6, -1, -1);    \
  |  |  403|   141k|    const __m256i perm1 = _mm256_setr_epi32(2, 4, 5, 6, -1, -1, 0, 1);    \
  |  |  404|   141k|    const __m256i perm2 = _mm256_setr_epi32(5, 6, -1, -1, 0, 1, 2, 4);    \
  |  |  405|   141k|    const __m256i perm3 = _mm256_setr_epi32(-1, -1, 0, 1, 2, 4, 5, 6);    \
  |  |  406|   214k|    while (num_pixels >= 32) {                                            \
  |  |  ------------------
  |  |  |  Branch (406:12): [True: 73.3k, False: 141k]
  |  |  ------------------
  |  |  407|  73.3k|      const __m256i in0 = _mm256_loadu_si256((const __m256i*)(src + 0));  \
  |  |  408|  73.3k|      const __m256i in1 = _mm256_loadu_si256((const __m256i*)(src + 8));  \
  |  |  409|  73.3k|      const __m256i in2 = _mm256_loadu_si256((const __m256i*)(src + 16)); \
  |  |  410|  73.3k|      const __m256i in3 = _mm256_loadu_si256((const __m256i*)(src + 24)); \
  |  |  411|  73.3k|      const __m256i a0 = _mm256_shuffle_epi8(in0, shuf);                  \
  |  |  412|  73.3k|      const __m256i a1 = _mm256_shuffle_epi8(in1, shuf);                  \
  |  |  413|  73.3k|      const __m256i a2 = _mm256_shuffle_epi8(in2, shuf);                  \
  |  |  414|  73.3k|      const __m256i a3 = _mm256_shuffle_epi8(in3, shuf);                  \
  |  |  415|  73.3k|      const __m256i b0 = _mm256_permutevar8x32_epi32(a0, perm0);          \
  |  |  416|  73.3k|      const __m256i b1 = _mm256_permutevar8x32_epi32(a1, perm1);          \
  |  |  417|  73.3k|      const __m256i b2 = _mm256_permutevar8x32_epi32(a2, perm2);          \
  |  |  418|  73.3k|      const __m256i b3 = _mm256_permutevar8x32_epi32(a3, perm3);          \
  |  |  419|  73.3k|      const __m256i c0 = _mm256_blend_epi32(b0, b1, 0xc0);                \
  |  |  420|  73.3k|      const __m256i c1 = _mm256_blend_epi32(b1, b2, 0xf0);                \
  |  |  421|  73.3k|      const __m256i c2 = _mm256_blend_epi32(b2, b3, 0xfc);                \
  |  |  422|  73.3k|      _mm256_storeu_si256((__m256i*)(dst + 0), c0);                       \
  |  |  423|  73.3k|      _mm256_storeu_si256((__m256i*)(dst + 32), c1);                      \
  |  |  424|  73.3k|      _mm256_storeu_si256((__m256i*)(dst + 64), c2);                      \
  |  |  425|  73.3k|      src += 32;                                                          \
  |  |  426|  73.3k|      dst += 96;                                                          \
  |  |  427|  73.3k|      num_pixels -= 32;                                                   \
  |  |  428|  73.3k|    }                                                                     \
  |  |  429|   141k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (429:12): [Folded, False: 141k]
  |  |  ------------------
  ------------------
  438|       |
  439|       |  // left-overs
  440|   141k|  if (num_pixels > 0) {
  ------------------
  |  Branch (440:7): [True: 139k, False: 2.00k]
  ------------------
  441|   139k|    VP8LConvertBGRAToRGB_SSE(src, num_pixels, dst);
  442|   139k|  }
  443|   141k|}
lossless_avx2.c:ConvertBGRAToRGBA_AVX2:
  462|   205k|                                   int num_pixels, uint8_t* WEBP_RESTRICT dst) {
  463|   699k|  while (num_pixels >= 8) {
  ------------------
  |  Branch (463:10): [True: 494k, False: 205k]
  ------------------
  464|   494k|    const __m256i A = _mm256_loadu_si256((const __m256i*)src);
  465|   494k|    const __m256i B = _mm256_shuffle_epi8(
  466|   494k|        A,
  467|   494k|        _mm256_set_epi8(15, 12, 13, 14, 11, 8, 9, 10, 7, 4, 5, 6, 3, 0, 1, 2,
  468|   494k|                        15, 12, 13, 14, 11, 8, 9, 10, 7, 4, 5, 6, 3, 0, 1, 2));
  469|   494k|    _mm256_storeu_si256((__m256i*)dst, B);
  470|   494k|    src += 8;
  471|   494k|    dst += 32;
  472|   494k|    num_pixels -= 8;
  473|   494k|  }
  474|       |  // left-overs
  475|   205k|  if (num_pixels > 0) {
  ------------------
  |  Branch (475:7): [True: 189k, False: 16.2k]
  ------------------
  476|   189k|    VP8LConvertBGRAToRGBA_SSE(src, num_pixels, dst);
  477|   189k|  }
  478|   205k|}
lossless_avx2.c:ConvertBGRAToBGR_AVX2:
  446|   163k|                                  int num_pixels, uint8_t* WEBP_RESTRICT dst) {
  447|   163k|  const __m256i shuf =
  448|   163k|      _mm256_setr_epi8(0, 1, 2, 4, 5, 6, 8, 9, 10, 12, 13, 14, -1, -1, -1, -1,
  449|   163k|                       0, 1, 2, 4, 5, 6, 8, 9, 10, 12, 13, 14, -1, -1, -1, -1);
  450|       |
  451|   163k|  ARGB_TO_RGB_AVX2;
  ------------------
  |  |  401|   163k|  do {                                                                    \
  |  |  402|   163k|    const __m256i perm0 = _mm256_setr_epi32(0, 1, 2, 4, 5, 6, -1, -1);    \
  |  |  403|   163k|    const __m256i perm1 = _mm256_setr_epi32(2, 4, 5, 6, -1, -1, 0, 1);    \
  |  |  404|   163k|    const __m256i perm2 = _mm256_setr_epi32(5, 6, -1, -1, 0, 1, 2, 4);    \
  |  |  405|   163k|    const __m256i perm3 = _mm256_setr_epi32(-1, -1, 0, 1, 2, 4, 5, 6);    \
  |  |  406|   247k|    while (num_pixels >= 32) {                                            \
  |  |  ------------------
  |  |  |  Branch (406:12): [True: 84.2k, False: 163k]
  |  |  ------------------
  |  |  407|  84.2k|      const __m256i in0 = _mm256_loadu_si256((const __m256i*)(src + 0));  \
  |  |  408|  84.2k|      const __m256i in1 = _mm256_loadu_si256((const __m256i*)(src + 8));  \
  |  |  409|  84.2k|      const __m256i in2 = _mm256_loadu_si256((const __m256i*)(src + 16)); \
  |  |  410|  84.2k|      const __m256i in3 = _mm256_loadu_si256((const __m256i*)(src + 24)); \
  |  |  411|  84.2k|      const __m256i a0 = _mm256_shuffle_epi8(in0, shuf);                  \
  |  |  412|  84.2k|      const __m256i a1 = _mm256_shuffle_epi8(in1, shuf);                  \
  |  |  413|  84.2k|      const __m256i a2 = _mm256_shuffle_epi8(in2, shuf);                  \
  |  |  414|  84.2k|      const __m256i a3 = _mm256_shuffle_epi8(in3, shuf);                  \
  |  |  415|  84.2k|      const __m256i b0 = _mm256_permutevar8x32_epi32(a0, perm0);          \
  |  |  416|  84.2k|      const __m256i b1 = _mm256_permutevar8x32_epi32(a1, perm1);          \
  |  |  417|  84.2k|      const __m256i b2 = _mm256_permutevar8x32_epi32(a2, perm2);          \
  |  |  418|  84.2k|      const __m256i b3 = _mm256_permutevar8x32_epi32(a3, perm3);          \
  |  |  419|  84.2k|      const __m256i c0 = _mm256_blend_epi32(b0, b1, 0xc0);                \
  |  |  420|  84.2k|      const __m256i c1 = _mm256_blend_epi32(b1, b2, 0xf0);                \
  |  |  421|  84.2k|      const __m256i c2 = _mm256_blend_epi32(b2, b3, 0xfc);                \
  |  |  422|  84.2k|      _mm256_storeu_si256((__m256i*)(dst + 0), c0);                       \
  |  |  423|  84.2k|      _mm256_storeu_si256((__m256i*)(dst + 32), c1);                      \
  |  |  424|  84.2k|      _mm256_storeu_si256((__m256i*)(dst + 64), c2);                      \
  |  |  425|  84.2k|      src += 32;                                                          \
  |  |  426|  84.2k|      dst += 96;                                                          \
  |  |  427|  84.2k|      num_pixels -= 32;                                                   \
  |  |  428|  84.2k|    }                                                                     \
  |  |  429|   163k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (429:12): [Folded, False: 163k]
  |  |  ------------------
  ------------------
  452|       |
  453|       |  // left-overs
  454|   163k|  if (num_pixels > 0) {
  ------------------
  |  Branch (454:7): [True: 163k, False: 293]
  ------------------
  455|   163k|    VP8LConvertBGRAToBGR_SSE(src, num_pixels, dst);
  456|   163k|  }
  457|   163k|}

vp8l_dec.c:VP8LSubSampleSize:
   51|  5.14k|                                              uint32_t sampling_bits) {
   52|  5.14k|  return (size + (1 << sampling_bits) - 1) >> sampling_bits;
   53|  5.14k|}
lossless.c:VP8LAddPixels:
  172|  1.90M|VP8LAddPixels(uint32_t a, uint32_t b) {
  173|  1.90M|  const uint32_t alpha_and_green = (a & 0xff00ff00u) + (b & 0xff00ff00u);
  174|  1.90M|  const uint32_t red_and_blue = (a & 0x00ff00ffu) + (b & 0x00ff00ffu);
  175|  1.90M|  return (alpha_and_green & 0xff00ff00u) | (red_and_blue & 0x00ff00ffu);
  176|  1.90M|}
lossless.c:VP8LSubSampleSize:
   51|  25.4k|                                              uint32_t sampling_bits) {
   52|  25.4k|  return (size + (1 << sampling_bits) - 1) >> sampling_bits;
   53|  25.4k|}
lossless.c:VP8GetARGBIndex:
   34|  1.97M|static WEBP_INLINE uint32_t VP8GetARGBIndex(uint32_t idx) {
   35|  1.97M|  return (idx >> 8) & 0xff;
   36|  1.97M|}
lossless.c:VP8GetARGBValue:
   40|  3.62M|static WEBP_INLINE uint32_t VP8GetARGBValue(uint32_t val) { return val; }
lossless_sse2.c:VP8LAddPixels:
  172|   741k|VP8LAddPixels(uint32_t a, uint32_t b) {
  173|   741k|  const uint32_t alpha_and_green = (a & 0xff00ff00u) + (b & 0xff00ff00u);
  174|   741k|  const uint32_t red_and_blue = (a & 0x00ff00ffu) + (b & 0x00ff00ffu);
  175|   741k|  return (alpha_and_green & 0xff00ff00u) | (red_and_blue & 0x00ff00ffu);
  176|   741k|}

VP8LDspInitSSE2:
  678|      1|WEBP_TSAN_IGNORE_FUNCTION void VP8LDspInitSSE2(void) {
  679|      1|  VP8LPredictors[5] = Predictor5_SSE2;
  680|      1|  VP8LPredictors[6] = Predictor6_SSE2;
  681|      1|  VP8LPredictors[7] = Predictor7_SSE2;
  682|      1|  VP8LPredictors[8] = Predictor8_SSE2;
  683|      1|  VP8LPredictors[9] = Predictor9_SSE2;
  684|      1|  VP8LPredictors[10] = Predictor10_SSE2;
  685|      1|  VP8LPredictors[11] = Predictor11_SSE2;
  686|      1|  VP8LPredictors[12] = Predictor12_SSE2;
  687|      1|  VP8LPredictors[13] = Predictor13_SSE2;
  688|       |
  689|       |  // SSE exports for AVX and above.
  690|      1|  VP8LPredictorsAdd_SSE[0] = PredictorAdd0_SSE2;
  691|      1|  VP8LPredictorsAdd_SSE[1] = PredictorAdd1_SSE2;
  692|      1|  VP8LPredictorsAdd_SSE[2] = PredictorAdd2_SSE2;
  693|      1|  VP8LPredictorsAdd_SSE[3] = PredictorAdd3_SSE2;
  694|      1|  VP8LPredictorsAdd_SSE[4] = PredictorAdd4_SSE2;
  695|      1|  VP8LPredictorsAdd_SSE[5] = PredictorAdd5_SSE2;
  696|      1|  VP8LPredictorsAdd_SSE[6] = PredictorAdd6_SSE2;
  697|      1|  VP8LPredictorsAdd_SSE[7] = PredictorAdd7_SSE2;
  698|      1|  VP8LPredictorsAdd_SSE[8] = PredictorAdd8_SSE2;
  699|      1|  VP8LPredictorsAdd_SSE[9] = PredictorAdd9_SSE2;
  700|      1|  VP8LPredictorsAdd_SSE[10] = PredictorAdd10_SSE2;
  701|      1|  VP8LPredictorsAdd_SSE[11] = PredictorAdd11_SSE2;
  702|      1|  VP8LPredictorsAdd_SSE[12] = PredictorAdd12_SSE2;
  703|      1|  VP8LPredictorsAdd_SSE[13] = PredictorAdd13_SSE2;
  704|       |  // padding security sentinels
  705|      1|  VP8LPredictorsAdd_SSE[14] = PredictorAdd0_SSE2;
  706|      1|  VP8LPredictorsAdd_SSE[15] = PredictorAdd0_SSE2;
  707|      1|  memcpy(VP8LPredictorsAdd, VP8LPredictorsAdd_SSE, sizeof(VP8LPredictorsAdd));
  708|       |
  709|       |  // SSE exports for AVX and above.
  710|      1|  VP8LAddGreenToBlueAndRed_SSE = AddGreenToBlueAndRed_SSE2;
  711|      1|  VP8LTransformColorInverse_SSE = TransformColorInverse_SSE2;
  712|      1|  VP8LAddGreenToBlueAndRed = VP8LAddGreenToBlueAndRed_SSE;
  713|      1|  VP8LTransformColorInverse = VP8LTransformColorInverse_SSE;
  714|       |
  715|      1|  VP8LConvertBGRAToRGB = ConvertBGRAToRGB_SSE2;
  716|      1|  VP8LConvertBGRAToRGBA = ConvertBGRAToRGBA_SSE2;
  717|      1|  VP8LConvertBGRAToRGBA4444 = ConvertBGRAToRGBA4444_SSE2;
  718|      1|  VP8LConvertBGRAToRGB565 = ConvertBGRAToRGB565_SSE2;
  719|      1|  VP8LConvertBGRAToBGR = ConvertBGRAToBGR_SSE2;
  720|       |
  721|      1|  VP8LConvertBGRAToRGB_SSE = ConvertBGRAToRGB_SSE2;
  722|      1|  VP8LConvertBGRAToRGBA_SSE = ConvertBGRAToRGBA_SSE2;
  723|      1|  VP8LConvertBGRAToBGR_SSE = ConvertBGRAToBGR_SSE2;
  724|      1|}
lossless_sse2.c:Predictor5_SSE2:
  131|   159k|                                const uint32_t* const top) {
  132|   159k|  const uint32_t pred = Average3_SSE2(*left, top[0], top[1]);
  133|   159k|  return pred;
  134|   159k|}
lossless_sse2.c:Average3_SSE2:
  110|   159k|                                          uint32_t a2) {
  111|   159k|  const __m128i zero = _mm_setzero_si128();
  112|   159k|  const __m128i avg1 = Average2_uint32_16_SSE2(a0, a2);
  113|   159k|  const __m128i A1 = _mm_unpacklo_epi8(_mm_cvtsi32_si128((int)a1), zero);
  114|   159k|  const __m128i sum = _mm_add_epi16(avg1, A1);
  115|   159k|  const __m128i avg2 = _mm_srli_epi16(sum, 1);
  116|   159k|  const __m128i A2 = _mm_packus_epi16(avg2, avg2);
  117|   159k|  return (uint32_t)_mm_cvtsi128_si32(A2);
  118|   159k|}
lossless_sse2.c:Average2_uint32_16_SSE2:
   95|   159k|static WEBP_INLINE __m128i Average2_uint32_16_SSE2(uint32_t a0, uint32_t a1) {
   96|   159k|  const __m128i zero = _mm_setzero_si128();
   97|   159k|  const __m128i A0 = _mm_unpacklo_epi8(_mm_cvtsi32_si128((int)a0), zero);
   98|   159k|  const __m128i A1 = _mm_unpacklo_epi8(_mm_cvtsi32_si128((int)a1), zero);
   99|   159k|  const __m128i sum = _mm_add_epi16(A1, A0);
  100|   159k|  return _mm_srli_epi16(sum, 1);
  101|   159k|}
lossless_sse2.c:Predictor6_SSE2:
  136|   190k|                                const uint32_t* const top) {
  137|   190k|  const uint32_t pred = Average2_SSE2(*left, top[-1]);
  138|   190k|  return pred;
  139|   190k|}
lossless_sse2.c:Average2_SSE2:
  103|   308k|static WEBP_INLINE uint32_t Average2_SSE2(uint32_t a0, uint32_t a1) {
  104|   308k|  __m128i output;
  105|   308k|  Average2_uint32_SSE2(a0, a1, &output);
  106|   308k|  return (uint32_t)_mm_cvtsi128_si32(output);
  107|   308k|}
lossless_sse2.c:Average2_uint32_SSE2:
   85|   308k|                                             __m128i* const avg) {
   86|       |  // (a + b) >> 1 = ((a + b + 1) >> 1) - ((a ^ b) & 1)
   87|   308k|  const __m128i ones = _mm_set1_epi8(1);
   88|   308k|  const __m128i A0 = _mm_cvtsi32_si128((int)a0);
   89|   308k|  const __m128i A1 = _mm_cvtsi32_si128((int)a1);
   90|   308k|  const __m128i avg1 = _mm_avg_epu8(A0, A1);
   91|   308k|  const __m128i one = _mm_and_si128(_mm_xor_si128(A0, A1), ones);
   92|   308k|  *avg = _mm_sub_epi8(avg1, one);
   93|   308k|}
lossless_sse2.c:Predictor7_SSE2:
  141|   117k|                                const uint32_t* const top) {
  142|   117k|  const uint32_t pred = Average2_SSE2(*left, top[0]);
  143|   117k|  return pred;
  144|   117k|}
lossless_sse2.c:Predictor13_SSE2:
  173|   273k|                                 const uint32_t* const top) {
  174|   273k|  const uint32_t pred = ClampedAddSubtractHalf_SSE2(*left, top[0], top[-1]);
  175|   273k|  return pred;
  176|   273k|}
lossless_sse2.c:ClampedAddSubtractHalf_SSE2:
   46|   273k|                                                        uint32_t c2) {
   47|   273k|  const __m128i zero = _mm_setzero_si128();
   48|   273k|  const __m128i C0 = _mm_unpacklo_epi8(_mm_cvtsi32_si128((int)c0), zero);
   49|   273k|  const __m128i C1 = _mm_unpacklo_epi8(_mm_cvtsi32_si128((int)c1), zero);
   50|   273k|  const __m128i B0 = _mm_unpacklo_epi8(_mm_cvtsi32_si128((int)c2), zero);
   51|   273k|  const __m128i avg = _mm_add_epi16(C1, C0);
   52|   273k|  const __m128i A0 = _mm_srli_epi16(avg, 1);
   53|   273k|  const __m128i A1 = _mm_sub_epi16(A0, B0);
   54|   273k|  const __m128i BgtA = _mm_cmpgt_epi16(B0, A0);
   55|   273k|  const __m128i A2 = _mm_sub_epi16(A1, BgtA);
   56|   273k|  const __m128i A3 = _mm_srai_epi16(A2, 1);
   57|   273k|  const __m128i A4 = _mm_add_epi16(A0, A3);
   58|   273k|  const __m128i A5 = _mm_packus_epi16(A4, A4);
   59|   273k|  return (uint32_t)_mm_cvtsi128_si32(A5);
   60|   273k|}
lossless_sse2.c:PredictorAdd0_SSE2:
  182|   114k|                               int num_pixels, uint32_t* WEBP_RESTRICT out) {
  183|   114k|  int i;
  184|   114k|  const __m128i black = _mm_set1_epi32((int)ARGB_BLACK);
  ------------------
  |  |   38|   114k|#define ARGB_BLACK 0xff000000
  ------------------
  185|   318k|  for (i = 0; i + 4 <= num_pixels; i += 4) {
  ------------------
  |  Branch (185:15): [True: 204k, False: 114k]
  ------------------
  186|   204k|    const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);
  187|   204k|    const __m128i res = _mm_add_epi8(src, black);
  188|   204k|    _mm_storeu_si128((__m128i*)&out[i], res);
  189|   204k|  }
  190|   114k|  if (i != num_pixels) {
  ------------------
  |  Branch (190:7): [True: 76.7k, False: 37.7k]
  ------------------
  191|       |    VP8LPredictorsAdd_C[0](in + i, NULL, num_pixels - i, out + i);
  192|  76.7k|  }
  193|   114k|  (void)upper;
  194|   114k|}
lossless_sse2.c:PredictorAdd1_SSE2:
  198|  78.8k|                               int num_pixels, uint32_t* WEBP_RESTRICT out) {
  199|  78.8k|  int i;
  200|  78.8k|  __m128i prev = _mm_set1_epi32((int)out[-1]);
  201|   124k|  for (i = 0; i + 4 <= num_pixels; i += 4) {
  ------------------
  |  Branch (201:15): [True: 45.3k, False: 78.8k]
  ------------------
  202|       |    // a | b | c | d
  203|  45.3k|    const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);
  204|       |    // 0 | a | b | c
  205|  45.3k|    const __m128i shift0 = _mm_slli_si128(src, 4);
  206|       |    // a | a + b | b + c | c + d
  207|  45.3k|    const __m128i sum0 = _mm_add_epi8(src, shift0);
  208|       |    // 0 | 0 | a | a + b
  209|  45.3k|    const __m128i shift1 = _mm_slli_si128(sum0, 8);
  210|       |    // a | a + b | a + b + c | a + b + c + d
  211|  45.3k|    const __m128i sum1 = _mm_add_epi8(sum0, shift1);
  212|  45.3k|    const __m128i res = _mm_add_epi8(sum1, prev);
  213|  45.3k|    _mm_storeu_si128((__m128i*)&out[i], res);
  214|       |    // replicate prev output on the four lanes
  215|  45.3k|    prev = _mm_shuffle_epi32(res, (3 << 0) | (3 << 2) | (3 << 4) | (3 << 6));
  216|  45.3k|  }
  217|  78.8k|  if (i != num_pixels) {
  ------------------
  |  Branch (217:7): [True: 41.5k, False: 37.2k]
  ------------------
  218|  41.5k|    VP8LPredictorsAdd_C[1](in + i, upper + i, num_pixels - i, out + i);
  219|  41.5k|  }
  220|  78.8k|}
lossless_sse2.c:PredictorAdd2_SSE2:
  227|  45.2k|                                     uint32_t* WEBP_RESTRICT out) {         \
  228|  45.2k|    int i;                                                                  \
  229|  71.0k|    for (i = 0; i + 4 <= num_pixels; i += 4) {                              \
  ------------------
  |  Branch (229:17): [True: 25.8k, False: 45.2k]
  ------------------
  230|  25.8k|      const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);          \
  231|  25.8k|      const __m128i other = _mm_loadu_si128((const __m128i*)&(IN));         \
  232|  25.8k|      const __m128i res = _mm_add_epi8(src, other);                         \
  233|  25.8k|      _mm_storeu_si128((__m128i*)&out[i], res);                             \
  234|  25.8k|    }                                                                       \
  235|  45.2k|    if (i != num_pixels) {                                                  \
  ------------------
  |  Branch (235:9): [True: 26.0k, False: 19.2k]
  ------------------
  236|  26.0k|      VP8LPredictorsAdd_C[(X)](in + i, upper + i, num_pixels - i, out + i); \
  237|  26.0k|    }                                                                       \
  238|  45.2k|  }
lossless_sse2.c:PredictorAdd3_SSE2:
  227|  45.3k|                                     uint32_t* WEBP_RESTRICT out) {         \
  228|  45.3k|    int i;                                                                  \
  229|  84.7k|    for (i = 0; i + 4 <= num_pixels; i += 4) {                              \
  ------------------
  |  Branch (229:17): [True: 39.3k, False: 45.3k]
  ------------------
  230|  39.3k|      const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);          \
  231|  39.3k|      const __m128i other = _mm_loadu_si128((const __m128i*)&(IN));         \
  232|  39.3k|      const __m128i res = _mm_add_epi8(src, other);                         \
  233|  39.3k|      _mm_storeu_si128((__m128i*)&out[i], res);                             \
  234|  39.3k|    }                                                                       \
  235|  45.3k|    if (i != num_pixels) {                                                  \
  ------------------
  |  Branch (235:9): [True: 12.0k, False: 33.3k]
  ------------------
  236|  12.0k|      VP8LPredictorsAdd_C[(X)](in + i, upper + i, num_pixels - i, out + i); \
  237|  12.0k|    }                                                                       \
  238|  45.3k|  }
lossless_sse2.c:PredictorAdd4_SSE2:
  227|  34.4k|                                     uint32_t* WEBP_RESTRICT out) {         \
  228|  34.4k|    int i;                                                                  \
  229|  64.3k|    for (i = 0; i + 4 <= num_pixels; i += 4) {                              \
  ------------------
  |  Branch (229:17): [True: 29.8k, False: 34.4k]
  ------------------
  230|  29.8k|      const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);          \
  231|  29.8k|      const __m128i other = _mm_loadu_si128((const __m128i*)&(IN));         \
  232|  29.8k|      const __m128i res = _mm_add_epi8(src, other);                         \
  233|  29.8k|      _mm_storeu_si128((__m128i*)&out[i], res);                             \
  234|  29.8k|    }                                                                       \
  235|  34.4k|    if (i != num_pixels) {                                                  \
  ------------------
  |  Branch (235:9): [True: 6.52k, False: 27.9k]
  ------------------
  236|  6.52k|      VP8LPredictorsAdd_C[(X)](in + i, upper + i, num_pixels - i, out + i); \
  237|  6.52k|    }                                                                       \
  238|  34.4k|  }
lossless_sse2.c:PredictorAdd8_SSE2:
  257|  31.3k|                                     uint32_t* WEBP_RESTRICT out) {         \
  258|  31.3k|    int i;                                                                  \
  259|  54.4k|    for (i = 0; i + 4 <= num_pixels; i += 4) {                              \
  ------------------
  |  Branch (259:17): [True: 23.1k, False: 31.3k]
  ------------------
  260|  23.1k|      const __m128i Tother = _mm_loadu_si128((const __m128i*)&(IN));        \
  261|  23.1k|      const __m128i T = _mm_loadu_si128((const __m128i*)&upper[i]);         \
  262|  23.1k|      const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);          \
  263|  23.1k|      __m128i avg, res;                                                     \
  264|  23.1k|      Average2_m128i(&T, &Tother, &avg);                                    \
  265|  23.1k|      res = _mm_add_epi8(avg, src);                                         \
  266|  23.1k|      _mm_storeu_si128((__m128i*)&out[i], res);                             \
  267|  23.1k|    }                                                                       \
  268|  31.3k|    if (i != num_pixels) {                                                  \
  ------------------
  |  Branch (268:9): [True: 9.64k, False: 21.6k]
  ------------------
  269|  9.64k|      VP8LPredictorsAdd_C[(X)](in + i, upper + i, num_pixels - i, out + i); \
  270|  9.64k|    }                                                                       \
  271|  31.3k|  }
lossless_sse2.c:Average2_m128i:
   75|   693k|                                       __m128i* const avg) {
   76|       |  // (a + b) >> 1 = ((a + b + 1) >> 1) - ((a ^ b) & 1)
   77|   693k|  const __m128i ones = _mm_set1_epi8(1);
   78|   693k|  const __m128i avg1 = _mm_avg_epu8(*a0, *a1);
   79|   693k|  const __m128i one = _mm_and_si128(_mm_xor_si128(*a0, *a1), ones);
   80|   693k|  *avg = _mm_sub_epi8(avg1, one);
   81|   693k|}
lossless_sse2.c:PredictorAdd9_SSE2:
  257|  42.4k|                                     uint32_t* WEBP_RESTRICT out) {         \
  258|  42.4k|    int i;                                                                  \
  259|  78.0k|    for (i = 0; i + 4 <= num_pixels; i += 4) {                              \
  ------------------
  |  Branch (259:17): [True: 35.5k, False: 42.4k]
  ------------------
  260|  35.5k|      const __m128i Tother = _mm_loadu_si128((const __m128i*)&(IN));        \
  261|  35.5k|      const __m128i T = _mm_loadu_si128((const __m128i*)&upper[i]);         \
  262|  35.5k|      const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);          \
  263|  35.5k|      __m128i avg, res;                                                     \
  264|  35.5k|      Average2_m128i(&T, &Tother, &avg);                                    \
  265|  35.5k|      res = _mm_add_epi8(avg, src);                                         \
  266|  35.5k|      _mm_storeu_si128((__m128i*)&out[i], res);                             \
  267|  35.5k|    }                                                                       \
  268|  42.4k|    if (i != num_pixels) {                                                  \
  ------------------
  |  Branch (268:9): [True: 9.44k, False: 33.0k]
  ------------------
  269|  9.44k|      VP8LPredictorsAdd_C[(X)](in + i, upper + i, num_pixels - i, out + i); \
  270|  9.44k|    }                                                                       \
  271|  42.4k|  }
lossless_sse2.c:PredictorAdd10_SSE2:
  297|  76.0k|                                int num_pixels, uint32_t* WEBP_RESTRICT out) {
  298|  76.0k|  int i;
  299|  76.0k|  __m128i L = _mm_cvtsi32_si128((int)out[-1]);
  300|   146k|  for (i = 0; i + 4 <= num_pixels; i += 4) {
  ------------------
  |  Branch (300:15): [True: 70.5k, False: 76.0k]
  ------------------
  301|  70.5k|    __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);
  302|  70.5k|    __m128i TL = _mm_loadu_si128((const __m128i*)&upper[i - 1]);
  303|  70.5k|    const __m128i T = _mm_loadu_si128((const __m128i*)&upper[i]);
  304|  70.5k|    const __m128i TR = _mm_loadu_si128((const __m128i*)&upper[i + 1]);
  305|  70.5k|    __m128i avgTTR;
  306|  70.5k|    Average2_m128i(&T, &TR, &avgTTR);
  307|  70.5k|    DO_PRED10(0);
  ------------------
  |  |  280|  70.5k|  do {                                               \
  |  |  281|  70.5k|    __m128i avgLTL, avg;                             \
  |  |  282|  70.5k|    Average2_m128i(&L, &TL, &avgLTL);                \
  |  |  283|  70.5k|    Average2_m128i(&avgTTR, &avgLTL, &avg);          \
  |  |  284|  70.5k|    L = _mm_add_epi8(avg, src);                      \
  |  |  285|  70.5k|    out[i + (OUT)] = (uint32_t)_mm_cvtsi128_si32(L); \
  |  |  286|  70.5k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (286:12): [Folded, False: 70.5k]
  |  |  ------------------
  ------------------
  308|  70.5k|    DO_PRED10_SHIFT;
  ------------------
  |  |  289|  70.5k|  do {                                                          \
  |  |  290|  70.5k|    /* Rotate the pre-computed values for the next iteration.*/ \
  |  |  291|  70.5k|    avgTTR = _mm_srli_si128(avgTTR, 4);                         \
  |  |  292|  70.5k|    TL = _mm_srli_si128(TL, 4);                                 \
  |  |  293|  70.5k|    src = _mm_srli_si128(src, 4);                               \
  |  |  294|  70.5k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (294:12): [Folded, False: 70.5k]
  |  |  ------------------
  ------------------
  309|  70.5k|    DO_PRED10(1);
  ------------------
  |  |  280|  70.5k|  do {                                               \
  |  |  281|  70.5k|    __m128i avgLTL, avg;                             \
  |  |  282|  70.5k|    Average2_m128i(&L, &TL, &avgLTL);                \
  |  |  283|  70.5k|    Average2_m128i(&avgTTR, &avgLTL, &avg);          \
  |  |  284|  70.5k|    L = _mm_add_epi8(avg, src);                      \
  |  |  285|  70.5k|    out[i + (OUT)] = (uint32_t)_mm_cvtsi128_si32(L); \
  |  |  286|  70.5k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (286:12): [Folded, False: 70.5k]
  |  |  ------------------
  ------------------
  310|  70.5k|    DO_PRED10_SHIFT;
  ------------------
  |  |  289|  70.5k|  do {                                                          \
  |  |  290|  70.5k|    /* Rotate the pre-computed values for the next iteration.*/ \
  |  |  291|  70.5k|    avgTTR = _mm_srli_si128(avgTTR, 4);                         \
  |  |  292|  70.5k|    TL = _mm_srli_si128(TL, 4);                                 \
  |  |  293|  70.5k|    src = _mm_srli_si128(src, 4);                               \
  |  |  294|  70.5k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (294:12): [Folded, False: 70.5k]
  |  |  ------------------
  ------------------
  311|  70.5k|    DO_PRED10(2);
  ------------------
  |  |  280|  70.5k|  do {                                               \
  |  |  281|  70.5k|    __m128i avgLTL, avg;                             \
  |  |  282|  70.5k|    Average2_m128i(&L, &TL, &avgLTL);                \
  |  |  283|  70.5k|    Average2_m128i(&avgTTR, &avgLTL, &avg);          \
  |  |  284|  70.5k|    L = _mm_add_epi8(avg, src);                      \
  |  |  285|  70.5k|    out[i + (OUT)] = (uint32_t)_mm_cvtsi128_si32(L); \
  |  |  286|  70.5k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (286:12): [Folded, False: 70.5k]
  |  |  ------------------
  ------------------
  312|  70.5k|    DO_PRED10_SHIFT;
  ------------------
  |  |  289|  70.5k|  do {                                                          \
  |  |  290|  70.5k|    /* Rotate the pre-computed values for the next iteration.*/ \
  |  |  291|  70.5k|    avgTTR = _mm_srli_si128(avgTTR, 4);                         \
  |  |  292|  70.5k|    TL = _mm_srli_si128(TL, 4);                                 \
  |  |  293|  70.5k|    src = _mm_srli_si128(src, 4);                               \
  |  |  294|  70.5k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (294:12): [Folded, False: 70.5k]
  |  |  ------------------
  ------------------
  313|  70.5k|    DO_PRED10(3);
  ------------------
  |  |  280|  70.5k|  do {                                               \
  |  |  281|  70.5k|    __m128i avgLTL, avg;                             \
  |  |  282|  70.5k|    Average2_m128i(&L, &TL, &avgLTL);                \
  |  |  283|  70.5k|    Average2_m128i(&avgTTR, &avgLTL, &avg);          \
  |  |  284|  70.5k|    L = _mm_add_epi8(avg, src);                      \
  |  |  285|  70.5k|    out[i + (OUT)] = (uint32_t)_mm_cvtsi128_si32(L); \
  |  |  286|  70.5k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (286:12): [Folded, False: 70.5k]
  |  |  ------------------
  ------------------
  314|  70.5k|  }
  315|  76.0k|  if (i != num_pixels) {
  ------------------
  |  Branch (315:7): [True: 15.3k, False: 60.7k]
  ------------------
  316|  15.3k|    VP8LPredictorsAdd_C[10](in + i, upper + i, num_pixels - i, out + i);
  317|  15.3k|  }
  318|  76.0k|}
lossless_sse2.c:PredictorAdd11_SSE2:
  346|  75.3k|                                int num_pixels, uint32_t* WEBP_RESTRICT out) {
  347|  75.3k|  int i;
  348|  75.3k|  __m128i pa;
  349|  75.3k|  __m128i L = _mm_cvtsi32_si128((int)out[-1]);
  350|   135k|  for (i = 0; i + 4 <= num_pixels; i += 4) {
  ------------------
  |  Branch (350:15): [True: 60.6k, False: 75.3k]
  ------------------
  351|  60.6k|    __m128i T = _mm_loadu_si128((const __m128i*)&upper[i]);
  352|  60.6k|    __m128i TL = _mm_loadu_si128((const __m128i*)&upper[i - 1]);
  353|  60.6k|    __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);
  354|  60.6k|    {
  355|       |      // We can unpack with any value on the upper 32 bits, provided it's the
  356|       |      // same on both operands (so that their sum of abs diff is zero). Here we
  357|       |      // use T.
  358|  60.6k|      const __m128i T_lo = _mm_unpacklo_epi32(T, T);
  359|  60.6k|      const __m128i TL_lo = _mm_unpacklo_epi32(TL, T);
  360|  60.6k|      const __m128i T_hi = _mm_unpackhi_epi32(T, T);
  361|  60.6k|      const __m128i TL_hi = _mm_unpackhi_epi32(TL, T);
  362|  60.6k|      const __m128i s_lo = _mm_sad_epu8(T_lo, TL_lo);
  363|  60.6k|      const __m128i s_hi = _mm_sad_epu8(T_hi, TL_hi);
  364|  60.6k|      pa = _mm_packs_epi32(s_lo, s_hi);  // pa = sum |T-TL|
  365|  60.6k|    }
  366|  60.6k|    DO_PRED11(0);
  ------------------
  |  |  324|  60.6k|  do {                                                                   \
  |  |  325|  60.6k|    const __m128i L_lo = _mm_unpacklo_epi32(L, T);                       \
  |  |  326|  60.6k|    const __m128i TL_lo = _mm_unpacklo_epi32(TL, T);                     \
  |  |  327|  60.6k|    const __m128i pb = _mm_sad_epu8(L_lo, TL_lo); /* pb = sum |L-TL|*/   \
  |  |  328|  60.6k|    const __m128i mask = _mm_cmpgt_epi32(pb, pa);                        \
  |  |  329|  60.6k|    const __m128i A = _mm_and_si128(mask, L);                            \
  |  |  330|  60.6k|    const __m128i B = _mm_andnot_si128(mask, T);                         \
  |  |  331|  60.6k|    const __m128i pred = _mm_or_si128(A, B); /* pred = (pa > b)? L : T*/ \
  |  |  332|  60.6k|    L = _mm_add_epi8(src, pred);                                         \
  |  |  333|  60.6k|    out[i + (OUT)] = (uint32_t)_mm_cvtsi128_si32(L);                     \
  |  |  334|  60.6k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (334:12): [Folded, False: 60.6k]
  |  |  ------------------
  ------------------
  367|  60.6k|    DO_PRED11_SHIFT;
  ------------------
  |  |  337|  60.6k|  do {                                                        \
  |  |  338|  60.6k|    /* Shift the pre-computed value for the next iteration.*/ \
  |  |  339|  60.6k|    T = _mm_srli_si128(T, 4);                                 \
  |  |  340|  60.6k|    TL = _mm_srli_si128(TL, 4);                               \
  |  |  341|  60.6k|    src = _mm_srli_si128(src, 4);                             \
  |  |  342|  60.6k|    pa = _mm_srli_si128(pa, 4);                               \
  |  |  343|  60.6k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (343:12): [Folded, False: 60.6k]
  |  |  ------------------
  ------------------
  368|  60.6k|    DO_PRED11(1);
  ------------------
  |  |  324|  60.6k|  do {                                                                   \
  |  |  325|  60.6k|    const __m128i L_lo = _mm_unpacklo_epi32(L, T);                       \
  |  |  326|  60.6k|    const __m128i TL_lo = _mm_unpacklo_epi32(TL, T);                     \
  |  |  327|  60.6k|    const __m128i pb = _mm_sad_epu8(L_lo, TL_lo); /* pb = sum |L-TL|*/   \
  |  |  328|  60.6k|    const __m128i mask = _mm_cmpgt_epi32(pb, pa);                        \
  |  |  329|  60.6k|    const __m128i A = _mm_and_si128(mask, L);                            \
  |  |  330|  60.6k|    const __m128i B = _mm_andnot_si128(mask, T);                         \
  |  |  331|  60.6k|    const __m128i pred = _mm_or_si128(A, B); /* pred = (pa > b)? L : T*/ \
  |  |  332|  60.6k|    L = _mm_add_epi8(src, pred);                                         \
  |  |  333|  60.6k|    out[i + (OUT)] = (uint32_t)_mm_cvtsi128_si32(L);                     \
  |  |  334|  60.6k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (334:12): [Folded, False: 60.6k]
  |  |  ------------------
  ------------------
  369|  60.6k|    DO_PRED11_SHIFT;
  ------------------
  |  |  337|  60.6k|  do {                                                        \
  |  |  338|  60.6k|    /* Shift the pre-computed value for the next iteration.*/ \
  |  |  339|  60.6k|    T = _mm_srli_si128(T, 4);                                 \
  |  |  340|  60.6k|    TL = _mm_srli_si128(TL, 4);                               \
  |  |  341|  60.6k|    src = _mm_srli_si128(src, 4);                             \
  |  |  342|  60.6k|    pa = _mm_srli_si128(pa, 4);                               \
  |  |  343|  60.6k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (343:12): [Folded, False: 60.6k]
  |  |  ------------------
  ------------------
  370|  60.6k|    DO_PRED11(2);
  ------------------
  |  |  324|  60.6k|  do {                                                                   \
  |  |  325|  60.6k|    const __m128i L_lo = _mm_unpacklo_epi32(L, T);                       \
  |  |  326|  60.6k|    const __m128i TL_lo = _mm_unpacklo_epi32(TL, T);                     \
  |  |  327|  60.6k|    const __m128i pb = _mm_sad_epu8(L_lo, TL_lo); /* pb = sum |L-TL|*/   \
  |  |  328|  60.6k|    const __m128i mask = _mm_cmpgt_epi32(pb, pa);                        \
  |  |  329|  60.6k|    const __m128i A = _mm_and_si128(mask, L);                            \
  |  |  330|  60.6k|    const __m128i B = _mm_andnot_si128(mask, T);                         \
  |  |  331|  60.6k|    const __m128i pred = _mm_or_si128(A, B); /* pred = (pa > b)? L : T*/ \
  |  |  332|  60.6k|    L = _mm_add_epi8(src, pred);                                         \
  |  |  333|  60.6k|    out[i + (OUT)] = (uint32_t)_mm_cvtsi128_si32(L);                     \
  |  |  334|  60.6k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (334:12): [Folded, False: 60.6k]
  |  |  ------------------
  ------------------
  371|  60.6k|    DO_PRED11_SHIFT;
  ------------------
  |  |  337|  60.6k|  do {                                                        \
  |  |  338|  60.6k|    /* Shift the pre-computed value for the next iteration.*/ \
  |  |  339|  60.6k|    T = _mm_srli_si128(T, 4);                                 \
  |  |  340|  60.6k|    TL = _mm_srli_si128(TL, 4);                               \
  |  |  341|  60.6k|    src = _mm_srli_si128(src, 4);                             \
  |  |  342|  60.6k|    pa = _mm_srli_si128(pa, 4);                               \
  |  |  343|  60.6k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (343:12): [Folded, False: 60.6k]
  |  |  ------------------
  ------------------
  372|  60.6k|    DO_PRED11(3);
  ------------------
  |  |  324|  60.6k|  do {                                                                   \
  |  |  325|  60.6k|    const __m128i L_lo = _mm_unpacklo_epi32(L, T);                       \
  |  |  326|  60.6k|    const __m128i TL_lo = _mm_unpacklo_epi32(TL, T);                     \
  |  |  327|  60.6k|    const __m128i pb = _mm_sad_epu8(L_lo, TL_lo); /* pb = sum |L-TL|*/   \
  |  |  328|  60.6k|    const __m128i mask = _mm_cmpgt_epi32(pb, pa);                        \
  |  |  329|  60.6k|    const __m128i A = _mm_and_si128(mask, L);                            \
  |  |  330|  60.6k|    const __m128i B = _mm_andnot_si128(mask, T);                         \
  |  |  331|  60.6k|    const __m128i pred = _mm_or_si128(A, B); /* pred = (pa > b)? L : T*/ \
  |  |  332|  60.6k|    L = _mm_add_epi8(src, pred);                                         \
  |  |  333|  60.6k|    out[i + (OUT)] = (uint32_t)_mm_cvtsi128_si32(L);                     \
  |  |  334|  60.6k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (334:12): [Folded, False: 60.6k]
  |  |  ------------------
  ------------------
  373|  60.6k|  }
  374|  75.3k|  if (i != num_pixels) {
  ------------------
  |  Branch (374:7): [True: 21.2k, False: 54.0k]
  ------------------
  375|  21.2k|    VP8LPredictorsAdd_C[11](in + i, upper + i, num_pixels - i, out + i);
  376|  21.2k|  }
  377|  75.3k|}
lossless_sse2.c:PredictorAdd12_SSE2:
  399|  37.1k|                                int num_pixels, uint32_t* WEBP_RESTRICT out) {
  400|  37.1k|  int i;
  401|  37.1k|  const __m128i zero = _mm_setzero_si128();
  402|  37.1k|  const __m128i L8 = _mm_cvtsi32_si128((int)out[-1]);
  403|  37.1k|  __m128i L = _mm_unpacklo_epi8(L8, zero);
  404|  68.6k|  for (i = 0; i + 4 <= num_pixels; i += 4) {
  ------------------
  |  Branch (404:15): [True: 31.5k, False: 37.1k]
  ------------------
  405|       |    // Load 4 pixels at a time.
  406|  31.5k|    __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);
  407|  31.5k|    const __m128i T = _mm_loadu_si128((const __m128i*)&upper[i]);
  408|  31.5k|    const __m128i T_lo = _mm_unpacklo_epi8(T, zero);
  409|  31.5k|    const __m128i T_hi = _mm_unpackhi_epi8(T, zero);
  410|  31.5k|    const __m128i TL = _mm_loadu_si128((const __m128i*)&upper[i - 1]);
  411|  31.5k|    const __m128i TL_lo = _mm_unpacklo_epi8(TL, zero);
  412|  31.5k|    const __m128i TL_hi = _mm_unpackhi_epi8(TL, zero);
  413|  31.5k|    __m128i diff_lo = _mm_sub_epi16(T_lo, TL_lo);
  414|  31.5k|    __m128i diff_hi = _mm_sub_epi16(T_hi, TL_hi);
  415|  31.5k|    DO_PRED12(diff_lo, 0, 0);
  ------------------
  |  |  383|  31.5k|  do {                                                 \
  |  |  384|  31.5k|    const __m128i all = _mm_add_epi16(L, (DIFF));      \
  |  |  385|  31.5k|    const __m128i alls = _mm_packus_epi16(all, all);   \
  |  |  386|  31.5k|    const __m128i res = _mm_add_epi8(src, alls);       \
  |  |  387|  31.5k|    out[i + (OUT)] = (uint32_t)_mm_cvtsi128_si32(res); \
  |  |  388|  31.5k|    L = _mm_unpacklo_epi8(res, zero);                  \
  |  |  389|  31.5k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (389:12): [Folded, False: 31.5k]
  |  |  ------------------
  ------------------
  416|  31.5k|    DO_PRED12_SHIFT(diff_lo, 0);
  ------------------
  |  |  392|  31.5k|  do {                                                        \
  |  |  393|  31.5k|    /* Shift the pre-computed value for the next iteration.*/ \
  |  |  394|  31.5k|    if ((LANE) == 0) (DIFF) = _mm_srli_si128((DIFF), 8);      \
  |  |  ------------------
  |  |  |  Branch (394:9): [True: 31.5k, Folded]
  |  |  ------------------
  |  |  395|  31.5k|    src = _mm_srli_si128(src, 4);                             \
  |  |  396|  31.5k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (396:12): [Folded, False: 31.5k]
  |  |  ------------------
  ------------------
  417|  31.5k|    DO_PRED12(diff_lo, 1, 1);
  ------------------
  |  |  383|  31.5k|  do {                                                 \
  |  |  384|  31.5k|    const __m128i all = _mm_add_epi16(L, (DIFF));      \
  |  |  385|  31.5k|    const __m128i alls = _mm_packus_epi16(all, all);   \
  |  |  386|  31.5k|    const __m128i res = _mm_add_epi8(src, alls);       \
  |  |  387|  31.5k|    out[i + (OUT)] = (uint32_t)_mm_cvtsi128_si32(res); \
  |  |  388|  31.5k|    L = _mm_unpacklo_epi8(res, zero);                  \
  |  |  389|  31.5k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (389:12): [Folded, False: 31.5k]
  |  |  ------------------
  ------------------
  418|  31.5k|    DO_PRED12_SHIFT(diff_lo, 1);
  ------------------
  |  |  392|  31.5k|  do {                                                        \
  |  |  393|  31.5k|    /* Shift the pre-computed value for the next iteration.*/ \
  |  |  394|  31.5k|    if ((LANE) == 0) (DIFF) = _mm_srli_si128((DIFF), 8);      \
  |  |  ------------------
  |  |  |  Branch (394:9): [Folded, False: 31.5k]
  |  |  ------------------
  |  |  395|  31.5k|    src = _mm_srli_si128(src, 4);                             \
  |  |  396|  31.5k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (396:12): [Folded, False: 31.5k]
  |  |  ------------------
  ------------------
  419|  31.5k|    DO_PRED12(diff_hi, 0, 2);
  ------------------
  |  |  383|  31.5k|  do {                                                 \
  |  |  384|  31.5k|    const __m128i all = _mm_add_epi16(L, (DIFF));      \
  |  |  385|  31.5k|    const __m128i alls = _mm_packus_epi16(all, all);   \
  |  |  386|  31.5k|    const __m128i res = _mm_add_epi8(src, alls);       \
  |  |  387|  31.5k|    out[i + (OUT)] = (uint32_t)_mm_cvtsi128_si32(res); \
  |  |  388|  31.5k|    L = _mm_unpacklo_epi8(res, zero);                  \
  |  |  389|  31.5k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (389:12): [Folded, False: 31.5k]
  |  |  ------------------
  ------------------
  420|  31.5k|    DO_PRED12_SHIFT(diff_hi, 0);
  ------------------
  |  |  392|  31.5k|  do {                                                        \
  |  |  393|  31.5k|    /* Shift the pre-computed value for the next iteration.*/ \
  |  |  394|  31.5k|    if ((LANE) == 0) (DIFF) = _mm_srli_si128((DIFF), 8);      \
  |  |  ------------------
  |  |  |  Branch (394:9): [True: 31.5k, Folded]
  |  |  ------------------
  |  |  395|  31.5k|    src = _mm_srli_si128(src, 4);                             \
  |  |  396|  31.5k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (396:12): [Folded, False: 31.5k]
  |  |  ------------------
  ------------------
  421|  31.5k|    DO_PRED12(diff_hi, 1, 3);
  ------------------
  |  |  383|  31.5k|  do {                                                 \
  |  |  384|  31.5k|    const __m128i all = _mm_add_epi16(L, (DIFF));      \
  |  |  385|  31.5k|    const __m128i alls = _mm_packus_epi16(all, all);   \
  |  |  386|  31.5k|    const __m128i res = _mm_add_epi8(src, alls);       \
  |  |  387|  31.5k|    out[i + (OUT)] = (uint32_t)_mm_cvtsi128_si32(res); \
  |  |  388|  31.5k|    L = _mm_unpacklo_epi8(res, zero);                  \
  |  |  389|  31.5k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (389:12): [Folded, False: 31.5k]
  |  |  ------------------
  ------------------
  422|  31.5k|  }
  423|  37.1k|  if (i != num_pixels) {
  ------------------
  |  Branch (423:7): [True: 14.0k, False: 23.1k]
  ------------------
  424|  14.0k|    VP8LPredictorsAdd_C[12](in + i, upper + i, num_pixels - i, out + i);
  425|  14.0k|  }
  426|  37.1k|}
lossless_sse2.c:AddGreenToBlueAndRed_SSE2:
  438|     78|                                      uint32_t* dst) {
  439|     78|  int i;
  440|    123|  for (i = 0; i + 4 <= num_pixels; i += 4) {
  ------------------
  |  Branch (440:15): [True: 45, False: 78]
  ------------------
  441|     45|    const __m128i in = _mm_loadu_si128((const __m128i*)&src[i]);  // argb
  442|     45|    const __m128i A = _mm_srli_epi16(in, 8);                      // 0 a 0 g
  443|     45|    const __m128i B = _mm_shufflelo_epi16(A, _MM_SHUFFLE(2, 2, 0, 0));
  444|     45|    const __m128i C = _mm_shufflehi_epi16(B, _MM_SHUFFLE(2, 2, 0, 0));  // 0g0g
  445|     45|    const __m128i out = _mm_add_epi8(in, C);
  446|     45|    _mm_storeu_si128((__m128i*)&dst[i], out);
  447|     45|  }
  448|       |  // fallthrough and finish off with plain-C
  449|     78|  if (i != num_pixels) {
  ------------------
  |  Branch (449:7): [True: 57, False: 21]
  ------------------
  450|     57|    VP8LAddGreenToBlueAndRed_C(src + i, num_pixels - i, dst + i);
  451|     57|  }
  452|     78|}
lossless_sse2.c:ConvertBGRAToRGBA_SSE2:
  528|   189k|                                   int num_pixels, uint8_t* WEBP_RESTRICT dst) {
  529|   189k|  const __m128i red_blue_mask = _mm_set1_epi32(0x00ff00ff);
  530|   189k|  while (num_pixels >= 8) {
  ------------------
  |  Branch (530:10): [True: 0, False: 189k]
  ------------------
  531|      0|    const __m128i A1 = _mm_loadu_si128((const __m128i*)(src + 0));
  532|      0|    const __m128i A2 = _mm_loadu_si128((const __m128i*)(src + 4));
  533|      0|    const __m128i B1 = _mm_and_si128(A1, red_blue_mask);     // R 0 B 0
  534|      0|    const __m128i B2 = _mm_and_si128(A2, red_blue_mask);     // R 0 B 0
  535|      0|    const __m128i C1 = _mm_andnot_si128(red_blue_mask, A1);  // 0 G 0 A
  536|      0|    const __m128i C2 = _mm_andnot_si128(red_blue_mask, A2);  // 0 G 0 A
  537|      0|    const __m128i D1 = _mm_shufflelo_epi16(B1, _MM_SHUFFLE(2, 3, 0, 1));
  538|      0|    const __m128i D2 = _mm_shufflelo_epi16(B2, _MM_SHUFFLE(2, 3, 0, 1));
  539|      0|    const __m128i E1 = _mm_shufflehi_epi16(D1, _MM_SHUFFLE(2, 3, 0, 1));
  540|      0|    const __m128i E2 = _mm_shufflehi_epi16(D2, _MM_SHUFFLE(2, 3, 0, 1));
  541|      0|    const __m128i F1 = _mm_or_si128(E1, C1);
  542|      0|    const __m128i F2 = _mm_or_si128(E2, C2);
  543|      0|    _mm_storeu_si128((__m128i*)(dst + 0), F1);
  544|      0|    _mm_storeu_si128((__m128i*)(dst + 16), F2);
  545|      0|    src += 8;
  546|      0|    dst += 32;
  547|      0|    num_pixels -= 8;
  548|      0|  }
  549|       |  // left-overs
  550|   189k|  if (num_pixels > 0) {
  ------------------
  |  Branch (550:7): [True: 189k, False: 0]
  ------------------
  551|   189k|    VP8LConvertBGRAToRGBA_C(src, num_pixels, dst);
  552|   189k|  }
  553|   189k|}

VP8LDspInitSSE41:
  121|      1|WEBP_TSAN_IGNORE_FUNCTION void VP8LDspInitSSE41(void) {
  122|      1|  VP8LTransformColorInverse = TransformColorInverse_SSE41;
  123|      1|  VP8LConvertBGRAToRGB = ConvertBGRAToRGB_SSE41;
  124|      1|  VP8LConvertBGRAToBGR = ConvertBGRAToBGR_SSE41;
  125|       |
  126|       |  // SSE exports for AVX and above.
  127|      1|  VP8LTransformColorInverse_SSE = TransformColorInverse_SSE41;
  128|      1|  VP8LConvertBGRAToRGB_SSE = ConvertBGRAToRGB_SSE41;
  129|      1|  VP8LConvertBGRAToBGR_SSE = ConvertBGRAToBGR_SSE41;
  130|      1|}
lossless_sse41.c:TransformColorInverse_SSE41:
   27|   144k|                                        int num_pixels, uint32_t* dst) {
   28|       |// sign-extended multiplying constants, pre-shifted by 5.
   29|   144k|#define CST(X) (((int16_t)(m->X << 8)) >> 5)  // sign-extend
   30|   144k|  const __m128i mults_rb = _mm_set1_epi32(
   31|   144k|      (int)((uint32_t)CST(green_to_red) << 16 | (CST(green_to_blue) & 0xffff)));
  ------------------
  |  |   29|   144k|#define CST(X) (((int16_t)(m->X << 8)) >> 5)  // sign-extend
  ------------------
                    (int)((uint32_t)CST(green_to_red) << 16 | (CST(green_to_blue) & 0xffff)));
  ------------------
  |  |   29|   144k|#define CST(X) (((int16_t)(m->X << 8)) >> 5)  // sign-extend
  ------------------
   32|   144k|  const __m128i mults_b2 = _mm_set1_epi32(CST(red_to_blue));
  ------------------
  |  |   29|   144k|#define CST(X) (((int16_t)(m->X << 8)) >> 5)  // sign-extend
  ------------------
   33|   144k|#undef CST
   34|   144k|  const __m128i mask_ag = _mm_set1_epi32((int)0xff00ff00);
   35|   144k|  const __m128i perm1 =
   36|   144k|      _mm_setr_epi8(-1, 1, -1, 1, -1, 5, -1, 5, -1, 9, -1, 9, -1, 13, -1, 13);
   37|   144k|  const __m128i perm2 = _mm_setr_epi8(-1, 2, -1, -1, -1, 6, -1, -1, -1, 10, -1,
   38|   144k|                                      -1, -1, 14, -1, -1);
   39|   144k|  int i;
   40|   238k|  for (i = 0; i + 4 <= num_pixels; i += 4) {
  ------------------
  |  Branch (40:15): [True: 93.5k, False: 144k]
  ------------------
   41|  93.5k|    const __m128i A = _mm_loadu_si128((const __m128i*)(src + i));
   42|  93.5k|    const __m128i B = _mm_shuffle_epi8(A, perm1);  // argb -> g0g0
   43|  93.5k|    const __m128i C = _mm_mulhi_epi16(B, mults_rb);
   44|  93.5k|    const __m128i D = _mm_add_epi8(A, C);
   45|  93.5k|    const __m128i E = _mm_shuffle_epi8(D, perm2);
   46|  93.5k|    const __m128i F = _mm_mulhi_epi16(E, mults_b2);
   47|  93.5k|    const __m128i G = _mm_add_epi8(D, F);
   48|  93.5k|    const __m128i out = _mm_blendv_epi8(G, A, mask_ag);
   49|  93.5k|    _mm_storeu_si128((__m128i*)&dst[i], out);
   50|  93.5k|  }
   51|       |  // Fall-back to C-version for left-overs.
   52|   144k|  if (i != num_pixels) {
  ------------------
  |  Branch (52:7): [True: 55.6k, False: 89.1k]
  ------------------
   53|  55.6k|    VP8LTransformColorInverse_C(m, src + i, num_pixels - i, dst + i);
   54|  55.6k|  }
   55|   144k|}
lossless_sse41.c:ConvertBGRAToRGB_SSE41:
   83|   139k|                                   int num_pixels, uint8_t* WEBP_RESTRICT dst) {
   84|   139k|  const __m128i perm0 =
   85|   139k|      _mm_setr_epi8(2, 1, 0, 6, 5, 4, 10, 9, 8, 14, 13, 12, -1, -1, -1, -1);
   86|   139k|  const __m128i perm1 = _mm_shuffle_epi32(perm0, 0x39);
   87|   139k|  const __m128i perm2 = _mm_shuffle_epi32(perm0, 0x4e);
   88|   139k|  const __m128i perm3 = _mm_shuffle_epi32(perm0, 0x93);
   89|       |
   90|   139k|  ARGB_TO_RGB_SSE41;
  ------------------
  |  |   60|   139k|  do {                                                                 \
  |  |   61|   152k|    while (num_pixels >= 16) {                                         \
  |  |  ------------------
  |  |  |  Branch (61:12): [True: 13.5k, False: 139k]
  |  |  ------------------
  |  |   62|  13.5k|      const __m128i in0 = _mm_loadu_si128((const __m128i*)(src + 0));  \
  |  |   63|  13.5k|      const __m128i in1 = _mm_loadu_si128((const __m128i*)(src + 4));  \
  |  |   64|  13.5k|      const __m128i in2 = _mm_loadu_si128((const __m128i*)(src + 8));  \
  |  |   65|  13.5k|      const __m128i in3 = _mm_loadu_si128((const __m128i*)(src + 12)); \
  |  |   66|  13.5k|      const __m128i a0 = _mm_shuffle_epi8(in0, perm0);                 \
  |  |   67|  13.5k|      const __m128i a1 = _mm_shuffle_epi8(in1, perm1);                 \
  |  |   68|  13.5k|      const __m128i a2 = _mm_shuffle_epi8(in2, perm2);                 \
  |  |   69|  13.5k|      const __m128i a3 = _mm_shuffle_epi8(in3, perm3);                 \
  |  |   70|  13.5k|      const __m128i b0 = _mm_blend_epi16(a0, a1, 0xc0);                \
  |  |   71|  13.5k|      const __m128i b1 = _mm_blend_epi16(a1, a2, 0xf0);                \
  |  |   72|  13.5k|      const __m128i b2 = _mm_blend_epi16(a2, a3, 0xfc);                \
  |  |   73|  13.5k|      _mm_storeu_si128((__m128i*)(dst + 0), b0);                       \
  |  |   74|  13.5k|      _mm_storeu_si128((__m128i*)(dst + 16), b1);                      \
  |  |   75|  13.5k|      _mm_storeu_si128((__m128i*)(dst + 32), b2);                      \
  |  |   76|  13.5k|      src += 16;                                                       \
  |  |   77|  13.5k|      dst += 48;                                                       \
  |  |   78|  13.5k|      num_pixels -= 16;                                                \
  |  |   79|  13.5k|    }                                                                  \
  |  |   80|   139k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (80:12): [Folded, False: 139k]
  |  |  ------------------
  ------------------
   91|       |
   92|       |  // left-overs
   93|   139k|  if (num_pixels > 0) {
  ------------------
  |  Branch (93:7): [True: 138k, False: 492]
  ------------------
   94|   138k|    VP8LConvertBGRAToRGB_C(src, num_pixels, dst);
   95|   138k|  }
   96|   139k|}
lossless_sse41.c:ConvertBGRAToBGR_SSE41:
   99|   163k|                                   int num_pixels, uint8_t* WEBP_RESTRICT dst) {
  100|   163k|  const __m128i perm0 =
  101|   163k|      _mm_setr_epi8(0, 1, 2, 4, 5, 6, 8, 9, 10, 12, 13, 14, -1, -1, -1, -1);
  102|   163k|  const __m128i perm1 = _mm_shuffle_epi32(perm0, 0x39);
  103|   163k|  const __m128i perm2 = _mm_shuffle_epi32(perm0, 0x4e);
  104|   163k|  const __m128i perm3 = _mm_shuffle_epi32(perm0, 0x93);
  105|       |
  106|   163k|  ARGB_TO_RGB_SSE41;
  ------------------
  |  |   60|   163k|  do {                                                                 \
  |  |   61|   180k|    while (num_pixels >= 16) {                                         \
  |  |  ------------------
  |  |  |  Branch (61:12): [True: 17.1k, False: 163k]
  |  |  ------------------
  |  |   62|  17.1k|      const __m128i in0 = _mm_loadu_si128((const __m128i*)(src + 0));  \
  |  |   63|  17.1k|      const __m128i in1 = _mm_loadu_si128((const __m128i*)(src + 4));  \
  |  |   64|  17.1k|      const __m128i in2 = _mm_loadu_si128((const __m128i*)(src + 8));  \
  |  |   65|  17.1k|      const __m128i in3 = _mm_loadu_si128((const __m128i*)(src + 12)); \
  |  |   66|  17.1k|      const __m128i a0 = _mm_shuffle_epi8(in0, perm0);                 \
  |  |   67|  17.1k|      const __m128i a1 = _mm_shuffle_epi8(in1, perm1);                 \
  |  |   68|  17.1k|      const __m128i a2 = _mm_shuffle_epi8(in2, perm2);                 \
  |  |   69|  17.1k|      const __m128i a3 = _mm_shuffle_epi8(in3, perm3);                 \
  |  |   70|  17.1k|      const __m128i b0 = _mm_blend_epi16(a0, a1, 0xc0);                \
  |  |   71|  17.1k|      const __m128i b1 = _mm_blend_epi16(a1, a2, 0xf0);                \
  |  |   72|  17.1k|      const __m128i b2 = _mm_blend_epi16(a2, a3, 0xfc);                \
  |  |   73|  17.1k|      _mm_storeu_si128((__m128i*)(dst + 0), b0);                       \
  |  |   74|  17.1k|      _mm_storeu_si128((__m128i*)(dst + 16), b1);                      \
  |  |   75|  17.1k|      _mm_storeu_si128((__m128i*)(dst + 32), b2);                      \
  |  |   76|  17.1k|      src += 16;                                                       \
  |  |   77|  17.1k|      dst += 48;                                                       \
  |  |   78|  17.1k|      num_pixels -= 16;                                                \
  |  |   79|  17.1k|    }                                                                  \
  |  |   80|   163k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (80:12): [Folded, False: 163k]
  |  |  ------------------
  ------------------
  107|       |
  108|       |  // left-overs
  109|   163k|  if (num_pixels > 0) {
  ------------------
  |  Branch (109:7): [True: 156k, False: 6.83k]
  ------------------
  110|   156k|    VP8LConvertBGRAToBGR_C(src, num_pixels, dst);
  111|   156k|  }
  112|   163k|}

upsampling.c:WebPInitUpsamplers_body:
  277|      1|WEBP_DSP_INIT_FUNC(WebPInitUpsamplers) {
  278|      1|#ifdef FANCY_UPSAMPLING
  279|      1|#if !WEBP_NEON_OMIT_C_CODE
  280|      1|  WebPUpsamplers[MODE_RGBA] = UpsampleRgbaLinePair_C;
  281|      1|  WebPUpsamplers[MODE_BGRA] = UpsampleBgraLinePair_C;
  282|      1|  WebPUpsamplers[MODE_rgbA] = UpsampleRgbaLinePair_C;
  283|      1|  WebPUpsamplers[MODE_bgrA] = UpsampleBgraLinePair_C;
  284|      1|  WebPUpsamplers[MODE_RGB] = UpsampleRgbLinePair_C;
  285|      1|  WebPUpsamplers[MODE_BGR] = UpsampleBgrLinePair_C;
  286|      1|  WebPUpsamplers[MODE_ARGB] = UpsampleArgbLinePair_C;
  287|      1|  WebPUpsamplers[MODE_RGBA_4444] = UpsampleRgba4444LinePair_C;
  288|      1|  WebPUpsamplers[MODE_RGB_565] = UpsampleRgb565LinePair_C;
  289|      1|  WebPUpsamplers[MODE_Argb] = UpsampleArgbLinePair_C;
  290|      1|  WebPUpsamplers[MODE_rgbA_4444] = UpsampleRgba4444LinePair_C;
  291|      1|#endif
  292|       |
  293|       |  // If defined, use CPUInfo() to overwrite some pointers with faster versions.
  294|      1|  if (VP8GetCPUInfo != NULL) {
  ------------------
  |  Branch (294:7): [True: 1, False: 0]
  ------------------
  295|      1|#if defined(WEBP_HAVE_SSE2)
  296|      1|    if (VP8GetCPUInfo(kSSE2)) {
  ------------------
  |  Branch (296:9): [True: 1, False: 0]
  ------------------
  297|      1|      WebPInitUpsamplersSSE2();
  298|      1|    }
  299|      1|#endif
  300|      1|#if defined(WEBP_HAVE_SSE41)
  301|      1|    if (VP8GetCPUInfo(kSSE4_1)) {
  ------------------
  |  Branch (301:9): [True: 1, False: 0]
  ------------------
  302|      1|      WebPInitUpsamplersSSE41();
  303|      1|    }
  304|      1|#endif
  305|       |#if defined(WEBP_USE_MIPS_DSP_R2)
  306|       |    if (VP8GetCPUInfo(kMIPSdspR2)) {
  307|       |      WebPInitUpsamplersMIPSdspR2();
  308|       |    }
  309|       |#endif
  310|       |#if defined(WEBP_USE_MSA)
  311|       |    if (VP8GetCPUInfo(kMSA)) {
  312|       |      WebPInitUpsamplersMSA();
  313|       |    }
  314|       |#endif
  315|      1|  }
  316|       |
  317|       |#if defined(WEBP_HAVE_NEON)
  318|       |  if (WEBP_NEON_OMIT_C_CODE ||
  319|       |      (VP8GetCPUInfo != NULL && VP8GetCPUInfo(kNEON))) {
  320|       |    WebPInitUpsamplersNEON();
  321|       |  }
  322|       |#endif
  323|       |
  324|      1|  assert(WebPUpsamplers[MODE_RGBA] != NULL);
  325|      1|  assert(WebPUpsamplers[MODE_BGRA] != NULL);
  326|      1|  assert(WebPUpsamplers[MODE_rgbA] != NULL);
  327|      1|  assert(WebPUpsamplers[MODE_bgrA] != NULL);
  328|      1|#if !defined(WEBP_REDUCE_CSP) || !WEBP_NEON_OMIT_C_CODE
  329|      1|  assert(WebPUpsamplers[MODE_RGB] != NULL);
  330|      1|  assert(WebPUpsamplers[MODE_BGR] != NULL);
  331|      1|  assert(WebPUpsamplers[MODE_ARGB] != NULL);
  332|      1|  assert(WebPUpsamplers[MODE_RGBA_4444] != NULL);
  333|      1|  assert(WebPUpsamplers[MODE_RGB_565] != NULL);
  334|      1|  assert(WebPUpsamplers[MODE_Argb] != NULL);
  335|      1|  assert(WebPUpsamplers[MODE_rgbA_4444] != NULL);
  336|      1|#endif
  337|       |
  338|      1|#endif  // FANCY_UPSAMPLING
  339|      1|}

WebPInitUpsamplersSSE2:
  211|      1|WEBP_TSAN_IGNORE_FUNCTION void WebPInitUpsamplersSSE2(void) {
  212|      1|  WebPUpsamplers[MODE_RGBA] = UpsampleRgbaLinePair_SSE2;
  213|      1|  WebPUpsamplers[MODE_BGRA] = UpsampleBgraLinePair_SSE2;
  214|      1|  WebPUpsamplers[MODE_rgbA] = UpsampleRgbaLinePair_SSE2;
  215|      1|  WebPUpsamplers[MODE_bgrA] = UpsampleBgraLinePair_SSE2;
  216|      1|#if !defined(WEBP_REDUCE_CSP)
  217|      1|  WebPUpsamplers[MODE_RGB] = UpsampleRgbLinePair_SSE2;
  218|      1|  WebPUpsamplers[MODE_BGR] = UpsampleBgrLinePair_SSE2;
  219|      1|  WebPUpsamplers[MODE_ARGB] = UpsampleArgbLinePair_SSE2;
  220|      1|  WebPUpsamplers[MODE_Argb] = UpsampleArgbLinePair_SSE2;
  221|      1|  WebPUpsamplers[MODE_RGB_565] = UpsampleRgb565LinePair_SSE2;
  222|      1|  WebPUpsamplers[MODE_RGBA_4444] = UpsampleRgba4444LinePair_SSE2;
  223|      1|  WebPUpsamplers[MODE_rgbA_4444] = UpsampleRgba4444LinePair_SSE2;
  224|      1|#endif  // WEBP_REDUCE_CSP
  225|      1|}
upsampling_sse2.c:Upsample32Pixels_SSE2:
  102|   214k|                                  uint8_t* WEBP_RESTRICT const out) {
  103|   214k|  UPSAMPLE_32PIXELS(r1, r2, out);
  ------------------
  |  |   70|   214k|  do {                                                                         \
  |  |   71|   214k|    const __m128i one = _mm_set1_epi8(1);                                      \
  |  |   72|   214k|    const __m128i a = _mm_loadu_si128((const __m128i*)&(r1)[0]);               \
  |  |   73|   214k|    const __m128i b = _mm_loadu_si128((const __m128i*)&(r1)[1]);               \
  |  |   74|   214k|    const __m128i c = _mm_loadu_si128((const __m128i*)&(r2)[0]);               \
  |  |   75|   214k|    const __m128i d = _mm_loadu_si128((const __m128i*)&(r2)[1]);               \
  |  |   76|   214k|                                                                               \
  |  |   77|   214k|    const __m128i s = _mm_avg_epu8(a, d);   /* s = (a + d + 1) / 2 */          \
  |  |   78|   214k|    const __m128i t = _mm_avg_epu8(b, c);   /* t = (b + c + 1) / 2 */          \
  |  |   79|   214k|    const __m128i st = _mm_xor_si128(s, t); /* st = s^t */                     \
  |  |   80|   214k|                                                                               \
  |  |   81|   214k|    const __m128i ad = _mm_xor_si128(a, d); /* ad = a^d */                     \
  |  |   82|   214k|    const __m128i bc = _mm_xor_si128(b, c); /* bc = b^c */                     \
  |  |   83|   214k|                                                                               \
  |  |   84|   214k|    const __m128i t1 = _mm_or_si128(ad, bc);   /* (a^d) | (b^c) */             \
  |  |   85|   214k|    const __m128i t2 = _mm_or_si128(t1, st);   /* (a^d) | (b^c) | (s^t) */     \
  |  |   86|   214k|    const __m128i t3 = _mm_and_si128(t2, one); /* (a^d) | (b^c) | (s^t) & 1 */ \
  |  |   87|   214k|    const __m128i t4 = _mm_avg_epu8(s, t);                                     \
  |  |   88|   214k|    const __m128i k = _mm_sub_epi8(t4, t3); /* k = (a + b + c + d) / 4 */      \
  |  |   89|   214k|    __m128i diag1, diag2;                                                      \
  |  |   90|   214k|                                                                               \
  |  |   91|   214k|    GET_M(bc, t, diag1); /* diag1 = (a + 3b + 3c + d) / 8 */                   \
  |  |  ------------------
  |  |  |  |   45|   214k|  do {                                                                         \
  |  |  |  |   46|   214k|    const __m128i tmp0 = _mm_avg_epu8(k, (in));   /* (k + in + 1) / 2 */       \
  |  |  |  |   47|   214k|    const __m128i tmp1 = _mm_and_si128((ij), st); /* (ij) & (s^t) */           \
  |  |  |  |   48|   214k|    const __m128i tmp2 = _mm_xor_si128(k, (in));  /* (k^in) */                 \
  |  |  |  |   49|   214k|    const __m128i tmp3 =                                                       \
  |  |  |  |   50|   214k|        _mm_or_si128(tmp1, tmp2); /* ((ij) & (s^t)) | (k^in) */                \
  |  |  |  |   51|   214k|    const __m128i tmp4 = _mm_and_si128(tmp3, one); /* & 1 -> lsb_correction */ \
  |  |  |  |   52|   214k|    (out) = _mm_sub_epi8(tmp0, tmp4); /* (k + in + 1) / 2 - lsb_correction */  \
  |  |  |  |   53|   214k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (53:12): [Folded, False: 214k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   92|   214k|    GET_M(ad, s, diag2); /* diag2 = (3a + b + c + 3d) / 8 */                   \
  |  |  ------------------
  |  |  |  |   45|   214k|  do {                                                                         \
  |  |  |  |   46|   214k|    const __m128i tmp0 = _mm_avg_epu8(k, (in));   /* (k + in + 1) / 2 */       \
  |  |  |  |   47|   214k|    const __m128i tmp1 = _mm_and_si128((ij), st); /* (ij) & (s^t) */           \
  |  |  |  |   48|   214k|    const __m128i tmp2 = _mm_xor_si128(k, (in));  /* (k^in) */                 \
  |  |  |  |   49|   214k|    const __m128i tmp3 =                                                       \
  |  |  |  |   50|   214k|        _mm_or_si128(tmp1, tmp2); /* ((ij) & (s^t)) | (k^in) */                \
  |  |  |  |   51|   214k|    const __m128i tmp4 = _mm_and_si128(tmp3, one); /* & 1 -> lsb_correction */ \
  |  |  |  |   52|   214k|    (out) = _mm_sub_epi8(tmp0, tmp4); /* (k + in + 1) / 2 - lsb_correction */  \
  |  |  |  |   53|   214k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (53:12): [Folded, False: 214k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   93|   214k|                                                                               \
  |  |   94|   214k|    /* pack the alternate pixels */                                            \
  |  |   95|   214k|    PACK_AND_STORE(a, b, diag1, diag2, (out) + 0);      /* store top */        \
  |  |  ------------------
  |  |  |  |   57|   214k|  do {                                                          \
  |  |  |  |   58|   214k|    const __m128i t_a =                                         \
  |  |  |  |   59|   214k|        _mm_avg_epu8(a, da); /* (9a + 3b + 3c +  d + 8) / 16 */ \
  |  |  |  |   60|   214k|    const __m128i t_b =                                         \
  |  |  |  |   61|   214k|        _mm_avg_epu8(b, db); /* (3a + 9b +  c + 3d + 8) / 16 */ \
  |  |  |  |   62|   214k|    const __m128i t_1 = _mm_unpacklo_epi8(t_a, t_b);            \
  |  |  |  |   63|   214k|    const __m128i t_2 = _mm_unpackhi_epi8(t_a, t_b);            \
  |  |  |  |   64|   214k|    _mm_store_si128(((__m128i*)(out)) + 0, t_1);                \
  |  |  |  |   65|   214k|    _mm_store_si128(((__m128i*)(out)) + 1, t_2);                \
  |  |  |  |   66|   214k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (66:12): [Folded, False: 214k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   96|   214k|    PACK_AND_STORE(c, d, diag2, diag1, (out) + 2 * 32); /* store bottom */     \
  |  |  ------------------
  |  |  |  |   57|   214k|  do {                                                          \
  |  |  |  |   58|   214k|    const __m128i t_a =                                         \
  |  |  |  |   59|   214k|        _mm_avg_epu8(a, da); /* (9a + 3b + 3c +  d + 8) / 16 */ \
  |  |  |  |   60|   214k|    const __m128i t_b =                                         \
  |  |  |  |   61|   214k|        _mm_avg_epu8(b, db); /* (3a + 9b +  c + 3d + 8) / 16 */ \
  |  |  |  |   62|   214k|    const __m128i t_1 = _mm_unpacklo_epi8(t_a, t_b);            \
  |  |  |  |   63|   214k|    const __m128i t_2 = _mm_unpackhi_epi8(t_a, t_b);            \
  |  |  |  |   64|   214k|    _mm_store_si128(((__m128i*)(out)) + 0, t_1);                \
  |  |  |  |   65|   214k|    _mm_store_si128(((__m128i*)(out)) + 1, t_2);                \
  |  |  |  |   66|   214k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (66:12): [Folded, False: 214k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   97|   214k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (97:12): [Folded, False: 214k]
  |  |  ------------------
  ------------------
  104|   214k|}

WebPInitUpsamplersSSE41:
  208|      1|WEBP_TSAN_IGNORE_FUNCTION void WebPInitUpsamplersSSE41(void) {
  209|      1|#if !defined(WEBP_REDUCE_CSP)
  210|      1|  WebPUpsamplers[MODE_RGB] = UpsampleRgbLinePair_SSE41;
  211|      1|  WebPUpsamplers[MODE_BGR] = UpsampleBgrLinePair_SSE41;
  212|      1|#endif  // WEBP_REDUCE_CSP
  213|      1|}
upsampling_sse41.c:Upsample32Pixels_SSE41:
  104|   146k|                                   uint8_t* WEBP_RESTRICT const out) {
  105|   146k|  UPSAMPLE_32PIXELS(r1, r2, out);
  ------------------
  |  |   72|   146k|  do {                                                                         \
  |  |   73|   146k|    const __m128i one = _mm_set1_epi8(1);                                      \
  |  |   74|   146k|    const __m128i a = _mm_loadu_si128((const __m128i*)&(r1)[0]);               \
  |  |   75|   146k|    const __m128i b = _mm_loadu_si128((const __m128i*)&(r1)[1]);               \
  |  |   76|   146k|    const __m128i c = _mm_loadu_si128((const __m128i*)&(r2)[0]);               \
  |  |   77|   146k|    const __m128i d = _mm_loadu_si128((const __m128i*)&(r2)[1]);               \
  |  |   78|   146k|                                                                               \
  |  |   79|   146k|    const __m128i s = _mm_avg_epu8(a, d);   /* s = (a + d + 1) / 2 */          \
  |  |   80|   146k|    const __m128i t = _mm_avg_epu8(b, c);   /* t = (b + c + 1) / 2 */          \
  |  |   81|   146k|    const __m128i st = _mm_xor_si128(s, t); /* st = s^t */                     \
  |  |   82|   146k|                                                                               \
  |  |   83|   146k|    const __m128i ad = _mm_xor_si128(a, d); /* ad = a^d */                     \
  |  |   84|   146k|    const __m128i bc = _mm_xor_si128(b, c); /* bc = b^c */                     \
  |  |   85|   146k|                                                                               \
  |  |   86|   146k|    const __m128i t1 = _mm_or_si128(ad, bc);   /* (a^d) | (b^c) */             \
  |  |   87|   146k|    const __m128i t2 = _mm_or_si128(t1, st);   /* (a^d) | (b^c) | (s^t) */     \
  |  |   88|   146k|    const __m128i t3 = _mm_and_si128(t2, one); /* (a^d) | (b^c) | (s^t) & 1 */ \
  |  |   89|   146k|    const __m128i t4 = _mm_avg_epu8(s, t);                                     \
  |  |   90|   146k|    const __m128i k = _mm_sub_epi8(t4, t3); /* k = (a + b + c + d) / 4 */      \
  |  |   91|   146k|    __m128i diag1, diag2;                                                      \
  |  |   92|   146k|                                                                               \
  |  |   93|   146k|    GET_M(bc, t, diag1); /* diag1 = (a + 3b + 3c + d) / 8 */                   \
  |  |  ------------------
  |  |  |  |   47|   146k|  do {                                                                         \
  |  |  |  |   48|   146k|    const __m128i tmp0 = _mm_avg_epu8(k, (in));   /* (k + in + 1) / 2 */       \
  |  |  |  |   49|   146k|    const __m128i tmp1 = _mm_and_si128((ij), st); /* (ij) & (s^t) */           \
  |  |  |  |   50|   146k|    const __m128i tmp2 = _mm_xor_si128(k, (in));  /* (k^in) */                 \
  |  |  |  |   51|   146k|    const __m128i tmp3 =                                                       \
  |  |  |  |   52|   146k|        _mm_or_si128(tmp1, tmp2); /* ((ij) & (s^t)) | (k^in) */                \
  |  |  |  |   53|   146k|    const __m128i tmp4 = _mm_and_si128(tmp3, one); /* & 1 -> lsb_correction */ \
  |  |  |  |   54|   146k|    (out) = _mm_sub_epi8(tmp0, tmp4); /* (k + in + 1) / 2 - lsb_correction */  \
  |  |  |  |   55|   146k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (55:12): [Folded, False: 146k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   94|   146k|    GET_M(ad, s, diag2); /* diag2 = (3a + b + c + 3d) / 8 */                   \
  |  |  ------------------
  |  |  |  |   47|   146k|  do {                                                                         \
  |  |  |  |   48|   146k|    const __m128i tmp0 = _mm_avg_epu8(k, (in));   /* (k + in + 1) / 2 */       \
  |  |  |  |   49|   146k|    const __m128i tmp1 = _mm_and_si128((ij), st); /* (ij) & (s^t) */           \
  |  |  |  |   50|   146k|    const __m128i tmp2 = _mm_xor_si128(k, (in));  /* (k^in) */                 \
  |  |  |  |   51|   146k|    const __m128i tmp3 =                                                       \
  |  |  |  |   52|   146k|        _mm_or_si128(tmp1, tmp2); /* ((ij) & (s^t)) | (k^in) */                \
  |  |  |  |   53|   146k|    const __m128i tmp4 = _mm_and_si128(tmp3, one); /* & 1 -> lsb_correction */ \
  |  |  |  |   54|   146k|    (out) = _mm_sub_epi8(tmp0, tmp4); /* (k + in + 1) / 2 - lsb_correction */  \
  |  |  |  |   55|   146k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (55:12): [Folded, False: 146k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   95|   146k|                                                                               \
  |  |   96|   146k|    /* pack the alternate pixels */                                            \
  |  |   97|   146k|    PACK_AND_STORE(a, b, diag1, diag2, (out) + 0);      /* store top */        \
  |  |  ------------------
  |  |  |  |   59|   146k|  do {                                                          \
  |  |  |  |   60|   146k|    const __m128i t_a =                                         \
  |  |  |  |   61|   146k|        _mm_avg_epu8(a, da); /* (9a + 3b + 3c +  d + 8) / 16 */ \
  |  |  |  |   62|   146k|    const __m128i t_b =                                         \
  |  |  |  |   63|   146k|        _mm_avg_epu8(b, db); /* (3a + 9b +  c + 3d + 8) / 16 */ \
  |  |  |  |   64|   146k|    const __m128i t_1 = _mm_unpacklo_epi8(t_a, t_b);            \
  |  |  |  |   65|   146k|    const __m128i t_2 = _mm_unpackhi_epi8(t_a, t_b);            \
  |  |  |  |   66|   146k|    _mm_store_si128(((__m128i*)(out)) + 0, t_1);                \
  |  |  |  |   67|   146k|    _mm_store_si128(((__m128i*)(out)) + 1, t_2);                \
  |  |  |  |   68|   146k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (68:12): [Folded, False: 146k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   98|   146k|    PACK_AND_STORE(c, d, diag2, diag1, (out) + 2 * 32); /* store bottom */     \
  |  |  ------------------
  |  |  |  |   59|   146k|  do {                                                          \
  |  |  |  |   60|   146k|    const __m128i t_a =                                         \
  |  |  |  |   61|   146k|        _mm_avg_epu8(a, da); /* (9a + 3b + 3c +  d + 8) / 16 */ \
  |  |  |  |   62|   146k|    const __m128i t_b =                                         \
  |  |  |  |   63|   146k|        _mm_avg_epu8(b, db); /* (3a + 9b +  c + 3d + 8) / 16 */ \
  |  |  |  |   64|   146k|    const __m128i t_1 = _mm_unpacklo_epi8(t_a, t_b);            \
  |  |  |  |   65|   146k|    const __m128i t_2 = _mm_unpackhi_epi8(t_a, t_b);            \
  |  |  |  |   66|   146k|    _mm_store_si128(((__m128i*)(out)) + 0, t_1);                \
  |  |  |  |   67|   146k|    _mm_store_si128(((__m128i*)(out)) + 1, t_2);                \
  |  |  |  |   68|   146k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (68:12): [Folded, False: 146k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   99|   146k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (99:12): [Folded, False: 146k]
  |  |  ------------------
  ------------------
  106|   146k|}

WebPConvertRGBA32ToUV_C:
  209|   144k|                             int width) {
  210|   144k|  int i;
  211|   539k|  for (i = 0; i < width; i += 1, rgb += 4) {
  ------------------
  |  Branch (211:15): [True: 394k, False: 144k]
  ------------------
  212|   394k|    const int r = rgb[0], g = rgb[1], b = rgb[2];
  213|   394k|    u[i] = VP8RGBToU(r, g, b, YUV_HALF << 2);
  214|   394k|    v[i] = VP8RGBToV(r, g, b, YUV_HALF << 2);
  215|   394k|  }
  216|   144k|}
WebPAccumulateRGB:
  492|   146k|                       uint16_t* dst, int width) {
  493|   146k|  int i, j;
  494|  1.39M|  for (i = 0, j = 0; i < (width >> 1); i += 1, j += 2 * step, dst += 4) {
  ------------------
  |  Branch (494:22): [True: 1.25M, False: 146k]
  ------------------
  495|  1.25M|    dst[0] = SUM4(r_ptr + j, step);
  ------------------
  |  |  297|  1.25M|  LinearToGamma(GammaToLinear((ptr)[0]) + GammaToLinear((ptr)[(step)]) + \
  |  |  298|  1.25M|                    GammaToLinear((ptr)[rgb_stride]) +                   \
  |  |  299|  1.25M|                    GammaToLinear((ptr)[rgb_stride + (step)]),           \
  |  |  300|  1.25M|                0)
  ------------------
  496|  1.25M|    dst[1] = SUM4(g_ptr + j, step);
  ------------------
  |  |  297|  1.25M|  LinearToGamma(GammaToLinear((ptr)[0]) + GammaToLinear((ptr)[(step)]) + \
  |  |  298|  1.25M|                    GammaToLinear((ptr)[rgb_stride]) +                   \
  |  |  299|  1.25M|                    GammaToLinear((ptr)[rgb_stride + (step)]),           \
  |  |  300|  1.25M|                0)
  ------------------
  497|  1.25M|    dst[2] = SUM4(b_ptr + j, step);
  ------------------
  |  |  297|  1.25M|  LinearToGamma(GammaToLinear((ptr)[0]) + GammaToLinear((ptr)[(step)]) + \
  |  |  298|  1.25M|                    GammaToLinear((ptr)[rgb_stride]) +                   \
  |  |  299|  1.25M|                    GammaToLinear((ptr)[rgb_stride + (step)]),           \
  |  |  300|  1.25M|                0)
  ------------------
  498|       |    // MemorySanitizer may raise false positives with data that passes through
  499|       |    // RGBA32PackedToPlanar_16b_SSE41() due to incorrect modeling of shuffles.
  500|       |    // See https://crbug.com/webp/573.
  501|       |#ifdef WEBP_MSAN
  502|       |    dst[3] = 0;
  503|       |#endif
  504|  1.25M|  }
  505|   146k|  if (width & 1) {
  ------------------
  |  Branch (505:7): [True: 100k, False: 45.8k]
  ------------------
  506|   100k|    dst[0] = SUM2(r_ptr + j);
  ------------------
  |  |  303|   100k|  LinearToGamma(GammaToLinear((ptr)[0]) + GammaToLinear((ptr)[rgb_stride]), 1)
  ------------------
  507|   100k|    dst[1] = SUM2(g_ptr + j);
  ------------------
  |  |  303|   100k|  LinearToGamma(GammaToLinear((ptr)[0]) + GammaToLinear((ptr)[rgb_stride]), 1)
  ------------------
  508|   100k|    dst[2] = SUM2(b_ptr + j);
  ------------------
  |  |  303|   100k|  LinearToGamma(GammaToLinear((ptr)[0]) + GammaToLinear((ptr)[rgb_stride]), 1)
  ------------------
  509|       |#ifdef WEBP_MSAN
  510|       |    dst[3] = 0;
  511|       |#endif
  512|   100k|  }
  513|   146k|}
yuv.c:WebPInitSamplers_body:
   96|      1|WEBP_DSP_INIT_FUNC(WebPInitSamplers) {
   97|      1|  WebPSamplers[MODE_RGB] = YuvToRgbRow;
   98|      1|  WebPSamplers[MODE_RGBA] = YuvToRgbaRow;
   99|      1|  WebPSamplers[MODE_BGR] = YuvToBgrRow;
  100|      1|  WebPSamplers[MODE_BGRA] = YuvToBgraRow;
  101|      1|  WebPSamplers[MODE_ARGB] = YuvToArgbRow;
  102|      1|  WebPSamplers[MODE_RGBA_4444] = YuvToRgba4444Row;
  103|      1|  WebPSamplers[MODE_RGB_565] = YuvToRgb565Row;
  104|      1|  WebPSamplers[MODE_rgbA] = YuvToRgbaRow;
  105|      1|  WebPSamplers[MODE_bgrA] = YuvToBgraRow;
  106|      1|  WebPSamplers[MODE_Argb] = YuvToArgbRow;
  107|      1|  WebPSamplers[MODE_rgbA_4444] = YuvToRgba4444Row;
  108|       |
  109|       |  // If defined, use CPUInfo() to overwrite some pointers with faster versions.
  110|      1|  if (VP8GetCPUInfo != NULL) {
  ------------------
  |  Branch (110:7): [True: 1, False: 0]
  ------------------
  111|      1|#if defined(WEBP_HAVE_SSE2)
  112|      1|    if (VP8GetCPUInfo(kSSE2)) {
  ------------------
  |  Branch (112:9): [True: 1, False: 0]
  ------------------
  113|      1|      WebPInitSamplersSSE2();
  114|      1|    }
  115|      1|#endif  // WEBP_HAVE_SSE2
  116|      1|#if defined(WEBP_HAVE_SSE41)
  117|      1|    if (VP8GetCPUInfo(kSSE4_1)) {
  ------------------
  |  Branch (117:9): [True: 1, False: 0]
  ------------------
  118|      1|      WebPInitSamplersSSE41();
  119|      1|    }
  120|      1|#endif  // WEBP_HAVE_SSE41
  121|       |#if defined(WEBP_USE_MIPS32)
  122|       |    if (VP8GetCPUInfo(kMIPS32)) {
  123|       |      WebPInitSamplersMIPS32();
  124|       |    }
  125|       |#endif  // WEBP_USE_MIPS32
  126|       |#if defined(WEBP_USE_MIPS_DSP_R2)
  127|       |    if (VP8GetCPUInfo(kMIPSdspR2)) {
  128|       |      WebPInitSamplersMIPSdspR2();
  129|       |    }
  130|       |#endif  // WEBP_USE_MIPS_DSP_R2
  131|      1|  }
  132|      1|}
yuv.c:WebPInitGammaTables_body:
  237|      1|WEBP_DSP_INIT_FUNC(WebPInitGammaTables) {
  238|      1|  if (!kGammaTablesOk) {
  ------------------
  |  Branch (238:7): [True: 1, False: 0]
  ------------------
  239|      1|    int v;
  240|      1|    const double scale = (double)(1 << GAMMA_TAB_FIX) / kGammaScale;
  ------------------
  |  |  225|      1|#define GAMMA_TAB_FIX 7  // fixed-point fractional bits precision
  ------------------
  241|      1|    const double norm = 1. / 255.;
  242|    257|    for (v = 0; v <= 255; ++v) {
  ------------------
  |  Branch (242:17): [True: 256, False: 1]
  ------------------
  243|    256|      kGammaToLinearTab[v] =
  244|    256|          (uint16_t)(pow(norm * v, kGamma) * kGammaScale + .5);
  245|    256|    }
  246|     34|    for (v = 0; v <= GAMMA_TAB_SIZE; ++v) {
  ------------------
  |  |  226|     34|#define GAMMA_TAB_SIZE (1 << (GAMMA_FIX - GAMMA_TAB_FIX))
  |  |  ------------------
  |  |  |  |  224|     34|#define GAMMA_FIX 12     // fixed-point precision for linear values
  |  |  ------------------
  |  |               #define GAMMA_TAB_SIZE (1 << (GAMMA_FIX - GAMMA_TAB_FIX))
  |  |  ------------------
  |  |  |  |  225|     34|#define GAMMA_TAB_FIX 7  // fixed-point fractional bits precision
  |  |  ------------------
  ------------------
  |  Branch (246:17): [True: 33, False: 1]
  ------------------
  247|     33|      kLinearToGammaTab[v] = (int)(255. * pow(scale * v, 1. / kGamma) + .5);
  248|     33|    }
  249|      1|    kGammaTablesOk = 1;
  250|      1|  }
  251|      1|}
yuv.c:LinearToGamma:
  269|  4.05M|static WEBP_INLINE int LinearToGamma(uint32_t base_value, int shift) {
  270|  4.05M|  const int y = Interpolate(base_value << shift);  // final uplifted value
  271|  4.05M|  return (y + kGammaTabRounder) >> GAMMA_TAB_FIX;  // descale
  ------------------
  |  |  225|  4.05M|#define GAMMA_TAB_FIX 7  // fixed-point fractional bits precision
  ------------------
  272|  4.05M|}
yuv.c:Interpolate:
  257|  4.05M|static WEBP_INLINE int Interpolate(int v) {
  258|  4.05M|  const int tab_pos = v >> (GAMMA_TAB_FIX + 2);   // integer part
  ------------------
  |  |  225|  4.05M|#define GAMMA_TAB_FIX 7  // fixed-point fractional bits precision
  ------------------
  259|  4.05M|  const int x = v & ((kGammaTabScale << 2) - 1);  // fractional part
  260|  4.05M|  const int v0 = kLinearToGammaTab[tab_pos];
  261|  4.05M|  const int v1 = kLinearToGammaTab[tab_pos + 1];
  262|  4.05M|  const int y = v1 * x + v0 * ((kGammaTabScale << 2) - x);  // interpolate
  263|       |  assert(tab_pos + 1 < GAMMA_TAB_SIZE + 1);
  264|  4.05M|  return y;
  265|  4.05M|}
yuv.c:GammaToLinear:
  253|  15.6M|static WEBP_INLINE uint32_t GammaToLinear(uint8_t v) {
  254|  15.6M|  return kGammaToLinearTab[v];
  255|  15.6M|}
yuv.c:WebPInitConvertARGBToYUV_body:
  645|      1|WEBP_DSP_INIT_FUNC(WebPInitConvertARGBToYUV) {
  646|      1|  WebPConvertARGBToY = ConvertARGBToY_C;
  647|      1|  WebPConvertARGBToUV = WebPConvertARGBToUV_C;
  648|       |
  649|      1|  WebPConvertRGBToY = ConvertRGBToY_C;
  650|      1|  WebPConvertBGRToY = ConvertBGRToY_C;
  651|       |
  652|      1|  WebPConvertRGBA32ToUV = WebPConvertRGBA32ToUV_C;
  653|       |
  654|      1|  WebPImportYUVAFromRGBA = ImportYUVAFromRGBA_C;
  655|      1|  WebPImportYUVAFromRGBALastLine = ImportYUVAFromRGBALastLine_C;
  656|       |
  657|      1|  if (VP8GetCPUInfo != NULL) {
  ------------------
  |  Branch (657:7): [True: 1, False: 0]
  ------------------
  658|      1|#if defined(WEBP_HAVE_SSE2)
  659|      1|    if (VP8GetCPUInfo(kSSE2)) {
  ------------------
  |  Branch (659:9): [True: 1, False: 0]
  ------------------
  660|      1|      WebPInitConvertARGBToYUVSSE2();
  661|      1|    }
  662|      1|#endif  // WEBP_HAVE_SSE2
  663|      1|#if defined(WEBP_HAVE_SSE41)
  664|      1|    if (VP8GetCPUInfo(kSSE4_1)) {
  ------------------
  |  Branch (664:9): [True: 1, False: 0]
  ------------------
  665|      1|      WebPInitConvertARGBToYUVSSE41();
  666|      1|    }
  667|      1|#endif  // WEBP_HAVE_SSE41
  668|      1|  }
  669|       |
  670|       |#if defined(WEBP_HAVE_NEON)
  671|       |  if (WEBP_NEON_OMIT_C_CODE ||
  672|       |      (VP8GetCPUInfo != NULL && VP8GetCPUInfo(kNEON))) {
  673|       |    WebPInitConvertARGBToYUVNEON();
  674|       |  }
  675|       |#endif  // WEBP_HAVE_NEON
  676|       |
  677|      1|  assert(WebPConvertARGBToY != NULL);
  678|      1|  assert(WebPConvertARGBToUV != NULL);
  679|      1|  assert(WebPConvertRGBToY != NULL);
  680|      1|  assert(WebPConvertBGRToY != NULL);
  681|       |  assert(WebPConvertRGBA32ToUV != NULL);
  682|      1|}
yuv.c:ImportYUVAFromRGBA_C:
  523|  18.4k|                                 uint8_t* dst_a) {
  524|  18.4k|  int y;
  525|  18.4k|  const int is_rgb = (r_ptr < b_ptr);  // otherwise it's bgr
  526|  18.4k|  const int uv_width = (width + 1) >> 1;
  527|       |
  528|  18.4k|  has_alpha &= dst_a != NULL;
  529|  18.4k|  if (has_alpha) {
  ------------------
  |  Branch (529:7): [True: 0, False: 18.4k]
  ------------------
  530|      0|#if defined(USE_GAMMA_COMPRESSION) && defined(USE_INVERSE_ALPHA_TABLE)
  531|      0|    assert(kAlphaFix + GAMMA_FIX <= 31);
  532|      0|#endif
  533|      0|  }
  534|       |
  535|  18.4k|  WebPInitGammaTables();
  536|       |
  537|       |  // Downsample Y/U/V planes, two rows at a time
  538|   164k|  for (y = 0; y < (height >> 1); ++y) {
  ------------------
  |  Branch (538:15): [True: 146k, False: 18.4k]
  ------------------
  539|   146k|    int rows_have_alpha = has_alpha;
  540|   146k|    if (is_rgb) {
  ------------------
  |  Branch (540:9): [True: 0, False: 146k]
  ------------------
  541|      0|      WebPConvertRGBToY(r_ptr, dst_y, width, step);
  542|      0|      WebPConvertRGBToY(r_ptr + rgb_stride, dst_y + y_stride, width, step);
  543|   146k|    } else {
  544|   146k|      WebPConvertBGRToY(b_ptr, dst_y, width, step);
  545|   146k|      WebPConvertBGRToY(b_ptr + rgb_stride, dst_y + y_stride, width, step);
  546|   146k|    }
  547|   146k|    dst_y += 2 * (ptrdiff_t)y_stride;
  548|   146k|    if (has_alpha) {
  ------------------
  |  Branch (548:9): [True: 0, False: 146k]
  ------------------
  549|      0|      rows_have_alpha &=
  550|      0|          !WebPExtractAlpha(a_ptr, rgb_stride, width, 2, dst_a, a_stride);
  551|      0|      dst_a += 2 * (ptrdiff_t)a_stride;
  552|   146k|    } else if (dst_a != NULL) {
  ------------------
  |  Branch (552:16): [True: 0, False: 146k]
  ------------------
  553|      0|      int i;
  554|      0|      for (i = 0; i < 2; ++i, dst_a += a_stride) {
  ------------------
  |  Branch (554:19): [True: 0, False: 0]
  ------------------
  555|      0|        memset(dst_a, 0xff, width);
  556|      0|      }
  557|      0|    }
  558|       |
  559|       |    // Collect averaged R/G/B(/A)
  560|   146k|    if (!rows_have_alpha) {
  ------------------
  |  Branch (560:9): [True: 146k, False: 0]
  ------------------
  561|   146k|      WebPAccumulateRGB(r_ptr, g_ptr, b_ptr, step, rgb_stride, tmp_rgb, width);
  562|   146k|    } else {
  563|      0|      WebPAccumulateRGBA(r_ptr, g_ptr, b_ptr, a_ptr, rgb_stride, tmp_rgb,
  564|      0|                         width);
  565|      0|    }
  566|       |    // Convert to U/V
  567|   146k|    WebPConvertRGBA32ToUV(tmp_rgb, dst_u, dst_v, uv_width);
  568|   146k|    dst_u += u_stride;
  569|   146k|    dst_v += v_stride;
  570|   146k|    r_ptr += 2 * (ptrdiff_t)rgb_stride;
  571|   146k|    b_ptr += 2 * (ptrdiff_t)rgb_stride;
  572|   146k|    g_ptr += 2 * (ptrdiff_t)rgb_stride;
  573|   146k|    if (has_alpha) a_ptr += 2 * (ptrdiff_t)rgb_stride;
  ------------------
  |  Branch (573:9): [True: 0, False: 146k]
  ------------------
  574|   146k|  }
  575|  18.4k|}
yuv.c:ImportYUVAFromRGBALastLine_C:
  582|    106|    uint8_t* dst_v, uint8_t* dst_a) {
  583|    106|  const int is_rgb = (r_ptr < b_ptr);  // otherwise it's bgr
  584|    106|  const int uv_width = (width + 1) >> 1;
  585|    106|  int row_has_alpha = has_alpha && dst_a != NULL;
  ------------------
  |  Branch (585:23): [True: 0, False: 106]
  |  Branch (585:36): [True: 0, False: 0]
  ------------------
  586|       |
  587|    106|  if (is_rgb) {
  ------------------
  |  Branch (587:7): [True: 0, False: 106]
  ------------------
  588|      0|    WebPConvertRGBToY(r_ptr, dst_y, width, step);
  589|    106|  } else {
  590|    106|    WebPConvertBGRToY(b_ptr, dst_y, width, step);
  591|    106|  }
  592|    106|  if (row_has_alpha) {
  ------------------
  |  Branch (592:7): [True: 0, False: 106]
  ------------------
  593|      0|    row_has_alpha &= !WebPExtractAlpha(a_ptr, 0, width, 1, dst_a, 0);
  594|    106|  } else if (dst_a != NULL) {
  ------------------
  |  Branch (594:14): [True: 0, False: 106]
  ------------------
  595|      0|    memset(dst_a, 0xff, width);
  596|      0|  }
  597|       |
  598|       |  // Collect averaged R/G/B(/A)
  599|    106|  if (!row_has_alpha) {
  ------------------
  |  Branch (599:7): [True: 106, False: 0]
  ------------------
  600|       |    // Collect averaged R/G/B
  601|    106|    WebPAccumulateRGB(r_ptr, g_ptr, b_ptr, step, /*rgb_stride=*/0, tmp_rgb,
  602|    106|                      width);
  603|    106|  } else {
  604|      0|    WebPAccumulateRGBA(r_ptr, g_ptr, b_ptr, a_ptr, /*rgb_stride=*/0, tmp_rgb,
  605|      0|                       width);
  606|      0|  }
  607|    106|  WebPConvertRGBA32ToUV(tmp_rgb, dst_u, dst_v, uv_width);
  608|    106|}

yuv.c:VP8RGBToU:
  225|   394k|static WEBP_INLINE int VP8RGBToU(int r, int g, int b, int rounding) {
  226|   394k|  const int u = -9719 * r - 19081 * g + 28800 * b;
  227|   394k|  return VP8ClipUV(u, rounding);
  228|   394k|}
yuv.c:VP8ClipUV:
  215|   789k|static WEBP_INLINE int VP8ClipUV(int uv, int rounding) {
  216|   789k|  uv = (uv + rounding + (128 << (YUV_FIX + 2))) >> (YUV_FIX + 2);
  217|   789k|  return ((uv & ~0xff) == 0) ? uv : (uv < 0) ? 0 : 255;
  ------------------
  |  Branch (217:10): [True: 789k, False: 0]
  |  Branch (217:37): [True: 0, False: 0]
  ------------------
  218|   789k|}
yuv.c:VP8RGBToV:
  230|   394k|static WEBP_INLINE int VP8RGBToV(int r, int g, int b, int rounding) {
  231|   394k|  const int v = +28800 * r - 24116 * g - 4684 * b;
  232|   394k|  return VP8ClipUV(v, rounding);
  233|   394k|}
upsampling_sse41.c:VP8YuvToRgb:
   92|   107k|static WEBP_INLINE void VP8YuvToRgb(int y, int u, int v, uint8_t* const rgb) {
   93|   107k|  rgb[0] = VP8YUVToR(y, v);
   94|   107k|  rgb[1] = VP8YUVToG(y, u, v);
   95|   107k|  rgb[2] = VP8YUVToB(y, u);
   96|   107k|}
upsampling_sse41.c:VP8YUVToR:
   80|   177k|static WEBP_INLINE int VP8YUVToR(int y, int v) {
   81|   177k|  return VP8Clip8(MultHi(y, 19077) + MultHi(v, 26149) - 14234);
   82|   177k|}
upsampling_sse41.c:VP8Clip8:
   76|   532k|static WEBP_INLINE int VP8Clip8(int v) {
   77|   532k|  return ((v & ~YUV_MASK2) == 0) ? (v >> YUV_FIX2) : (v < 0) ? 0 : 255;
  ------------------
  |  Branch (77:10): [True: 476k, False: 55.6k]
  |  Branch (77:54): [True: 28.4k, False: 27.1k]
  ------------------
   78|   532k|}
upsampling_sse41.c:MultHi:
   72|  1.24M|static WEBP_INLINE int MultHi(int v, int coeff) {  // _mm_mulhi_epu16 emulation
   73|  1.24M|  return (v * coeff) >> 8;
   74|  1.24M|}
upsampling_sse41.c:VP8YUVToG:
   84|   177k|static WEBP_INLINE int VP8YUVToG(int y, int u, int v) {
   85|   177k|  return VP8Clip8(MultHi(y, 19077) - MultHi(u, 6419) - MultHi(v, 13320) + 8708);
   86|   177k|}
upsampling_sse41.c:VP8YUVToB:
   88|   177k|static WEBP_INLINE int VP8YUVToB(int y, int u) {
   89|   177k|  return VP8Clip8(MultHi(y, 19077) + MultHi(u, 33050) - 17685);
   90|   177k|}
upsampling_sse41.c:VP8YuvToBgr:
   98|  69.9k|static WEBP_INLINE void VP8YuvToBgr(int y, int u, int v, uint8_t* const bgr) {
   99|  69.9k|  bgr[0] = VP8YUVToB(y, u);
  100|  69.9k|  bgr[1] = VP8YUVToG(y, u, v);
  101|  69.9k|  bgr[2] = VP8YUVToR(y, v);
  102|  69.9k|}
yuv_sse41.c:VP8RGBToY:
  220|  1.41M|static WEBP_INLINE int VP8RGBToY(int r, int g, int b, int rounding) {
  221|  1.41M|  const int luma = 16839 * r + 33059 * g + 6420 * b;
  222|  1.41M|  return (luma + rounding + (16 << YUV_FIX)) >> YUV_FIX;  // no need to clip
  223|  1.41M|}
upsampling_sse2.c:VP8YuvToRgba:
  152|  98.0k|                                     uint8_t* const rgba) {
  153|  98.0k|  VP8YuvToRgb(y, u, v, rgba);
  154|  98.0k|  rgba[3] = 0xff;
  155|  98.0k|}
upsampling_sse2.c:VP8YuvToRgb:
   92|   190k|static WEBP_INLINE void VP8YuvToRgb(int y, int u, int v, uint8_t* const rgb) {
   93|   190k|  rgb[0] = VP8YUVToR(y, v);
   94|   190k|  rgb[1] = VP8YUVToG(y, u, v);
   95|   190k|  rgb[2] = VP8YUVToB(y, u);
   96|   190k|}
upsampling_sse2.c:VP8YUVToR:
   80|   255k|static WEBP_INLINE int VP8YUVToR(int y, int v) {
   81|   255k|  return VP8Clip8(MultHi(y, 19077) + MultHi(v, 26149) - 14234);
   82|   255k|}
upsampling_sse2.c:VP8Clip8:
   76|   765k|static WEBP_INLINE int VP8Clip8(int v) {
   77|   765k|  return ((v & ~YUV_MASK2) == 0) ? (v >> YUV_FIX2) : (v < 0) ? 0 : 255;
  ------------------
  |  Branch (77:10): [True: 696k, False: 69.8k]
  |  Branch (77:54): [True: 39.4k, False: 30.3k]
  ------------------
   78|   765k|}
upsampling_sse2.c:MultHi:
   72|  1.78M|static WEBP_INLINE int MultHi(int v, int coeff) {  // _mm_mulhi_epu16 emulation
   73|  1.78M|  return (v * coeff) >> 8;
   74|  1.78M|}
upsampling_sse2.c:VP8YUVToG:
   84|   255k|static WEBP_INLINE int VP8YUVToG(int y, int u, int v) {
   85|   255k|  return VP8Clip8(MultHi(y, 19077) - MultHi(u, 6419) - MultHi(v, 13320) + 8708);
   86|   255k|}
upsampling_sse2.c:VP8YUVToB:
   88|   255k|static WEBP_INLINE int VP8YUVToB(int y, int u) {
   89|   255k|  return VP8Clip8(MultHi(y, 19077) + MultHi(u, 33050) - 17685);
   90|   255k|}
upsampling_sse2.c:VP8YuvToBgra:
  146|  65.2k|                                     uint8_t* const bgra) {
  147|  65.2k|  VP8YuvToBgr(y, u, v, bgra);
  148|  65.2k|  bgra[3] = 0xff;
  149|  65.2k|}
upsampling_sse2.c:VP8YuvToBgr:
   98|  65.2k|static WEBP_INLINE void VP8YuvToBgr(int y, int u, int v, uint8_t* const bgr) {
   99|  65.2k|  bgr[0] = VP8YUVToB(y, u);
  100|  65.2k|  bgr[1] = VP8YUVToG(y, u, v);
  101|  65.2k|  bgr[2] = VP8YUVToR(y, v);
  102|  65.2k|}
upsampling_sse2.c:VP8YuvToArgb:
  140|  91.9k|                                     uint8_t* const argb) {
  141|  91.9k|  argb[0] = 0xff;
  142|  91.9k|  VP8YuvToRgb(y, u, v, argb + 1);
  143|  91.9k|}

VP8YuvToRgba32_SSE2:
  198|  91.8k|                         uint8_t* WEBP_RESTRICT dst) {
  199|  91.8k|  const __m128i kAlpha = _mm_set1_epi16(255);
  200|  91.8k|  int n;
  201|   459k|  for (n = 0; n < 32; n += 8, dst += 32) {
  ------------------
  |  Branch (201:15): [True: 367k, False: 91.8k]
  ------------------
  202|   367k|    __m128i R, G, B;
  203|   367k|    YUV444ToRGB_SSE2(y + n, u + n, v + n, &R, &G, &B);
  204|   367k|    PackAndStore4_SSE2(&R, &G, &B, &kAlpha, dst);
  205|   367k|  }
  206|  91.8k|}
VP8YuvToBgra32_SSE2:
  211|  65.3k|                         uint8_t* WEBP_RESTRICT dst) {
  212|  65.3k|  const __m128i kAlpha = _mm_set1_epi16(255);
  213|  65.3k|  int n;
  214|   326k|  for (n = 0; n < 32; n += 8, dst += 32) {
  ------------------
  |  Branch (214:15): [True: 261k, False: 65.3k]
  ------------------
  215|   261k|    __m128i R, G, B;
  216|   261k|    YUV444ToRGB_SSE2(y + n, u + n, v + n, &R, &G, &B);
  217|   261k|    PackAndStore4_SSE2(&B, &G, &R, &kAlpha, dst);
  218|   261k|  }
  219|  65.3k|}
VP8YuvToArgb32_SSE2:
  224|  96.6k|                         uint8_t* WEBP_RESTRICT dst) {
  225|  96.6k|  const __m128i kAlpha = _mm_set1_epi16(255);
  226|  96.6k|  int n;
  227|   483k|  for (n = 0; n < 32; n += 8, dst += 32) {
  ------------------
  |  Branch (227:15): [True: 386k, False: 96.6k]
  ------------------
  228|   386k|    __m128i R, G, B;
  229|   386k|    YUV444ToRGB_SSE2(y + n, u + n, v + n, &R, &G, &B);
  230|   386k|    PackAndStore4_SSE2(&kAlpha, &R, &G, &B, dst);
  231|   386k|  }
  232|  96.6k|}
WebPInitSamplersSSE2:
  460|      1|WEBP_TSAN_IGNORE_FUNCTION void WebPInitSamplersSSE2(void) {
  461|      1|  WebPSamplers[MODE_RGB] = YuvToRgbRow_SSE2;
  462|      1|  WebPSamplers[MODE_RGBA] = YuvToRgbaRow_SSE2;
  463|      1|  WebPSamplers[MODE_BGR] = YuvToBgrRow_SSE2;
  464|      1|  WebPSamplers[MODE_BGRA] = YuvToBgraRow_SSE2;
  465|      1|  WebPSamplers[MODE_ARGB] = YuvToArgbRow_SSE2;
  466|      1|}
WebPInitConvertARGBToYUVSSE2:
  787|      1|WEBP_TSAN_IGNORE_FUNCTION void WebPInitConvertARGBToYUVSSE2(void) {
  788|      1|  WebPConvertARGBToY = ConvertARGBToY_SSE2;
  789|      1|  WebPConvertARGBToUV = ConvertARGBToUV_SSE2;
  790|       |
  791|      1|  WebPConvertRGBToY = ConvertRGBToY_SSE2;
  792|      1|  WebPConvertBGRToY = ConvertBGRToY_SSE2;
  793|       |
  794|      1|  WebPConvertRGBA32ToUV = ConvertRGBA32ToUV_SSE2;
  795|      1|}
yuv_sse2.c:YUV444ToRGB_SSE2:
   90|  1.01M|                             __m128i* const B) {
   91|  1.01M|  const __m128i Y0 = Load_HI_16_SSE2(y), U0 = Load_HI_16_SSE2(u),
   92|  1.01M|                V0 = Load_HI_16_SSE2(v);
   93|  1.01M|  ConvertYUV444ToRGB_SSE2(&Y0, &U0, &V0, R, G, B);
   94|  1.01M|}
yuv_sse2.c:Load_HI_16_SSE2:
   72|  3.04M|static WEBP_INLINE __m128i Load_HI_16_SSE2(const uint8_t* src) {
   73|  3.04M|  const __m128i zero = _mm_setzero_si128();
   74|  3.04M|  return _mm_unpacklo_epi8(zero, _mm_loadl_epi64((const __m128i*)src));
   75|  3.04M|}
yuv_sse2.c:ConvertYUV444ToRGB_SSE2:
   37|  1.01M|                                    __m128i* const G, __m128i* const B) {
   38|  1.01M|  const __m128i k19077 = _mm_set1_epi16(19077);
   39|  1.01M|  const __m128i k26149 = _mm_set1_epi16(26149);
   40|  1.01M|  const __m128i k14234 = _mm_set1_epi16(14234);
   41|       |  // 33050 doesn't fit in a signed short: only use this with unsigned arithmetic
   42|  1.01M|  const __m128i k33050 = _mm_set1_epi16((short)33050);
   43|  1.01M|  const __m128i k17685 = _mm_set1_epi16(17685);
   44|  1.01M|  const __m128i k6419 = _mm_set1_epi16(6419);
   45|  1.01M|  const __m128i k13320 = _mm_set1_epi16(13320);
   46|  1.01M|  const __m128i k8708 = _mm_set1_epi16(8708);
   47|       |
   48|  1.01M|  const __m128i Y1 = _mm_mulhi_epu16(*Y0, k19077);
   49|       |
   50|  1.01M|  const __m128i R0 = _mm_mulhi_epu16(*V0, k26149);
   51|  1.01M|  const __m128i R1 = _mm_sub_epi16(Y1, k14234);
   52|  1.01M|  const __m128i R2 = _mm_add_epi16(R1, R0);
   53|       |
   54|  1.01M|  const __m128i G0 = _mm_mulhi_epu16(*U0, k6419);
   55|  1.01M|  const __m128i G1 = _mm_mulhi_epu16(*V0, k13320);
   56|  1.01M|  const __m128i G2 = _mm_add_epi16(Y1, k8708);
   57|  1.01M|  const __m128i G3 = _mm_add_epi16(G0, G1);
   58|  1.01M|  const __m128i G4 = _mm_sub_epi16(G2, G3);
   59|       |
   60|       |  // be careful with the saturated *unsigned* arithmetic here!
   61|  1.01M|  const __m128i B0 = _mm_mulhi_epu16(*U0, k33050);
   62|  1.01M|  const __m128i B1 = _mm_adds_epu16(B0, Y1);
   63|  1.01M|  const __m128i B2 = _mm_subs_epu16(B1, k17685);
   64|       |
   65|       |  // use logical shift for B2, which can be larger than 32767
   66|  1.01M|  *R = _mm_srai_epi16(R2, 6);  // range: [-14234, 30815]
   67|  1.01M|  *G = _mm_srai_epi16(G4, 6);  // range: [-10953, 27710]
   68|  1.01M|  *B = _mm_srli_epi16(B2, 6);  // range: [0, 34238]
   69|  1.01M|}
yuv_sse2.c:PackAndStore4_SSE2:
  112|  1.01M|                                           uint8_t* WEBP_RESTRICT const dst) {
  113|  1.01M|  const __m128i rb = _mm_packus_epi16(*R, *B);
  114|  1.01M|  const __m128i ga = _mm_packus_epi16(*G, *A);
  115|  1.01M|  const __m128i rg = _mm_unpacklo_epi8(rb, ga);
  116|  1.01M|  const __m128i ba = _mm_unpackhi_epi8(rb, ga);
  117|  1.01M|  const __m128i RGBA_lo = _mm_unpacklo_epi16(rg, ba);
  118|  1.01M|  const __m128i RGBA_hi = _mm_unpackhi_epi16(rg, ba);
  119|  1.01M|  _mm_storeu_si128((__m128i*)(dst + 0), RGBA_lo);
  120|  1.01M|  _mm_storeu_si128((__m128i*)(dst + 16), RGBA_hi);
  121|  1.01M|}

VP8YuvToRgb32_SSE41:
  140|  94.6k|                         uint8_t* WEBP_RESTRICT dst) {
  141|  94.6k|  __m128i R0, R1, R2, R3, G0, G1, G2, G3, B0, B1, B2, B3;
  142|  94.6k|  __m128i rgb0, rgb1, rgb2, rgb3, rgb4, rgb5;
  143|       |
  144|  94.6k|  YUV444ToRGB_SSE41(y + 0, u + 0, v + 0, &R0, &G0, &B0);
  145|  94.6k|  YUV444ToRGB_SSE41(y + 8, u + 8, v + 8, &R1, &G1, &B1);
  146|  94.6k|  YUV444ToRGB_SSE41(y + 16, u + 16, v + 16, &R2, &G2, &B2);
  147|  94.6k|  YUV444ToRGB_SSE41(y + 24, u + 24, v + 24, &R3, &G3, &B3);
  148|       |
  149|       |  // Cast to 8b and store as RRRRGGGGBBBB.
  150|  94.6k|  rgb0 = _mm_packus_epi16(R0, R1);
  151|  94.6k|  rgb1 = _mm_packus_epi16(R2, R3);
  152|  94.6k|  rgb2 = _mm_packus_epi16(G0, G1);
  153|  94.6k|  rgb3 = _mm_packus_epi16(G2, G3);
  154|  94.6k|  rgb4 = _mm_packus_epi16(B0, B1);
  155|  94.6k|  rgb5 = _mm_packus_epi16(B2, B3);
  156|       |
  157|       |  // Pack as RGBRGBRGBRGB.
  158|  94.6k|  PlanarTo24b_SSE41(&rgb0, &rgb1, &rgb2, &rgb3, &rgb4, &rgb5, dst);
  159|  94.6k|}
VP8YuvToBgr32_SSE41:
  164|  68.6k|                         uint8_t* WEBP_RESTRICT dst) {
  165|  68.6k|  __m128i R0, R1, R2, R3, G0, G1, G2, G3, B0, B1, B2, B3;
  166|  68.6k|  __m128i bgr0, bgr1, bgr2, bgr3, bgr4, bgr5;
  167|       |
  168|  68.6k|  YUV444ToRGB_SSE41(y + 0, u + 0, v + 0, &R0, &G0, &B0);
  169|  68.6k|  YUV444ToRGB_SSE41(y + 8, u + 8, v + 8, &R1, &G1, &B1);
  170|  68.6k|  YUV444ToRGB_SSE41(y + 16, u + 16, v + 16, &R2, &G2, &B2);
  171|  68.6k|  YUV444ToRGB_SSE41(y + 24, u + 24, v + 24, &R3, &G3, &B3);
  172|       |
  173|       |  // Cast to 8b and store as BBBBGGGGRRRR.
  174|  68.6k|  bgr0 = _mm_packus_epi16(B0, B1);
  175|  68.6k|  bgr1 = _mm_packus_epi16(B2, B3);
  176|  68.6k|  bgr2 = _mm_packus_epi16(G0, G1);
  177|  68.6k|  bgr3 = _mm_packus_epi16(G2, G3);
  178|  68.6k|  bgr4 = _mm_packus_epi16(R0, R1);
  179|  68.6k|  bgr5 = _mm_packus_epi16(R2, R3);
  180|       |
  181|       |  // Pack as BGRBGRBGRBGR.
  182|  68.6k|  PlanarTo24b_SSE41(&bgr0, &bgr1, &bgr2, &bgr3, &bgr4, &bgr5, dst);
  183|  68.6k|}
WebPInitSamplersSSE41:
  269|      1|WEBP_TSAN_IGNORE_FUNCTION void WebPInitSamplersSSE41(void) {
  270|      1|  WebPSamplers[MODE_RGB] = YuvToRgbRow_SSE41;
  271|      1|  WebPSamplers[MODE_BGR] = YuvToBgrRow_SSE41;
  272|      1|}
WebPInitConvertARGBToYUVSSE41:
  632|      1|WEBP_TSAN_IGNORE_FUNCTION void WebPInitConvertARGBToYUVSSE41(void) {
  633|      1|  WebPConvertARGBToY = ConvertARGBToY_SSE41;
  634|      1|  WebPConvertARGBToUV = ConvertARGBToUV_SSE41;
  635|       |
  636|      1|  WebPConvertRGBToY = ConvertRGBToY_SSE41;
  637|      1|  WebPConvertBGRToY = ConvertBGRToY_SSE41;
  638|       |
  639|      1|  WebPConvertRGBA32ToUV = ConvertRGBA32ToUV_SSE41;
  640|      1|}
yuv_sse41.c:YUV444ToRGB_SSE41:
   91|   653k|                              __m128i* const B) {
   92|   653k|  const __m128i Y0 = Load_HI_16_SSE41(y), U0 = Load_HI_16_SSE41(u),
   93|   653k|                V0 = Load_HI_16_SSE41(v);
   94|   653k|  ConvertYUV444ToRGB_SSE41(&Y0, &U0, &V0, R, G, B);
   95|   653k|}
yuv_sse41.c:Load_HI_16_SSE41:
   73|  1.95M|static WEBP_INLINE __m128i Load_HI_16_SSE41(const uint8_t* src) {
   74|  1.95M|  const __m128i zero = _mm_setzero_si128();
   75|  1.95M|  return _mm_unpacklo_epi8(zero, _mm_loadl_epi64((const __m128i*)src));
   76|  1.95M|}
yuv_sse41.c:ConvertYUV444ToRGB_SSE41:
   38|   653k|                                     __m128i* const G, __m128i* const B) {
   39|   653k|  const __m128i k19077 = _mm_set1_epi16(19077);
   40|   653k|  const __m128i k26149 = _mm_set1_epi16(26149);
   41|   653k|  const __m128i k14234 = _mm_set1_epi16(14234);
   42|       |  // 33050 doesn't fit in a signed short: only use this with unsigned arithmetic
   43|   653k|  const __m128i k33050 = _mm_set1_epi16((short)33050);
   44|   653k|  const __m128i k17685 = _mm_set1_epi16(17685);
   45|   653k|  const __m128i k6419 = _mm_set1_epi16(6419);
   46|   653k|  const __m128i k13320 = _mm_set1_epi16(13320);
   47|   653k|  const __m128i k8708 = _mm_set1_epi16(8708);
   48|       |
   49|   653k|  const __m128i Y1 = _mm_mulhi_epu16(*Y0, k19077);
   50|       |
   51|   653k|  const __m128i R0 = _mm_mulhi_epu16(*V0, k26149);
   52|   653k|  const __m128i R1 = _mm_sub_epi16(Y1, k14234);
   53|   653k|  const __m128i R2 = _mm_add_epi16(R1, R0);
   54|       |
   55|   653k|  const __m128i G0 = _mm_mulhi_epu16(*U0, k6419);
   56|   653k|  const __m128i G1 = _mm_mulhi_epu16(*V0, k13320);
   57|   653k|  const __m128i G2 = _mm_add_epi16(Y1, k8708);
   58|   653k|  const __m128i G3 = _mm_add_epi16(G0, G1);
   59|   653k|  const __m128i G4 = _mm_sub_epi16(G2, G3);
   60|       |
   61|       |  // be careful with the saturated *unsigned* arithmetic here!
   62|   653k|  const __m128i B0 = _mm_mulhi_epu16(*U0, k33050);
   63|   653k|  const __m128i B1 = _mm_adds_epu16(B0, Y1);
   64|   653k|  const __m128i B2 = _mm_subs_epu16(B1, k17685);
   65|       |
   66|       |  // use logical shift for B2, which can be larger than 32767
   67|   653k|  *R = _mm_srai_epi16(R2, 6);  // range: [-14234, 30815]
   68|   653k|  *G = _mm_srai_epi16(G4, 6);  // range: [-10953, 27710]
   69|   653k|  *B = _mm_srli_epi16(B2, 6);  // range: [0, 34238]
   70|   653k|}
yuv_sse41.c:PlanarTo24b_SSE41:
  114|   163k|    uint8_t* WEBP_RESTRICT const rgb) {
  115|       |  // The input is 6 registers of sixteen 8b but for the sake of explanation,
  116|       |  // let's take 6 registers of four 8b values.
  117|       |  // To pack, we will keep taking one every two 8b integer and move it
  118|       |  // around as follows:
  119|       |  // Input:
  120|       |  //   r0r1r2r3 | r4r5r6r7 | g0g1g2g3 | g4g5g6g7 | b0b1b2b3 | b4b5b6b7
  121|       |  // Split the 6 registers in two sets of 3 registers: the first set as the even
  122|       |  // 8b bytes, the second the odd ones:
  123|       |  //   r0r2r4r6 | g0g2g4g6 | b0b2b4b6 | r1r3r5r7 | g1g3g5g7 | b1b3b5b7
  124|       |  // Repeat the same permutations twice more:
  125|       |  //   r0r4g0g4 | b0b4r1r5 | g1g5b1b5 | r2r6g2g6 | b2b6r3r7 | g3g7b3b7
  126|       |  //   r0g0b0r1 | g1b1r2g2 | b2r3g3b3 | r4g4b4r5 | g5b5r6g6 | b6r7g7b7
  127|   163k|  VP8PlanarTo24b_SSE41(in0, in1, in2, in3, in4, in5);
  128|       |
  129|   163k|  _mm_storeu_si128((__m128i*)(rgb + 0), *in0);
  130|   163k|  _mm_storeu_si128((__m128i*)(rgb + 16), *in1);
  131|   163k|  _mm_storeu_si128((__m128i*)(rgb + 32), *in2);
  132|   163k|  _mm_storeu_si128((__m128i*)(rgb + 48), *in3);
  133|   163k|  _mm_storeu_si128((__m128i*)(rgb + 64), *in4);
  134|   163k|  _mm_storeu_si128((__m128i*)(rgb + 80), *in5);
  135|   163k|}
yuv_sse41.c:ConvertRGBToYImpl_SSE41:
  405|   440k|                                                __m128i* const Y) {
  406|   440k|  const __m128i kRG_y = MK_CST_16(16839, 33059 - 16384);
  ------------------
  |  |  401|   440k|#define MK_CST_16(A, B) _mm_set_epi16((B), (A), (B), (A), (B), (A), (B), (A))
  ------------------
  407|   440k|  const __m128i kGB_y = MK_CST_16(16384, 6420);
  ------------------
  |  |  401|   440k|#define MK_CST_16(A, B) _mm_set_epi16((B), (A), (B), (A), (B), (A), (B), (A))
  ------------------
  408|   440k|  const __m128i kHALF_Y = _mm_set1_epi32((16 << YUV_FIX) + YUV_HALF);
  409|       |
  410|   440k|  const __m128i RG_lo = _mm_unpacklo_epi16(*R, *G);
  411|   440k|  const __m128i RG_hi = _mm_unpackhi_epi16(*R, *G);
  412|   440k|  const __m128i GB_lo = _mm_unpacklo_epi16(*G, *B);
  413|   440k|  const __m128i GB_hi = _mm_unpackhi_epi16(*G, *B);
  414|   440k|  TRANSFORM(RG_lo, RG_hi, GB_lo, GB_hi, kRG_y, kGB_y, kHALF_Y, YUV_FIX, *Y);
  ------------------
  |  |  387|   440k|  do {                                                                   \
  |  |  388|   440k|    const __m128i V0_lo = _mm_madd_epi16(RG_LO, MULT_RG);                \
  |  |  389|   440k|    const __m128i V0_hi = _mm_madd_epi16(RG_HI, MULT_RG);                \
  |  |  390|   440k|    const __m128i V1_lo = _mm_madd_epi16(GB_LO, MULT_GB);                \
  |  |  391|   440k|    const __m128i V1_hi = _mm_madd_epi16(GB_HI, MULT_GB);                \
  |  |  392|   440k|    const __m128i V2_lo = _mm_add_epi32(V0_lo, V1_lo);                   \
  |  |  393|   440k|    const __m128i V2_hi = _mm_add_epi32(V0_hi, V1_hi);                   \
  |  |  394|   440k|    const __m128i V3_lo = _mm_add_epi32(V2_lo, ROUNDER);                 \
  |  |  395|   440k|    const __m128i V3_hi = _mm_add_epi32(V2_hi, ROUNDER);                 \
  |  |  396|   440k|    const __m128i V5_lo = _mm_srai_epi32(V3_lo, DESCALE_FIX);            \
  |  |  397|   440k|    const __m128i V5_hi = _mm_srai_epi32(V3_hi, DESCALE_FIX);            \
  |  |  398|   440k|    (OUT) = _mm_packs_epi32(V5_lo, V5_hi);                               \
  |  |  399|   440k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (399:12): [Folded, False: 440k]
  |  |  ------------------
  ------------------
  415|   440k|}
yuv_sse41.c:ConvertRGBToUV_SSE41:
  421|   119k|                                             __m128i* const V) {
  422|   119k|  const __m128i kRG_u = MK_CST_16(-9719, -19081);
  ------------------
  |  |  401|   119k|#define MK_CST_16(A, B) _mm_set_epi16((B), (A), (B), (A), (B), (A), (B), (A))
  ------------------
  423|   119k|  const __m128i kGB_u = MK_CST_16(0, 28800);
  ------------------
  |  |  401|   119k|#define MK_CST_16(A, B) _mm_set_epi16((B), (A), (B), (A), (B), (A), (B), (A))
  ------------------
  424|   119k|  const __m128i kRG_v = MK_CST_16(28800, 0);
  ------------------
  |  |  401|   119k|#define MK_CST_16(A, B) _mm_set_epi16((B), (A), (B), (A), (B), (A), (B), (A))
  ------------------
  425|   119k|  const __m128i kGB_v = MK_CST_16(-24116, -4684);
  ------------------
  |  |  401|   119k|#define MK_CST_16(A, B) _mm_set_epi16((B), (A), (B), (A), (B), (A), (B), (A))
  ------------------
  426|   119k|  const __m128i kHALF_UV = _mm_set1_epi32(((128 << YUV_FIX) + YUV_HALF) << 2);
  427|       |
  428|   119k|  const __m128i RG_lo = _mm_unpacklo_epi16(*R, *G);
  429|   119k|  const __m128i RG_hi = _mm_unpackhi_epi16(*R, *G);
  430|   119k|  const __m128i GB_lo = _mm_unpacklo_epi16(*G, *B);
  431|   119k|  const __m128i GB_hi = _mm_unpackhi_epi16(*G, *B);
  432|   119k|  TRANSFORM(RG_lo, RG_hi, GB_lo, GB_hi, kRG_u, kGB_u, kHALF_UV, YUV_FIX + 2,
  ------------------
  |  |  387|   119k|  do {                                                                   \
  |  |  388|   119k|    const __m128i V0_lo = _mm_madd_epi16(RG_LO, MULT_RG);                \
  |  |  389|   119k|    const __m128i V0_hi = _mm_madd_epi16(RG_HI, MULT_RG);                \
  |  |  390|   119k|    const __m128i V1_lo = _mm_madd_epi16(GB_LO, MULT_GB);                \
  |  |  391|   119k|    const __m128i V1_hi = _mm_madd_epi16(GB_HI, MULT_GB);                \
  |  |  392|   119k|    const __m128i V2_lo = _mm_add_epi32(V0_lo, V1_lo);                   \
  |  |  393|   119k|    const __m128i V2_hi = _mm_add_epi32(V0_hi, V1_hi);                   \
  |  |  394|   119k|    const __m128i V3_lo = _mm_add_epi32(V2_lo, ROUNDER);                 \
  |  |  395|   119k|    const __m128i V3_hi = _mm_add_epi32(V2_hi, ROUNDER);                 \
  |  |  396|   119k|    const __m128i V5_lo = _mm_srai_epi32(V3_lo, DESCALE_FIX);            \
  |  |  397|   119k|    const __m128i V5_hi = _mm_srai_epi32(V3_hi, DESCALE_FIX);            \
  |  |  398|   119k|    (OUT) = _mm_packs_epi32(V5_lo, V5_hi);                               \
  |  |  399|   119k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (399:12): [Folded, False: 119k]
  |  |  ------------------
  ------------------
  433|   119k|            *U);
  434|   119k|  TRANSFORM(RG_lo, RG_hi, GB_lo, GB_hi, kRG_v, kGB_v, kHALF_UV, YUV_FIX + 2,
  ------------------
  |  |  387|   119k|  do {                                                                   \
  |  |  388|   119k|    const __m128i V0_lo = _mm_madd_epi16(RG_LO, MULT_RG);                \
  |  |  389|   119k|    const __m128i V0_hi = _mm_madd_epi16(RG_HI, MULT_RG);                \
  |  |  390|   119k|    const __m128i V1_lo = _mm_madd_epi16(GB_LO, MULT_GB);                \
  |  |  391|   119k|    const __m128i V1_hi = _mm_madd_epi16(GB_HI, MULT_GB);                \
  |  |  392|   119k|    const __m128i V2_lo = _mm_add_epi32(V0_lo, V1_lo);                   \
  |  |  393|   119k|    const __m128i V2_hi = _mm_add_epi32(V0_hi, V1_hi);                   \
  |  |  394|   119k|    const __m128i V3_lo = _mm_add_epi32(V2_lo, ROUNDER);                 \
  |  |  395|   119k|    const __m128i V3_hi = _mm_add_epi32(V2_hi, ROUNDER);                 \
  |  |  396|   119k|    const __m128i V5_lo = _mm_srai_epi32(V3_lo, DESCALE_FIX);            \
  |  |  397|   119k|    const __m128i V5_hi = _mm_srai_epi32(V3_hi, DESCALE_FIX);            \
  |  |  398|   119k|    (OUT) = _mm_packs_epi32(V5_lo, V5_hi);                               \
  |  |  399|   119k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (399:12): [Folded, False: 119k]
  |  |  ------------------
  ------------------
  435|   119k|            *V);
  436|   119k|}
yuv_sse41.c:ConvertRGBToYHelper_SSE41:
  443|   110k|    uint8_t* WEBP_RESTRICT y) {
  444|   110k|  int j;
  445|       |
  446|   330k|  for (j = 0; j < 2; ++j, *i += 16) {
  ------------------
  |  Branch (446:15): [True: 220k, False: 110k]
  ------------------
  447|   220k|    const __m128i zero = _mm_setzero_si128();
  448|   220k|    __m128i r, g, b, Y0, Y1;
  449|       |
  450|       |    // Convert to 16-bit Y.
  451|   220k|    r = _mm_unpacklo_epi8(rgb_plane[(swap_rb ? 4 : 0) + j], zero);
  ------------------
  |  Branch (451:38): [True: 220k, False: 0]
  ------------------
  452|   220k|    g = _mm_unpacklo_epi8(rgb_plane[2 + j], zero);
  453|   220k|    b = _mm_unpacklo_epi8(rgb_plane[(swap_rb ? 0 : 4) + j], zero);
  ------------------
  |  Branch (453:38): [True: 220k, False: 0]
  ------------------
  454|   220k|    ConvertRGBToYImpl_SSE41(&r, &g, &b, &Y0);
  455|       |
  456|       |    // Convert to 16-bit Y.
  457|   220k|    r = _mm_unpackhi_epi8(rgb_plane[(swap_rb ? 4 : 0) + j], zero);
  ------------------
  |  Branch (457:38): [True: 220k, False: 0]
  ------------------
  458|   220k|    g = _mm_unpackhi_epi8(rgb_plane[2 + j], zero);
  459|   220k|    b = _mm_unpackhi_epi8(rgb_plane[(swap_rb ? 0 : 4) + j], zero);
  ------------------
  |  Branch (459:38): [True: 220k, False: 0]
  ------------------
  460|   220k|    ConvertRGBToYImpl_SSE41(&r, &g, &b, &Y1);
  461|       |
  462|       |    // Cast to 8-bit and store.
  463|   220k|    STORE_16(_mm_packus_epi16(Y0, Y1), y + *i);
  ------------------
  |  |  280|   220k|#define STORE_16(V, dst) _mm_storeu_si128((__m128i*)(dst), (V))
  ------------------
  464|   220k|  }
  465|   110k|}
yuv_sse41.c:RGBAPackedToRGBPlanar_SSE41:
  345|   110k|    const uint8_t* WEBP_RESTRICT const rgba, __m128i* const rgb /*in[6]*/) {
  346|   110k|  __m128i a0 = _mm_loadu_si128((const __m128i*)(rgba + 0));
  347|   110k|  __m128i a1 = _mm_loadu_si128((const __m128i*)(rgba + 16));
  348|   110k|  __m128i a2 = _mm_loadu_si128((const __m128i*)(rgba + 32));
  349|   110k|  __m128i a3 = _mm_loadu_si128((const __m128i*)(rgba + 48));
  350|   110k|  __m128i a4 = _mm_loadu_si128((const __m128i*)(rgba + 64));
  351|   110k|  __m128i a5 = _mm_loadu_si128((const __m128i*)(rgba + 80));
  352|   110k|  __m128i a6 = _mm_loadu_si128((const __m128i*)(rgba + 96));
  353|   110k|  __m128i a7 = _mm_loadu_si128((const __m128i*)(rgba + 112));
  354|   110k|  VP8L32bToPlanar_SSE41(&a0, &a1, &a2, &a3);
  355|   110k|  rgb[0] = a3;
  356|   110k|  rgb[2] = a2;
  357|   110k|  rgb[4] = a1;
  358|   110k|  VP8L32bToPlanar_SSE41(&a4, &a5, &a6, &a7);
  359|   110k|  rgb[1] = a7;
  360|   110k|  rgb[3] = a6;
  361|   110k|  rgb[5] = a5;
  362|   110k|}
yuv_sse41.c:ConvertBGRToY_SSE41:
  489|   292k|                                uint8_t* WEBP_RESTRICT y, int width, int step) {
  490|   292k|  const int max_width = width & ~31;
  491|   292k|  int i;
  492|   292k|  __m128i bgr_plane[6];
  493|   292k|  if (step == 3) {
  ------------------
  |  Branch (493:7): [True: 0, False: 292k]
  ------------------
  494|      0|    for (i = 0; i < max_width; bgr += 3 * 16 * 2) {
  ------------------
  |  Branch (494:17): [True: 0, False: 0]
  ------------------
  495|      0|      RGBPackedToPlanar_SSE41(bgr, bgr_plane);
  496|      0|      ConvertRGBToYHelper_SSE41(bgr_plane, /*swap_rb=*/1, &i, y);
  497|      0|    }
  498|   292k|  } else {
  499|   402k|    for (i = 0; i < max_width; bgr += 4 * 16 * 2) {
  ------------------
  |  Branch (499:17): [True: 110k, False: 292k]
  ------------------
  500|   110k|      RGBAPackedToRGBPlanar_SSE41(bgr, bgr_plane);
  501|   110k|      ConvertRGBToYHelper_SSE41(bgr_plane, /*swap_rb=*/1, &i, y);
  502|   110k|    }
  503|   292k|  }
  504|  1.71M|  for (; i < width; ++i, bgr += step) {  // left-over
  ------------------
  |  Branch (504:10): [True: 1.41M, False: 292k]
  ------------------
  505|  1.41M|    y[i] = VP8RGBToY(bgr[2], bgr[1], bgr[0], YUV_HALF);
  506|  1.41M|  }
  507|   292k|}
yuv_sse41.c:ConvertRGBA32ToUV_SSE41:
  608|   146k|                                    uint8_t* WEBP_RESTRICT v, int width) {
  609|   146k|  const int max_width = width & ~15;
  610|   146k|  const uint16_t* const last_rgb = rgb + 4 * max_width;
  611|   206k|  while (rgb < last_rgb) {
  ------------------
  |  Branch (611:10): [True: 59.8k, False: 146k]
  ------------------
  612|  59.8k|    __m128i r, g, b, U0, V0, U1, V1;
  613|  59.8k|    RGBA32PackedToPlanar_16b_SSE41(rgb + 0, &r, &g, &b);
  614|  59.8k|    ConvertRGBToUV_SSE41(&r, &g, &b, &U0, &V0);
  615|  59.8k|    RGBA32PackedToPlanar_16b_SSE41(rgb + 32, &r, &g, &b);
  616|  59.8k|    ConvertRGBToUV_SSE41(&r, &g, &b, &U1, &V1);
  617|  59.8k|    STORE_16(_mm_packus_epi16(U0, U1), u);
  ------------------
  |  |  280|  59.8k|#define STORE_16(V, dst) _mm_storeu_si128((__m128i*)(dst), (V))
  ------------------
  618|  59.8k|    STORE_16(_mm_packus_epi16(V0, V1), v);
  ------------------
  |  |  280|  59.8k|#define STORE_16(V, dst) _mm_storeu_si128((__m128i*)(dst), (V))
  ------------------
  619|  59.8k|    u += 16;
  620|  59.8k|    v += 16;
  621|  59.8k|    rgb += 2 * 32;
  622|  59.8k|  }
  623|   146k|  if (max_width < width) {  // left-over
  ------------------
  |  Branch (623:7): [True: 144k, False: 1.39k]
  ------------------
  624|   144k|    WebPConvertRGBA32ToUV_C(rgb, u, v, width - max_width);
  625|   144k|  }
  626|   146k|}
yuv_sse41.c:RGBA32PackedToPlanar_16b_SSE41:
  577|   119k|    __m128i* const g, __m128i* const b) {
  578|   119k|  const __m128i in0 = LOAD_16(rgbx + 0);   // r0 | g0 | b0 |x| r1 | g1 | b1 |x
  ------------------
  |  |  278|   119k|#define LOAD_16(src) _mm_loadu_si128((const __m128i*)(src))
  ------------------
  579|   119k|  const __m128i in1 = LOAD_16(rgbx + 8);   // r2 | g2 | b2 |x| r3 | g3 | b3 |x
  ------------------
  |  |  278|   119k|#define LOAD_16(src) _mm_loadu_si128((const __m128i*)(src))
  ------------------
  580|   119k|  const __m128i in2 = LOAD_16(rgbx + 16);  // r4 | ...
  ------------------
  |  |  278|   119k|#define LOAD_16(src) _mm_loadu_si128((const __m128i*)(src))
  ------------------
  581|   119k|  const __m128i in3 = LOAD_16(rgbx + 24);  // r6 | ...
  ------------------
  |  |  278|   119k|#define LOAD_16(src) _mm_loadu_si128((const __m128i*)(src))
  ------------------
  582|       |  // aarrggbb as 16-bit.
  583|   119k|  const __m128i shuff0 =
  584|   119k|      _mm_set_epi8(-1, -1, -1, -1, 13, 12, 5, 4, 11, 10, 3, 2, 9, 8, 1, 0);
  585|   119k|  const __m128i shuff1 =
  586|   119k|      _mm_set_epi8(13, 12, 5, 4, -1, -1, -1, -1, 11, 10, 3, 2, 9, 8, 1, 0);
  587|   119k|  const __m128i A0 = _mm_shuffle_epi8(in0, shuff0);
  588|   119k|  const __m128i A1 = _mm_shuffle_epi8(in1, shuff1);
  589|   119k|  const __m128i A2 = _mm_shuffle_epi8(in2, shuff0);
  590|   119k|  const __m128i A3 = _mm_shuffle_epi8(in3, shuff1);
  591|       |  // R0R1G0G1
  592|       |  // B0B1****
  593|       |  // R2R3G2G3
  594|       |  // B2B3****
  595|       |  // (OR is used to free port 5 for the unpack)
  596|   119k|  const __m128i B0 = _mm_unpacklo_epi32(A0, A1);
  597|   119k|  const __m128i B1 = _mm_or_si128(A0, A1);
  598|   119k|  const __m128i B2 = _mm_unpacklo_epi32(A2, A3);
  599|   119k|  const __m128i B3 = _mm_or_si128(A2, A3);
  600|       |  // Gather the channels.
  601|   119k|  *r = _mm_unpacklo_epi64(B0, B2);
  602|   119k|  *g = _mm_unpackhi_epi64(B0, B2);
  603|   119k|  *b = _mm_unpackhi_epi64(B1, B3);
  604|   119k|}

vp8_dec.c:VP8LoadNewBytes:
   64|   475k|    VP8BitReader* WEBP_RESTRICT const br) {
   65|   475k|  assert(br != NULL && br->buf != NULL);
   66|       |  // Read 'BITS' bits at a time if possible.
   67|   475k|  if (br->buf < br->buf_max) {
  ------------------
  |  Branch (67:7): [True: 32.1k, False: 443k]
  ------------------
   68|       |    // convert memory type to register type (with some zero'ing!)
   69|  32.1k|    bit_t bits;
   70|       |#if defined(WEBP_USE_MIPS32)
   71|       |    // This is needed because of un-aligned read.
   72|       |    lbit_t in_bits;
   73|       |    lbit_t* p_buf = (lbit_t*)br->buf;
   74|       |    __asm__ volatile(
   75|       |        ".set   push                             \n\t"
   76|       |        ".set   at                               \n\t"
   77|       |        ".set   macro                            \n\t"
   78|       |        "ulw    %[in_bits], 0(%[p_buf])          \n\t"
   79|       |        ".set   pop                              \n\t"
   80|       |        : [in_bits] "=r"(in_bits)
   81|       |        : [p_buf] "r"(p_buf)
   82|       |        : "memory", "at");
   83|       |#else
   84|  32.1k|    lbit_t in_bits;
   85|  32.1k|    WEBP_UNSAFE_MEMCPY(&in_bits, br->buf, sizeof(in_bits));
  ------------------
  |  |  174|  32.1k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
   86|  32.1k|#endif
   87|  32.1k|    br->buf += BITS >> 3;
  ------------------
  |  |   70|  32.1k|#define BITS 56
  ------------------
   88|  32.1k|    WEBP_SELF_ASSIGN(br->buf_end);
  ------------------
  |  |  186|  32.1k|#define WEBP_SELF_ASSIGN(x) x = x
  ------------------
   89|  32.1k|#if !defined(WORDS_BIGENDIAN)
   90|  32.1k|#if (BITS > 32)
   91|  32.1k|    bits = BSwap64(in_bits);
   92|  32.1k|    bits >>= 64 - BITS;
  ------------------
  |  |   70|  32.1k|#define BITS 56
  ------------------
   93|       |#elif (BITS >= 24)
   94|       |    bits = BSwap32(in_bits);
   95|       |    bits >>= (32 - BITS);
   96|       |#elif (BITS == 16)
   97|       |    bits = BSwap16(in_bits);
   98|       |#else   // BITS == 8
   99|       |    bits = (bit_t)in_bits;
  100|       |#endif  // BITS > 32
  101|       |#else   // WORDS_BIGENDIAN
  102|       |    bits = (bit_t)in_bits;
  103|       |    if (BITS != 8 * sizeof(bit_t)) bits >>= (8 * sizeof(bit_t) - BITS);
  104|       |#endif
  105|  32.1k|    br->value = bits | (br->value << BITS);
  ------------------
  |  |   70|  32.1k|#define BITS 56
  ------------------
  106|  32.1k|    br->bits += BITS;
  ------------------
  |  |   70|  32.1k|#define BITS 56
  ------------------
  107|   443k|  } else {
  108|   443k|    VP8LoadFinalBytes(br);  // no need to be inlined
  109|   443k|  }
  110|   475k|}
vp8_dec.c:VP8GetBit:
  114|  2.08M|                                 const char label[]) {
  115|       |  // Don't move this declaration! It makes a big speed difference to store
  116|       |  // 'range' *before* calling VP8LoadNewBytes(), even if this function doesn't
  117|       |  // alter br->range value.
  118|  2.08M|  range_t range = br->range;
  119|  2.08M|  if (br->bits < 0) {
  ------------------
  |  Branch (119:7): [True: 450k, False: 1.63M]
  ------------------
  120|   450k|    VP8LoadNewBytes(br);
  121|   450k|  }
  122|  2.08M|  {
  123|  2.08M|    const int pos = br->bits;
  124|  2.08M|    const range_t split = (range * prob) >> 8;
  125|  2.08M|    const range_t value = (range_t)(br->value >> pos);
  126|  2.08M|    const int bit = (value > split);
  127|  2.08M|    if (bit) {
  ------------------
  |  Branch (127:9): [True: 1.22M, False: 858k]
  ------------------
  128|  1.22M|      range -= split;
  129|  1.22M|      br->value -= (bit_t)(split + 1) << pos;
  130|  1.22M|    } else {
  131|   858k|      range = split + 1;
  132|   858k|    }
  133|  2.08M|    {
  134|  2.08M|      const int shift = 7 ^ BitsLog2Floor(range);
  135|  2.08M|      range <<= shift;
  136|  2.08M|      br->bits -= shift;
  137|  2.08M|    }
  138|  2.08M|    br->range = range - 1;
  139|  2.08M|    BT_TRACK(br);
  140|  2.08M|    return bit;
  141|  2.08M|  }
  142|  2.08M|}
vp8_dec.c:VP8GetSigned:
  146|   198k|    VP8BitReader* WEBP_RESTRICT const br, int v, const char label[]) {
  147|   198k|  if (br->bits < 0) {
  ------------------
  |  Branch (147:7): [True: 25.1k, False: 173k]
  ------------------
  148|  25.1k|    VP8LoadNewBytes(br);
  149|  25.1k|  }
  150|   198k|  {
  151|   198k|    const int pos = br->bits;
  152|   198k|    const range_t split = br->range >> 1;
  153|   198k|    const range_t value = (range_t)(br->value >> pos);
  154|   198k|    const int32_t mask = (int32_t)(split - value) >> 31;  // -1 or 0
  155|   198k|    br->bits -= 1;
  156|   198k|    br->range += (range_t)mask;
  157|   198k|    br->range |= 1;
  158|   198k|    br->value -= (bit_t)((split + 1) & (uint32_t)mask) << pos;
  159|   198k|    BT_TRACK(br);
  160|   198k|    return (v ^ mask) - mask;
  161|   198k|  }
  162|   198k|}
bit_reader_utils.c:VP8LoadNewBytes:
   64|   288k|    VP8BitReader* WEBP_RESTRICT const br) {
   65|   288k|  assert(br != NULL && br->buf != NULL);
   66|       |  // Read 'BITS' bits at a time if possible.
   67|   288k|  if (br->buf < br->buf_max) {
  ------------------
  |  Branch (67:7): [True: 5.68k, False: 283k]
  ------------------
   68|       |    // convert memory type to register type (with some zero'ing!)
   69|  5.68k|    bit_t bits;
   70|       |#if defined(WEBP_USE_MIPS32)
   71|       |    // This is needed because of un-aligned read.
   72|       |    lbit_t in_bits;
   73|       |    lbit_t* p_buf = (lbit_t*)br->buf;
   74|       |    __asm__ volatile(
   75|       |        ".set   push                             \n\t"
   76|       |        ".set   at                               \n\t"
   77|       |        ".set   macro                            \n\t"
   78|       |        "ulw    %[in_bits], 0(%[p_buf])          \n\t"
   79|       |        ".set   pop                              \n\t"
   80|       |        : [in_bits] "=r"(in_bits)
   81|       |        : [p_buf] "r"(p_buf)
   82|       |        : "memory", "at");
   83|       |#else
   84|  5.68k|    lbit_t in_bits;
   85|  5.68k|    WEBP_UNSAFE_MEMCPY(&in_bits, br->buf, sizeof(in_bits));
  ------------------
  |  |  174|  5.68k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
   86|  5.68k|#endif
   87|  5.68k|    br->buf += BITS >> 3;
  ------------------
  |  |   70|  5.68k|#define BITS 56
  ------------------
   88|  5.68k|    WEBP_SELF_ASSIGN(br->buf_end);
  ------------------
  |  |  186|  5.68k|#define WEBP_SELF_ASSIGN(x) x = x
  ------------------
   89|  5.68k|#if !defined(WORDS_BIGENDIAN)
   90|  5.68k|#if (BITS > 32)
   91|  5.68k|    bits = BSwap64(in_bits);
   92|  5.68k|    bits >>= 64 - BITS;
  ------------------
  |  |   70|  5.68k|#define BITS 56
  ------------------
   93|       |#elif (BITS >= 24)
   94|       |    bits = BSwap32(in_bits);
   95|       |    bits >>= (32 - BITS);
   96|       |#elif (BITS == 16)
   97|       |    bits = BSwap16(in_bits);
   98|       |#else   // BITS == 8
   99|       |    bits = (bit_t)in_bits;
  100|       |#endif  // BITS > 32
  101|       |#else   // WORDS_BIGENDIAN
  102|       |    bits = (bit_t)in_bits;
  103|       |    if (BITS != 8 * sizeof(bit_t)) bits >>= (8 * sizeof(bit_t) - BITS);
  104|       |#endif
  105|  5.68k|    br->value = bits | (br->value << BITS);
  ------------------
  |  |   70|  5.68k|#define BITS 56
  ------------------
  106|  5.68k|    br->bits += BITS;
  ------------------
  |  |   70|  5.68k|#define BITS 56
  ------------------
  107|   283k|  } else {
  108|   283k|    VP8LoadFinalBytes(br);  // no need to be inlined
  109|   283k|  }
  110|   288k|}
bit_reader_utils.c:VP8GetBit:
  114|   473k|                                 const char label[]) {
  115|       |  // Don't move this declaration! It makes a big speed difference to store
  116|       |  // 'range' *before* calling VP8LoadNewBytes(), even if this function doesn't
  117|       |  // alter br->range value.
  118|   473k|  range_t range = br->range;
  119|   473k|  if (br->bits < 0) {
  ------------------
  |  Branch (119:7): [True: 283k, False: 190k]
  ------------------
  120|   283k|    VP8LoadNewBytes(br);
  121|   283k|  }
  122|   473k|  {
  123|   473k|    const int pos = br->bits;
  124|   473k|    const range_t split = (range * prob) >> 8;
  125|   473k|    const range_t value = (range_t)(br->value >> pos);
  126|   473k|    const int bit = (value > split);
  127|   473k|    if (bit) {
  ------------------
  |  Branch (127:9): [True: 379k, False: 94.4k]
  ------------------
  128|   379k|      range -= split;
  129|   379k|      br->value -= (bit_t)(split + 1) << pos;
  130|   379k|    } else {
  131|  94.4k|      range = split + 1;
  132|  94.4k|    }
  133|   473k|    {
  134|   473k|      const int shift = 7 ^ BitsLog2Floor(range);
  135|   473k|      range <<= shift;
  136|   473k|      br->bits -= shift;
  137|   473k|    }
  138|   473k|    br->range = range - 1;
  139|   473k|    BT_TRACK(br);
  140|   473k|    return bit;
  141|   473k|  }
  142|   473k|}
tree_dec.c:VP8GetBit:
  114|  4.94M|                                 const char label[]) {
  115|       |  // Don't move this declaration! It makes a big speed difference to store
  116|       |  // 'range' *before* calling VP8LoadNewBytes(), even if this function doesn't
  117|       |  // alter br->range value.
  118|  4.94M|  range_t range = br->range;
  119|  4.94M|  if (br->bits < 0) {
  ------------------
  |  Branch (119:7): [True: 436k, False: 4.50M]
  ------------------
  120|   436k|    VP8LoadNewBytes(br);
  121|   436k|  }
  122|  4.94M|  {
  123|  4.94M|    const int pos = br->bits;
  124|  4.94M|    const range_t split = (range * prob) >> 8;
  125|  4.94M|    const range_t value = (range_t)(br->value >> pos);
  126|  4.94M|    const int bit = (value > split);
  127|  4.94M|    if (bit) {
  ------------------
  |  Branch (127:9): [True: 508k, False: 4.43M]
  ------------------
  128|   508k|      range -= split;
  129|   508k|      br->value -= (bit_t)(split + 1) << pos;
  130|  4.43M|    } else {
  131|  4.43M|      range = split + 1;
  132|  4.43M|    }
  133|  4.94M|    {
  134|  4.94M|      const int shift = 7 ^ BitsLog2Floor(range);
  135|  4.94M|      range <<= shift;
  136|  4.94M|      br->bits -= shift;
  137|  4.94M|    }
  138|  4.94M|    br->range = range - 1;
  139|  4.94M|    BT_TRACK(br);
  140|  4.94M|    return bit;
  141|  4.94M|  }
  142|  4.94M|}
tree_dec.c:VP8LoadNewBytes:
   64|   436k|    VP8BitReader* WEBP_RESTRICT const br) {
   65|   436k|  assert(br != NULL && br->buf != NULL);
   66|       |  // Read 'BITS' bits at a time if possible.
   67|   436k|  if (br->buf < br->buf_max) {
  ------------------
  |  Branch (67:7): [True: 12.1k, False: 423k]
  ------------------
   68|       |    // convert memory type to register type (with some zero'ing!)
   69|  12.1k|    bit_t bits;
   70|       |#if defined(WEBP_USE_MIPS32)
   71|       |    // This is needed because of un-aligned read.
   72|       |    lbit_t in_bits;
   73|       |    lbit_t* p_buf = (lbit_t*)br->buf;
   74|       |    __asm__ volatile(
   75|       |        ".set   push                             \n\t"
   76|       |        ".set   at                               \n\t"
   77|       |        ".set   macro                            \n\t"
   78|       |        "ulw    %[in_bits], 0(%[p_buf])          \n\t"
   79|       |        ".set   pop                              \n\t"
   80|       |        : [in_bits] "=r"(in_bits)
   81|       |        : [p_buf] "r"(p_buf)
   82|       |        : "memory", "at");
   83|       |#else
   84|  12.1k|    lbit_t in_bits;
   85|  12.1k|    WEBP_UNSAFE_MEMCPY(&in_bits, br->buf, sizeof(in_bits));
  ------------------
  |  |  174|  12.1k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
   86|  12.1k|#endif
   87|  12.1k|    br->buf += BITS >> 3;
  ------------------
  |  |   70|  12.1k|#define BITS 56
  ------------------
   88|  12.1k|    WEBP_SELF_ASSIGN(br->buf_end);
  ------------------
  |  |  186|  12.1k|#define WEBP_SELF_ASSIGN(x) x = x
  ------------------
   89|  12.1k|#if !defined(WORDS_BIGENDIAN)
   90|  12.1k|#if (BITS > 32)
   91|  12.1k|    bits = BSwap64(in_bits);
   92|  12.1k|    bits >>= 64 - BITS;
  ------------------
  |  |   70|  12.1k|#define BITS 56
  ------------------
   93|       |#elif (BITS >= 24)
   94|       |    bits = BSwap32(in_bits);
   95|       |    bits >>= (32 - BITS);
   96|       |#elif (BITS == 16)
   97|       |    bits = BSwap16(in_bits);
   98|       |#else   // BITS == 8
   99|       |    bits = (bit_t)in_bits;
  100|       |#endif  // BITS > 32
  101|       |#else   // WORDS_BIGENDIAN
  102|       |    bits = (bit_t)in_bits;
  103|       |    if (BITS != 8 * sizeof(bit_t)) bits >>= (8 * sizeof(bit_t) - BITS);
  104|       |#endif
  105|  12.1k|    br->value = bits | (br->value << BITS);
  ------------------
  |  |   70|  12.1k|#define BITS 56
  ------------------
  106|  12.1k|    br->bits += BITS;
  ------------------
  |  |   70|  12.1k|#define BITS 56
  ------------------
  107|   423k|  } else {
  108|   423k|    VP8LoadFinalBytes(br);  // no need to be inlined
  109|   423k|  }
  110|   436k|}

VP8BitReaderSetBuffer:
   36|  5.68k|                           size_t size) {
   37|  5.68k|  assert(start != NULL);
   38|  5.68k|  br->buf = start;
   39|  5.68k|  br->buf_end = start + size;
   40|  5.68k|  br->buf_max =
   41|  5.68k|      (size >= sizeof(lbit_t)) ? start + size - sizeof(lbit_t) + 1 : start;
  ------------------
  |  Branch (41:7): [True: 2.71k, False: 2.97k]
  ------------------
   42|  5.68k|}
VP8InitBitReader:
   46|  5.68k|                      size_t size) {
   47|  5.68k|  assert(br != NULL);
   48|  5.68k|  assert(start != NULL);
   49|       |  assert(size < (1u << 31));  // limit ensured by format and upstream checks
   50|  5.68k|  br->range = 255 - 1;
   51|  5.68k|  br->value = 0;
   52|  5.68k|  br->bits = -8;  // to load the very first 8bits
   53|  5.68k|  br->eof = 0;
   54|  5.68k|  VP8BitReaderSetBuffer(br, start, size);
   55|  5.68k|  VP8LoadNewBytes(br);
   56|  5.68k|}
VP8LoadFinalBytes:
   86|  1.15M|void VP8LoadFinalBytes(VP8BitReader* const br) {
   87|  1.15M|  assert(br != NULL && br->buf != NULL);
   88|       |  // Only read 8bits at a time
   89|  1.15M|  if (br->buf < br->buf_end) {
  ------------------
  |  Branch (89:7): [True: 14.5k, False: 1.13M]
  ------------------
   90|  14.5k|    br->bits += 8;
   91|  14.5k|    br->value = (bit_t)(*br->buf++) | (br->value << 8);
   92|  14.5k|    WEBP_SELF_ASSIGN(br->buf_end);
  ------------------
  |  |  186|  14.5k|#define WEBP_SELF_ASSIGN(x) x = x
  ------------------
   93|  1.13M|  } else if (!br->eof) {
  ------------------
  |  Branch (93:14): [True: 2.74k, False: 1.13M]
  ------------------
   94|  2.74k|    br->value <<= 8;
   95|  2.74k|    br->bits += 8;
   96|  2.74k|    br->eof = 1;
   97|  1.13M|  } else {
   98|  1.13M|    br->bits = 0;  // This is to avoid undefined behaviour with shifts.
   99|  1.13M|  }
  100|  1.15M|}
VP8GetValue:
  105|   101k|uint32_t VP8GetValue(VP8BitReader* const br, int bits, const char label[]) {
  106|   101k|  uint32_t v = 0;
  107|   575k|  while (bits-- > 0) {
  ------------------
  |  Branch (107:10): [True: 473k, False: 101k]
  ------------------
  108|   473k|    v |= VP8GetBit(br, 0x80, label) << bits;
  ------------------
  |  |   46|   473k|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  ------------------
  109|   473k|  }
  110|   101k|  return v;
  111|   101k|}
VP8GetSignedValue:
  114|  4.37k|                          const char label[]) {
  115|  4.37k|  const int value = VP8GetValue(br, bits, label);
  ------------------
  |  |   43|  4.37k|#define VP8GetValue(BR, N, L) VP8GetValue(BR, N)
  ------------------
  116|  4.37k|  return VP8Get(br, label) ? -value : value;
  ------------------
  |  |   44|  4.37k|#define VP8Get(BR, L) VP8GetValue(BR, 1, L)
  |  |  ------------------
  |  |  |  |   43|  4.37k|#define VP8GetValue(BR, N, L) VP8GetValue(BR, N)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (43:31): [True: 2.70k, False: 1.67k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  117|  4.37k|}
VP8LInitBitReader:
  138|  7.30k|                       size_t length) {
  139|  7.30k|  size_t i;
  140|  7.30k|  vp8l_val_t value = 0;
  141|  7.30k|  assert(br != NULL);
  142|  7.30k|  assert(start != NULL);
  143|  7.30k|  assert(length < 0xfffffff8u);  // can't happen with a RIFF chunk.
  144|       |
  145|  7.30k|  br->buf = start;
  146|  7.30k|  br->len = length;
  147|  7.30k|  br->bit_pos = 0;
  148|  7.30k|  br->eos = 0;
  149|       |
  150|  7.30k|  if (length > sizeof(br->val)) {
  ------------------
  |  Branch (150:7): [True: 7.24k, False: 59]
  ------------------
  151|  7.24k|    length = sizeof(br->val);
  152|  7.24k|  }
  153|  65.5k|  for (i = 0; i < length; ++i) {
  ------------------
  |  Branch (153:15): [True: 58.2k, False: 7.30k]
  ------------------
  154|  58.2k|    value |= (vp8l_val_t)start[i] << (8 * i);
  155|  58.2k|  }
  156|  7.30k|  br->val = value;
  157|  7.30k|  br->pos = length;
  158|  7.30k|}
VP8LDoFillBitWindow:
  190|   770k|void VP8LDoFillBitWindow(VP8LBitReader* const br) {
  191|   770k|  assert(br->bit_pos >= VP8L_WBITS);
  192|   770k|#if defined(VP8L_USE_FAST_LOAD)
  193|   770k|  if (br->pos + sizeof(br->val) < br->len) {
  ------------------
  |  Branch (193:7): [True: 206k, False: 564k]
  ------------------
  194|   206k|    br->val >>= VP8L_WBITS;
  ------------------
  |  |  147|   206k|#define VP8L_WBITS 32  // Minimum number of bytes ready after VP8LFillBitWindow.
  ------------------
  195|   206k|    br->bit_pos -= VP8L_WBITS;
  ------------------
  |  |  147|   206k|#define VP8L_WBITS 32  // Minimum number of bytes ready after VP8LFillBitWindow.
  ------------------
  196|   206k|    br->val |= (vp8l_val_t)HToLE32(WebPMemToUint32(br->buf + br->pos))
  ------------------
  |  |   29|   206k|#define HToLE32(x) (x)
  ------------------
  197|   206k|               << (VP8L_LBITS - VP8L_WBITS);
  ------------------
  |  |  146|   206k|#define VP8L_LBITS 64  // Number of bits prefetched (= bit-size of vp8l_val_t).
  ------------------
                             << (VP8L_LBITS - VP8L_WBITS);
  ------------------
  |  |  147|   206k|#define VP8L_WBITS 32  // Minimum number of bytes ready after VP8LFillBitWindow.
  ------------------
  198|   206k|    br->pos += VP8L_LOG8_WBITS;
  ------------------
  |  |  122|   206k|#define VP8L_LOG8_WBITS 4  // Number of bytes needed to store VP8L_WBITS bits.
  ------------------
  199|   206k|    return;
  200|   206k|  }
  201|   564k|#endif
  202|   564k|  ShiftBytes(br);  // Slow path.
  203|   564k|}
VP8LReadBits:
  205|   795k|uint32_t VP8LReadBits(VP8LBitReader* const br, int n_bits) {
  206|   795k|  assert(n_bits >= 0);
  207|       |  // Flag an error if end_of_stream or n_bits is more than allowed limit.
  208|   795k|  if (!br->eos && n_bits <= VP8L_MAX_NUM_BIT_READ) {
  ------------------
  |  |  144|   787k|#define VP8L_MAX_NUM_BIT_READ 24
  ------------------
  |  Branch (208:7): [True: 787k, False: 7.90k]
  |  Branch (208:19): [True: 787k, False: 0]
  ------------------
  209|   787k|    const uint32_t val = VP8LPrefetchBits(br) & kBitMask[n_bits];
  210|   787k|    const int new_bits = br->bit_pos + n_bits;
  211|   787k|    br->bit_pos = new_bits;
  212|   787k|    ShiftBytes(br);
  213|   787k|    return val;
  214|   787k|  } else {
  215|  7.90k|    VP8LSetEndOfStream(br);
  216|  7.90k|    return 0;
  217|  7.90k|  }
  218|   795k|}
bit_reader_utils.c:ShiftBytes:
  178|  1.35M|static void ShiftBytes(VP8LBitReader* const br) {
  179|  1.58M|  while (br->bit_pos >= 8 && br->pos < br->len) {
  ------------------
  |  Branch (179:10): [True: 854k, False: 725k]
  |  Branch (179:30): [True: 229k, False: 625k]
  ------------------
  180|   229k|    br->val >>= 8;
  181|   229k|    br->val |= ((vp8l_val_t)br->buf[br->pos]) << (VP8L_LBITS - 8);
  ------------------
  |  |  146|   229k|#define VP8L_LBITS 64  // Number of bits prefetched (= bit-size of vp8l_val_t).
  ------------------
  182|   229k|    ++br->pos;
  183|   229k|    br->bit_pos -= 8;
  184|   229k|  }
  185|  1.35M|  if (VP8LIsEndOfStream(br)) {
  ------------------
  |  Branch (185:7): [True: 777, False: 1.35M]
  ------------------
  186|    777|    VP8LSetEndOfStream(br);
  187|    777|  }
  188|  1.35M|}
bit_reader_utils.c:VP8LSetEndOfStream:
  172|  8.68k|static void VP8LSetEndOfStream(VP8LBitReader* const br) {
  173|  8.68k|  br->eos = 1;
  174|  8.68k|  br->bit_pos = 0;  // To avoid undefined behaviour with shifts.
  175|  8.68k|}

vp8l_dec.c:VP8LFillBitWindow:
  198|  2.70M|static WEBP_INLINE void VP8LFillBitWindow(VP8LBitReader* const br) {
  199|  2.70M|  if (br->bit_pos >= VP8L_WBITS) VP8LDoFillBitWindow(br);
  ------------------
  |  |  147|  2.70M|#define VP8L_WBITS 32  // Minimum number of bytes ready after VP8LFillBitWindow.
  ------------------
  |  Branch (199:7): [True: 770k, False: 1.93M]
  ------------------
  200|  2.70M|}
vp8l_dec.c:VP8LPrefetchBits:
  176|  4.05M|static WEBP_INLINE uint32_t VP8LPrefetchBits(VP8LBitReader* const br) {
  177|  4.05M|  return (uint32_t)(br->val >> (br->bit_pos & (VP8L_LBITS - 1)));
  ------------------
  |  |  146|  4.05M|#define VP8L_LBITS 64  // Number of bits prefetched (= bit-size of vp8l_val_t).
  ------------------
  178|  4.05M|}
vp8l_dec.c:VP8LSetBitPos:
  191|  4.05M|static WEBP_INLINE void VP8LSetBitPos(VP8LBitReader* const br, int val) {
  192|  4.05M|  br->bit_pos = val;
  193|  4.05M|}
vp8l_dec.c:VP8LIsEndOfStream:
  182|  2.09M|static WEBP_INLINE int VP8LIsEndOfStream(const VP8LBitReader* const br) {
  183|  2.09M|  assert(br->pos <= br->len);
  184|  2.09M|  return br->eos || ((br->pos == br->len) && (br->bit_pos > VP8L_LBITS));
  ------------------
  |  |  146|   765k|#define VP8L_LBITS 64  // Number of bits prefetched (= bit-size of vp8l_val_t).
  ------------------
  |  Branch (184:10): [True: 220, False: 2.09M]
  |  Branch (184:22): [True: 765k, False: 1.32M]
  |  Branch (184:46): [True: 488, False: 765k]
  ------------------
  185|  2.09M|}
bit_reader_utils.c:VP8LIsEndOfStream:
  182|  1.35M|static WEBP_INLINE int VP8LIsEndOfStream(const VP8LBitReader* const br) {
  183|  1.35M|  assert(br->pos <= br->len);
  184|  1.35M|  return br->eos || ((br->pos == br->len) && (br->bit_pos > VP8L_LBITS));
  ------------------
  |  |  146|   636k|#define VP8L_LBITS 64  // Number of bits prefetched (= bit-size of vp8l_val_t).
  ------------------
  |  Branch (184:10): [True: 293, False: 1.35M]
  |  Branch (184:22): [True: 636k, False: 714k]
  |  Branch (184:46): [True: 484, False: 635k]
  ------------------
  185|  1.35M|}
bit_reader_utils.c:VP8LPrefetchBits:
  176|   787k|static WEBP_INLINE uint32_t VP8LPrefetchBits(VP8LBitReader* const br) {
  177|   787k|  return (uint32_t)(br->val >> (br->bit_pos & (VP8L_LBITS - 1)));
  ------------------
  |  |  146|   787k|#define VP8L_LBITS 64  // Number of bits prefetched (= bit-size of vp8l_val_t).
  ------------------
  178|   787k|}

VP8LColorCacheInit:
   29|    409|int VP8LColorCacheInit(VP8LColorCache* const color_cache, int hash_bits) {
   30|    409|  const int hash_size = 1 << hash_bits;
   31|    409|  uint32_t* colors = (uint32_t*)WebPSafeCalloc((uint64_t)hash_size,
   32|    409|                                               sizeof(*color_cache->colors));
   33|    409|  assert(color_cache != NULL);
   34|    409|  assert(hash_bits > 0);
   35|    409|  if (colors == NULL) {
  ------------------
  |  Branch (35:7): [True: 0, False: 409]
  ------------------
   36|      0|    color_cache->colors = NULL;
   37|      0|    WEBP_SELF_ASSIGN(color_cache->hash_bits);
  ------------------
  |  |  186|      0|#define WEBP_SELF_ASSIGN(x) x = x
  ------------------
   38|      0|    return 0;
   39|      0|  }
   40|    409|  color_cache->hash_shift = 32 - hash_bits;
   41|    409|  color_cache->hash_bits = hash_bits;
   42|    409|  color_cache->colors = WEBP_UNSAFE_FORGE_BIDI_INDEXABLE(
  ------------------
  |  |  180|    409|#define WEBP_UNSAFE_FORGE_BIDI_INDEXABLE(typ, ptr, size) ((typ)(ptr))
  ------------------
   43|    409|      uint32_t*, colors, (size_t)hash_size * sizeof(*color_cache->colors));
   44|    409|  return 1;
   45|    409|}
VP8LColorCacheClear:
   47|  10.8k|void VP8LColorCacheClear(VP8LColorCache* const color_cache) {
   48|  10.8k|  if (color_cache != NULL) {
  ------------------
  |  Branch (48:7): [True: 10.8k, False: 0]
  ------------------
   49|  10.8k|    WebPSafeFree(color_cache->colors);
   50|  10.8k|    color_cache->colors = NULL;
   51|  10.8k|    WEBP_SELF_ASSIGN(color_cache->hash_bits);
  ------------------
  |  |  186|  10.8k|#define WEBP_SELF_ASSIGN(x) x = x
  ------------------
   52|  10.8k|  }
   53|  10.8k|}

vp8l_dec.c:VP8LColorCacheInsert:
   58|  2.14M|                                             uint32_t argb) {
   59|  2.14M|  const int key = VP8LHashPix(argb, cc->hash_shift);
   60|  2.14M|  cc->colors[key] = argb;
   61|  2.14M|}
vp8l_dec.c:VP8LHashPix:
   41|  2.14M|    uint32_t argb, int shift) {
   42|  2.14M|  return (int)((argb * kHashMul) >> shift);
   43|  2.14M|}
vp8l_dec.c:VP8LColorCacheLookup:
   46|   127k|                                                 uint32_t key) {
   47|       |  assert((key >> cc->hash_bits) == 0u);
   48|   127k|  return cc->colors[key];
   49|   127k|}

vp8_dec.c:BSwap64:
   78|  32.1k|static WEBP_INLINE uint64_t BSwap64(uint64_t x) {
   79|  32.1k|#if defined(HAVE_BUILTIN_BSWAP64)
   80|  32.1k|  return __builtin_bswap64(x);
   81|       |#elif defined(__x86_64__)
   82|       |  uint64_t swapped_bytes;
   83|       |  __asm__ volatile("bswapq %0" : "=r"(swapped_bytes) : "0"(x));
   84|       |  return swapped_bytes;
   85|       |#elif defined(_MSC_VER)
   86|       |  return (uint64_t)_byteswap_uint64(x);
   87|       |#else   // generic code for swapping 64-bit values (suggested by bdb@)
   88|       |  x = ((x & 0xffffffff00000000ull) >> 32) | ((x & 0x00000000ffffffffull) << 32);
   89|       |  x = ((x & 0xffff0000ffff0000ull) >> 16) | ((x & 0x0000ffff0000ffffull) << 16);
   90|       |  x = ((x & 0xff00ff00ff00ff00ull) >> 8) | ((x & 0x00ff00ff00ff00ffull) << 8);
   91|       |  return x;
   92|       |#endif  // HAVE_BUILTIN_BSWAP64
   93|  32.1k|}
lossless.c:BSwap32:
   56|  3.12M|static WEBP_INLINE uint32_t BSwap32(uint32_t x) {
   57|       |#if defined(WEBP_USE_MIPS32_R2)
   58|       |  uint32_t ret;
   59|       |  __asm__ volatile(
   60|       |      "wsbh   %[ret], %[x]          \n\t"
   61|       |      "rotr   %[ret], %[ret],  16   \n\t"
   62|       |      : [ret] "=r"(ret)
   63|       |      : [x] "r"(x));
   64|       |  return ret;
   65|       |#elif defined(HAVE_BUILTIN_BSWAP32)
   66|       |  return __builtin_bswap32(x);
   67|       |#elif defined(__i386__) || defined(__x86_64__)
   68|       |  uint32_t swapped_bytes;
   69|       |  __asm__ volatile("bswap %0" : "=r"(swapped_bytes) : "0"(x));
   70|       |  return swapped_bytes;
   71|       |#elif defined(_MSC_VER)
   72|       |  return (uint32_t)_byteswap_ulong(x);
   73|       |#else
   74|       |  return (x >> 24) | ((x >> 8) & 0xff00) | ((x << 8) & 0xff0000) | (x << 24);
   75|       |#endif  // HAVE_BUILTIN_BSWAP32
   76|  3.12M|}
bit_reader_utils.c:BSwap64:
   78|  5.68k|static WEBP_INLINE uint64_t BSwap64(uint64_t x) {
   79|  5.68k|#if defined(HAVE_BUILTIN_BSWAP64)
   80|  5.68k|  return __builtin_bswap64(x);
   81|       |#elif defined(__x86_64__)
   82|       |  uint64_t swapped_bytes;
   83|       |  __asm__ volatile("bswapq %0" : "=r"(swapped_bytes) : "0"(x));
   84|       |  return swapped_bytes;
   85|       |#elif defined(_MSC_VER)
   86|       |  return (uint64_t)_byteswap_uint64(x);
   87|       |#else   // generic code for swapping 64-bit values (suggested by bdb@)
   88|       |  x = ((x & 0xffffffff00000000ull) >> 32) | ((x & 0x00000000ffffffffull) << 32);
   89|       |  x = ((x & 0xffff0000ffff0000ull) >> 16) | ((x & 0x0000ffff0000ffffull) << 16);
   90|       |  x = ((x & 0xff00ff00ff00ff00ull) >> 8) | ((x & 0x00ff00ff00ff00ffull) << 8);
   91|       |  return x;
   92|       |#endif  // HAVE_BUILTIN_BSWAP64
   93|  5.68k|}
tree_dec.c:BSwap64:
   78|  12.1k|static WEBP_INLINE uint64_t BSwap64(uint64_t x) {
   79|  12.1k|#if defined(HAVE_BUILTIN_BSWAP64)
   80|  12.1k|  return __builtin_bswap64(x);
   81|       |#elif defined(__x86_64__)
   82|       |  uint64_t swapped_bytes;
   83|       |  __asm__ volatile("bswapq %0" : "=r"(swapped_bytes) : "0"(x));
   84|       |  return swapped_bytes;
   85|       |#elif defined(_MSC_VER)
   86|       |  return (uint64_t)_byteswap_uint64(x);
   87|       |#else   // generic code for swapping 64-bit values (suggested by bdb@)
   88|       |  x = ((x & 0xffffffff00000000ull) >> 32) | ((x & 0x00000000ffffffffull) << 32);
   89|       |  x = ((x & 0xffff0000ffff0000ull) >> 16) | ((x & 0x0000ffff0000ffffull) << 16);
   90|       |  x = ((x & 0xff00ff00ff00ff00ull) >> 8) | ((x & 0x00ff00ff00ff00ffull) << 8);
   91|       |  return x;
   92|       |#endif  // HAVE_BUILTIN_BSWAP64
   93|  12.1k|}

VP8LHtreeGroupsNew:
   31|  3.13k|HTreeGroup* VP8LHtreeGroupsNew(int num_htree_groups) {
   32|  3.13k|  HTreeGroup* const htree_groups =
   33|  3.13k|      (HTreeGroup*)WebPSafeMalloc(num_htree_groups, sizeof(*htree_groups));
   34|  3.13k|  if (htree_groups == NULL) {
  ------------------
  |  Branch (34:7): [True: 0, False: 3.13k]
  ------------------
   35|      0|    return NULL;
   36|      0|  }
   37|  3.13k|  assert(num_htree_groups <= MAX_HTREE_GROUPS);
   38|  3.13k|  return htree_groups;
   39|  3.13k|}
VP8LHtreeGroupsFree:
   41|  6.96k|void VP8LHtreeGroupsFree(HTreeGroup* const htree_groups) {
   42|  6.96k|  if (htree_groups != NULL) {
  ------------------
  |  Branch (42:7): [True: 3.13k, False: 3.83k]
  ------------------
   43|  3.13k|    WebPSafeFree(htree_groups);
   44|  3.13k|  }
   45|  6.96k|}
VP8LHuffmanTablesEnsureCapacity:
  236|  48.1k|                                    HuffmanTables* const huffman_tables) {
  237|  48.1k|  if (huffman_tables->curr_segment->curr_table + size >
  ------------------
  |  Branch (237:7): [True: 122, False: 48.0k]
  ------------------
  238|  48.1k|      huffman_tables->curr_segment->start +
  239|  48.1k|          huffman_tables->curr_segment->size) {
  240|       |    // If 'huffman_tables' does not have enough memory, allocate a new segment.
  241|       |    // The available part of huffman_tables->curr_segment is left unused because
  242|       |    // we need a contiguous buffer.
  243|    122|    const int segment_size = huffman_tables->curr_segment->size;
  244|    122|    struct HuffmanTablesSegment* next =
  245|    122|        (HuffmanTablesSegment*)WebPSafeMalloc(1, sizeof(*next));
  246|    122|    if (next == NULL) return 0;
  ------------------
  |  Branch (246:9): [True: 0, False: 122]
  ------------------
  247|       |    // Fill the new segment.
  248|       |    // We need at least 'size' but if that value is small, it is better to
  249|       |    // allocate a big chunk to prevent more allocations later. 'segment_size' is
  250|       |    // therefore chosen (any other arbitrary value could be chosen).
  251|    122|    {
  252|    122|      const int next_size = size > segment_size ? size : segment_size;
  ------------------
  |  Branch (252:29): [True: 0, False: 122]
  ------------------
  253|    122|      HuffmanCode* WEBP_BIDI_INDEXABLE const next_start =
  254|    122|          (HuffmanCode*)WebPSafeMalloc(next_size, sizeof(*next_start));
  255|    122|      if (next_start == NULL) {
  ------------------
  |  Branch (255:11): [True: 0, False: 122]
  ------------------
  256|      0|        WebPSafeFree(next);
  257|      0|        return 0;
  258|      0|      }
  259|    122|      next->size = next_size;
  260|    122|      next->start = next_start;
  261|    122|    }
  262|      0|    next->curr_table = next->start;
  263|    122|    next->next = NULL;
  264|       |    // Point to the new segment.
  265|    122|    huffman_tables->curr_segment->next = next;
  266|    122|    huffman_tables->curr_segment = next;
  267|    122|  }
  268|  48.1k|  return 1;
  269|  48.1k|}
VP8LBuildHuffmanTable:
  274|   152k|                          int code_lengths_size) {
  275|   152k|  const int total_size =
  276|   152k|      BuildHuffmanTable(NULL, root_bits, code_lengths, code_lengths_size, NULL);
  277|   152k|  assert(code_lengths_size <= MAX_CODE_LENGTHS_SIZE);
  278|   152k|  if (total_size == 0 || root_table == NULL) return total_size;
  ------------------
  |  Branch (278:7): [True: 357, False: 152k]
  |  Branch (278:26): [True: 106k, False: 45.4k]
  ------------------
  279|       |
  280|  45.4k|  if (!VP8LHuffmanTablesEnsureCapacity(total_size, root_table)) return -1;
  ------------------
  |  Branch (280:7): [True: 0, False: 45.4k]
  ------------------
  281|  45.4k|  if (code_lengths_size <= SORTED_SIZE_CUTOFF) {
  ------------------
  |  |  234|  45.4k|#define SORTED_SIZE_CUTOFF 512
  ------------------
  |  Branch (281:7): [True: 44.3k, False: 1.12k]
  ------------------
  282|       |    // use local stack-allocated array.
  283|  44.3k|    uint16_t sorted[SORTED_SIZE_CUTOFF];
  284|  44.3k|    BuildHuffmanTable(
  285|  44.3k|        WEBP_UNSAFE_FORGE_BIDI_INDEXABLE(
  ------------------
  |  |  180|  44.3k|#define WEBP_UNSAFE_FORGE_BIDI_INDEXABLE(typ, ptr, size) ((typ)(ptr))
  ------------------
  286|  44.3k|            HuffmanCode*, root_table->curr_segment->curr_table,
  287|  44.3k|            total_size * sizeof(*root_table->curr_segment->curr_table)),
  288|  44.3k|        root_bits, code_lengths, code_lengths_size, sorted);
  289|  44.3k|  } else {  // rare case. Use heap allocation.
  290|  1.12k|    uint16_t* const sorted =
  291|  1.12k|        (uint16_t*)WebPSafeMalloc(code_lengths_size, sizeof(*sorted));
  292|  1.12k|    if (sorted == NULL) return -1;
  ------------------
  |  Branch (292:9): [True: 0, False: 1.12k]
  ------------------
  293|  1.12k|    BuildHuffmanTable(
  294|  1.12k|        WEBP_UNSAFE_FORGE_BIDI_INDEXABLE(
  ------------------
  |  |  180|  1.12k|#define WEBP_UNSAFE_FORGE_BIDI_INDEXABLE(typ, ptr, size) ((typ)(ptr))
  ------------------
  295|  1.12k|            HuffmanCode*, root_table->curr_segment->curr_table,
  296|  1.12k|            total_size * sizeof(*root_table->curr_segment->curr_table)),
  297|  1.12k|        root_bits, code_lengths, code_lengths_size,
  298|  1.12k|        WEBP_UNSAFE_FORGE_BIDI_INDEXABLE(
  ------------------
  |  |  180|  1.12k|#define WEBP_UNSAFE_FORGE_BIDI_INDEXABLE(typ, ptr, size) ((typ)(ptr))
  ------------------
  299|  1.12k|            uint16_t*, sorted, (size_t)code_lengths_size * sizeof(*sorted)));
  300|  1.12k|    WebPSafeFree(sorted);
  301|  1.12k|  }
  302|  45.4k|  return total_size;
  303|  45.4k|}
VP8LHuffmanTablesAllocate:
  305|  4.18k|int VP8LHuffmanTablesAllocate(int size, HuffmanTables* huffman_tables) {
  306|       |  // Have 'segment' point to the first segment for now, 'root'.
  307|  4.18k|  HuffmanTablesSegment* const root = &huffman_tables->root;
  308|  4.18k|  huffman_tables->curr_segment = root;
  309|  4.18k|  root->next = NULL;
  310|       |  // Allocate root.
  311|  4.18k|  {
  312|  4.18k|    HuffmanCode* WEBP_BIDI_INDEXABLE const start =
  313|  4.18k|        (HuffmanCode*)WebPSafeMalloc(size, sizeof(*root->start));
  314|  4.18k|    if (start == NULL) {
  ------------------
  |  Branch (314:9): [True: 0, False: 4.18k]
  ------------------
  315|      0|      root->start = NULL;
  316|      0|      root->size = 0;
  317|      0|      return 0;
  318|      0|    }
  319|  4.18k|    root->size = size;
  320|  4.18k|    root->start = start;
  321|  4.18k|  }
  322|      0|  root->curr_table = root->start;
  323|  4.18k|  return 1;
  324|  4.18k|}
VP8LHuffmanTablesDeallocate:
  326|  8.01k|void VP8LHuffmanTablesDeallocate(HuffmanTables* const huffman_tables) {
  327|  8.01k|  HuffmanTablesSegment *current, *next;
  328|  8.01k|  if (huffman_tables == NULL) return;
  ------------------
  |  Branch (328:7): [True: 0, False: 8.01k]
  ------------------
  329|       |  // Free the root node.
  330|  8.01k|  current = &huffman_tables->root;
  331|  8.01k|  next = current->next;
  332|  8.01k|  WebPSafeFree(current->start);
  333|  8.01k|  current->start = NULL;
  334|  8.01k|  current->curr_table = NULL;
  335|  8.01k|  current->size = 0;
  336|  8.01k|  current->next = NULL;
  337|  8.01k|  huffman_tables->curr_segment = NULL;
  338|  8.01k|  current = next;
  339|       |  // Free the following nodes.
  340|  8.13k|  while (current != NULL) {
  ------------------
  |  Branch (340:10): [True: 122, False: 8.01k]
  ------------------
  341|    122|    next = current->next;
  342|    122|    WebPSafeFree(current->start);
  343|    122|    WebPSafeFree(current);
  344|    122|    current = next;
  345|    122|  }
  346|  8.01k|}
huffman_utils.c:BuildHuffmanTable:
   92|   198k|                                 sorted[]) {
   93|       |  // next available space in table
   94|   198k|  HuffmanCode* WEBP_BIDI_INDEXABLE table = root_table;
   95|   198k|  int total_size = 1 << root_bits;  // total size root table + 2nd level table
   96|   198k|  int len;                          // current code length
   97|   198k|  int symbol;                       // symbol index in original or sorted table
   98|       |  // number of codes of each length:
   99|   198k|  int count[MAX_ALLOWED_CODE_LENGTH + 1] = {0};
  100|       |  // offsets in sorted table for each length:
  101|   198k|  int offset[MAX_ALLOWED_CODE_LENGTH + 1];
  102|       |
  103|   198k|  assert(code_lengths_size != 0);
  104|   198k|  assert(code_lengths != NULL);
  105|   198k|  assert((root_table != NULL && sorted != NULL) ||
  106|   198k|         (root_table == NULL && sorted == NULL));
  107|   198k|  assert(root_bits > 0);
  108|       |
  109|       |  // Build histogram of code lengths.
  110|  44.6M|  for (symbol = 0; symbol < code_lengths_size; ++symbol) {
  ------------------
  |  Branch (110:20): [True: 44.4M, False: 198k]
  ------------------
  111|  44.4M|    if (code_lengths[symbol] > MAX_ALLOWED_CODE_LENGTH) {
  ------------------
  |  |   41|  44.4M|#define MAX_ALLOWED_CODE_LENGTH 15
  ------------------
  |  Branch (111:9): [True: 0, False: 44.4M]
  ------------------
  112|      0|      return 0;
  113|      0|    }
  114|  44.4M|    ++count[code_lengths[symbol]];
  115|  44.4M|  }
  116|       |
  117|       |  // Error, all code lengths are zeros.
  118|   198k|  if (count[0] == code_lengths_size) {
  ------------------
  |  Branch (118:7): [True: 114, False: 198k]
  ------------------
  119|    114|    return 0;
  120|    114|  }
  121|       |
  122|       |  // Generate offsets into sorted symbol table by code length.
  123|   198k|  offset[1] = 0;
  124|  2.97M|  for (len = 1; len < MAX_ALLOWED_CODE_LENGTH; ++len) {
  ------------------
  |  |   41|  2.97M|#define MAX_ALLOWED_CODE_LENGTH 15
  ------------------
  |  Branch (124:17): [True: 2.77M, False: 198k]
  ------------------
  125|  2.77M|    if (count[len] > (1 << len)) {
  ------------------
  |  Branch (125:9): [True: 48, False: 2.77M]
  ------------------
  126|     48|      return 0;
  127|     48|    }
  128|  2.77M|    offset[len + 1] = offset[len] + count[len];
  129|  2.77M|  }
  130|       |
  131|       |  // Sort symbols by length, by symbol order within each length.
  132|  44.5M|  for (symbol = 0; symbol < code_lengths_size; ++symbol) {
  ------------------
  |  Branch (132:20): [True: 44.3M, False: 198k]
  ------------------
  133|  44.3M|    const int symbol_code_length = code_lengths[symbol];
  134|  44.3M|    if (code_lengths[symbol] > 0) {
  ------------------
  |  Branch (134:9): [True: 413k, False: 43.9M]
  ------------------
  135|   413k|      if (sorted != NULL) {
  ------------------
  |  Branch (135:11): [True: 92.7k, False: 320k]
  ------------------
  136|  92.7k|        assert(offset[symbol_code_length] < code_lengths_size);
  137|       |        // The following check is not redundant with the assert. It prevents a
  138|       |        // potential buffer overflow that the optimizer might not be able to
  139|       |        // rule out on its own.
  140|  92.7k|        if (offset[symbol_code_length] >= code_lengths_size) {
  ------------------
  |  Branch (140:13): [True: 0, False: 92.7k]
  ------------------
  141|      0|          return 0;
  142|      0|        }
  143|  92.7k|        sorted[offset[symbol_code_length]++] = symbol;
  144|   320k|      } else {
  145|   320k|        offset[symbol_code_length]++;
  146|   320k|      }
  147|   413k|    }
  148|  44.3M|  }
  149|       |
  150|       |  // Special case code with only one value.
  151|   198k|  if (offset[MAX_ALLOWED_CODE_LENGTH] == 1) {
  ------------------
  |  |   41|   198k|#define MAX_ALLOWED_CODE_LENGTH 15
  ------------------
  |  Branch (151:7): [True: 99.8k, False: 98.1k]
  ------------------
  152|  99.8k|    if (sorted != NULL) {
  ------------------
  |  Branch (152:9): [True: 38.3k, False: 61.5k]
  ------------------
  153|  38.3k|      HuffmanCode code;
  154|  38.3k|      code.bits = 0;
  155|  38.3k|      code.value = (uint16_t)sorted[0];
  156|  38.3k|      ReplicateValue(table, 1, total_size, code);
  157|  38.3k|    }
  158|  99.8k|    return total_size;
  159|  99.8k|  }
  160|       |
  161|  98.1k|  {
  162|  98.1k|    int step;  // step size to replicate values in current table
  163|  98.1k|    uint32_t low = 0xffffffffu;      // low bits for current root entry
  164|  98.1k|    uint32_t mask = total_size - 1;  // mask for low bits
  165|  98.1k|    uint32_t key = 0;                // reversed prefix code
  166|  98.1k|    int num_nodes = 1;               // number of Huffman tree nodes
  167|  98.1k|    int num_open = 1;  // number of open branches in current tree level
  168|  98.1k|    int table_bits = root_bits;        // key length of current table
  169|  98.1k|    int table_size = 1 << table_bits;  // size of current table
  170|  98.1k|    symbol = 0;
  171|       |    // Fill in root table.
  172|   882k|    for (len = 1, step = 2; len <= root_bits; ++len, step <<= 1) {
  ------------------
  |  Branch (172:29): [True: 784k, False: 98.1k]
  ------------------
  173|   784k|      num_open <<= 1;
  174|   784k|      num_nodes += num_open;
  175|   784k|      num_open -= count[len];
  176|   784k|      if (num_open < 0) {
  ------------------
  |  Branch (176:11): [True: 56, False: 784k]
  ------------------
  177|     56|        return 0;
  178|     56|      }
  179|   784k|      if (root_table == NULL) continue;
  ------------------
  |  Branch (179:11): [True: 727k, False: 56.8k]
  ------------------
  180|  83.8k|      for (; count[len] > 0; --count[len]) {
  ------------------
  |  Branch (180:14): [True: 27.0k, False: 56.8k]
  ------------------
  181|  27.0k|        HuffmanCode code;
  182|  27.0k|        code.bits = (uint8_t)len;
  183|  27.0k|        code.value = (uint16_t)sorted[symbol++];
  184|  27.0k|        ReplicateValue(&table[key], step, table_size, code);
  185|  27.0k|        key = GetNextKey(key, len);
  186|  27.0k|      }
  187|  56.8k|    }
  188|       |
  189|       |    // Fill in 2nd level tables and add pointers to root table.
  190|   786k|    for (len = root_bits + 1, step = 2; len <= MAX_ALLOWED_CODE_LENGTH;
  ------------------
  |  |   41|   786k|#define MAX_ALLOWED_CODE_LENGTH 15
  ------------------
  |  Branch (190:41): [True: 688k, False: 98.1k]
  ------------------
  191|   688k|         ++len, step <<= 1) {
  192|   688k|      num_open <<= 1;
  193|   688k|      num_nodes += num_open;
  194|   688k|      num_open -= count[len];
  195|   688k|      if (num_open < 0) {
  ------------------
  |  Branch (195:11): [True: 14, False: 688k]
  ------------------
  196|     14|        return 0;
  197|     14|      }
  198|   769k|      for (; count[len] > 0; --count[len]) {
  ------------------
  |  Branch (198:14): [True: 80.9k, False: 688k]
  ------------------
  199|  80.9k|        HuffmanCode code;
  200|  80.9k|        if ((key & mask) != low) {
  ------------------
  |  Branch (200:13): [True: 23.4k, False: 57.4k]
  ------------------
  201|  23.4k|          if (root_table != NULL) table += table_size;
  ------------------
  |  Branch (201:15): [True: 10.0k, False: 13.3k]
  ------------------
  202|  23.4k|          table_bits = NextTableBitSize(count, len, root_bits);
  203|  23.4k|          table_size = 1 << table_bits;
  204|  23.4k|          total_size += table_size;
  205|  23.4k|          low = key & mask;
  206|  23.4k|          if (root_table != NULL) {
  ------------------
  |  Branch (206:15): [True: 10.0k, False: 13.3k]
  ------------------
  207|  10.0k|            root_table[low].bits = (uint8_t)(table_bits + root_bits);
  208|  10.0k|            root_table[low].value = (uint16_t)((table - root_table) - low);
  209|  10.0k|          }
  210|  23.4k|        }
  211|  80.9k|        if (root_table != NULL) {
  ------------------
  |  Branch (211:13): [True: 27.4k, False: 53.4k]
  ------------------
  212|  27.4k|          code.bits = (uint8_t)(len - root_bits);
  213|  27.4k|          code.value = (uint16_t)sorted[symbol++];
  214|  27.4k|          ReplicateValue(&table[key >> root_bits], step, table_size, code);
  215|  27.4k|        }
  216|  80.9k|        key = GetNextKey(key, len);
  217|  80.9k|      }
  218|   688k|    }
  219|       |
  220|       |    // Check if tree is full.
  221|  98.1k|    if (num_nodes != 2 * offset[MAX_ALLOWED_CODE_LENGTH] - 1) {
  ------------------
  |  |   41|  98.1k|#define MAX_ALLOWED_CODE_LENGTH 15
  ------------------
  |  Branch (221:9): [True: 125, False: 97.9k]
  ------------------
  222|    125|      return 0;
  223|    125|    }
  224|  98.1k|  }
  225|       |
  226|  97.9k|  return total_size;
  227|  98.1k|}
huffman_utils.c:ReplicateValue:
   61|  92.7k|                                       int step, int end, HuffmanCode code) {
   62|  92.7k|  int current_end = end;
   63|  92.7k|  assert(current_end % step == 0);
   64|  11.5M|  do {
   65|  11.5M|    current_end -= step;
   66|  11.5M|    table[current_end] = code;
   67|  11.5M|  } while (current_end > 0);
  ------------------
  |  Branch (67:12): [True: 11.4M, False: 92.7k]
  ------------------
   68|  92.7k|}
huffman_utils.c:GetNextKey:
   49|   107k|static WEBP_INLINE uint32_t GetNextKey(uint32_t key, int len) {
   50|   107k|  uint32_t step = 1 << (len - 1);
   51|   208k|  while (key & step) {
  ------------------
  |  Branch (51:10): [True: 100k, False: 107k]
  ------------------
   52|   100k|    step >>= 1;
   53|   100k|  }
   54|   107k|  return step ? (key & (step - 1)) + step : key;
  ------------------
  |  Branch (54:10): [True: 100k, False: 7.21k]
  ------------------
   55|   107k|}
huffman_utils.c:NextTableBitSize:
   75|  23.4k|    int len, int root_bits) {
   76|  23.4k|  int left = 1 << (len - root_bits);
   77|  23.6k|  while (len < MAX_ALLOWED_CODE_LENGTH) {
  ------------------
  |  |   41|  23.6k|#define MAX_ALLOWED_CODE_LENGTH 15
  ------------------
  |  Branch (77:10): [True: 23.5k, False: 83]
  ------------------
   78|  23.5k|    left -= count[len];
   79|  23.5k|    if (left <= 0) break;
  ------------------
  |  Branch (79:9): [True: 23.3k, False: 208]
  ------------------
   80|    208|    ++len;
   81|    208|    left <<= 1;
   82|    208|  }
   83|  23.4k|  return len - root_bits;
   84|  23.4k|}

WebPGetWorkerInterface:
  305|  7.51k|const WebPWorkerInterface* WebPGetWorkerInterface(void) {
  306|  7.51k|  return &g_worker_interface;
  307|  7.51k|}
thread_utils.c:Init:
  204|  2.67k|static void Init(WebPWorker* const worker) {
  205|  2.67k|  WEBP_UNSAFE_MEMSET(worker, 0, sizeof(*worker));
  ------------------
  |  |  175|  2.67k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  206|  2.67k|  worker->status = NOT_OK;
  207|  2.67k|}
thread_utils.c:End:
  271|  4.83k|static void End(WebPWorker* const worker) {
  272|  4.83k|#ifdef WEBP_USE_THREAD
  273|  4.83k|  if (worker->impl != NULL) {
  ------------------
  |  Branch (273:7): [True: 0, False: 4.83k]
  ------------------
  274|      0|    WebPWorkerImpl* const impl = (WebPWorkerImpl*)worker->impl;
  275|      0|    ChangeState(worker, NOT_OK);
  276|      0|    pthread_join(impl->thread, NULL);
  277|      0|    pthread_mutex_destroy(&impl->mutex);
  278|      0|    pthread_cond_destroy(&impl->condition);
  279|      0|    WebPSafeFree(impl);
  280|      0|    worker->impl = NULL;
  281|      0|  }
  282|       |#else
  283|       |  worker->status = NOT_OK;
  284|       |  assert(worker->impl == NULL);
  285|       |#endif
  286|       |  assert(worker->status == NOT_OK);
  287|  4.83k|}

WebPSafeMalloc:
  206|  18.2k|    WebPSafeMalloc(uint64_t nmemb, size_t size) {
  207|  18.2k|  void* ptr;
  208|  18.2k|  Increment(&num_malloc_calls);
  ------------------
  |  |  171|  18.2k|  do {               \
  |  |  172|  18.2k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (172:12): [Folded, False: 18.2k]
  |  |  ------------------
  ------------------
  209|  18.2k|  if (!CheckSizeArgumentsOverflow(nmemb, size)) return NULL;
  ------------------
  |  Branch (209:7): [True: 0, False: 18.2k]
  ------------------
  210|  18.2k|  assert(nmemb * size > 0);
  211|  18.2k|  ptr = malloc((size_t)(nmemb * size));
  212|  18.2k|  AddMem(ptr, (size_t)(nmemb * size));
  ------------------
  |  |  174|  18.2k|  do {               \
  |  |  175|  18.2k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (175:12): [Folded, False: 18.2k]
  |  |  ------------------
  ------------------
  213|  18.2k|  return WEBP_UNSAFE_FORGE_BIDI_INDEXABLE(void*, ptr, (size_t)(nmemb * size));
  ------------------
  |  |  180|  18.2k|#define WEBP_UNSAFE_FORGE_BIDI_INDEXABLE(typ, ptr, size) ((typ)(ptr))
  ------------------
  214|  18.2k|}
WebPSafeCalloc:
  217|  8.27k|    WebPSafeCalloc(uint64_t nmemb, size_t size) {
  218|  8.27k|  void* ptr;
  219|  8.27k|  Increment(&num_calloc_calls);
  ------------------
  |  |  171|  8.27k|  do {               \
  |  |  172|  8.27k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (172:12): [Folded, False: 8.27k]
  |  |  ------------------
  ------------------
  220|  8.27k|  if (!CheckSizeArgumentsOverflow(nmemb, size)) return NULL;
  ------------------
  |  Branch (220:7): [True: 0, False: 8.27k]
  ------------------
  221|  8.27k|  assert(nmemb * size > 0);
  222|  8.27k|  ptr = calloc((size_t)nmemb, size);
  223|  8.27k|  AddMem(ptr, (size_t)(nmemb * size));
  ------------------
  |  |  174|  8.27k|  do {               \
  |  |  175|  8.27k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (175:12): [Folded, False: 8.27k]
  |  |  ------------------
  ------------------
  224|  8.27k|  return WEBP_UNSAFE_FORGE_BIDI_INDEXABLE(void*, ptr, (size_t)(nmemb * size));
  ------------------
  |  |  180|  8.27k|#define WEBP_UNSAFE_FORGE_BIDI_INDEXABLE(typ, ptr, size) ((typ)(ptr))
  ------------------
  225|  8.27k|}
WebPSafeFree:
  227|  62.0k|void WebPSafeFree(void* const ptr) {
  228|  62.0k|  if (ptr != NULL) {
  ------------------
  |  Branch (228:7): [True: 26.5k, False: 35.5k]
  ------------------
  229|  26.5k|    Increment(&num_free_calls);
  ------------------
  |  |  171|  26.5k|  do {               \
  |  |  172|  26.5k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (172:12): [Folded, False: 26.5k]
  |  |  ------------------
  ------------------
  230|  26.5k|    SubMem(ptr);
  ------------------
  |  |  177|  26.5k|  do {            \
  |  |  178|  26.5k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (178:12): [Folded, False: 26.5k]
  |  |  ------------------
  ------------------
  231|  26.5k|  }
  232|  62.0k|  free(ptr);
  233|  62.0k|}
WebPFree:
  251|    702|void WebPFree(void* WEBP_SINGLE ptr) { WebPSafeFree(ptr); }
WebPCopyPlane:
  256|  14.5k|                   int dst_stride, int width, int height) {
  257|  14.5k|  assert(src != NULL && dst != NULL);
  258|  14.5k|  assert(CheckStride(src_stride, 1, width) &&
  259|  14.5k|         CheckStride(dst_stride, 1, width));
  260|   168k|  while (height-- > 0) {
  ------------------
  |  Branch (260:10): [True: 153k, False: 14.5k]
  ------------------
  261|   153k|    WEBP_UNSAFE_MEMCPY(dst, src, width);
  ------------------
  |  |  174|   153k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
  262|   153k|    src += src_stride;
  263|   153k|    dst += dst_stride;
  264|   153k|  }
  265|  14.5k|}
utils.c:CheckSizeArgumentsOverflow:
  183|  26.5k|                                                     size_t size) {
  184|  26.5k|  const uint64_t total_size = nmemb * size;
  185|  26.5k|  if (nmemb == 0) return 1;
  ------------------
  |  Branch (185:7): [True: 0, False: 26.5k]
  ------------------
  186|  26.5k|  if ((uint64_t)size > WEBP_MAX_ALLOCABLE_MEMORY / nmemb) return 0;
  ------------------
  |  |   40|  26.5k|#define WEBP_MAX_ALLOCABLE_MEMORY (1ULL << 34)
  ------------------
  |  Branch (186:7): [True: 0, False: 26.5k]
  ------------------
  187|  26.5k|  if (!CheckSizeOverflow(total_size)) return 0;
  ------------------
  |  Branch (187:7): [True: 0, False: 26.5k]
  ------------------
  188|       |#if defined(PRINT_MEM_INFO) && defined(MALLOC_FAIL_AT)
  189|       |  if (countdown_to_fail > 0 && --countdown_to_fail == 0) {
  190|       |    return 0;  // fake fail!
  191|       |  }
  192|       |#endif
  193|       |#if defined(PRINT_MEM_INFO) && defined(MALLOC_LIMIT)
  194|       |  if (mem_limit > 0) {
  195|       |    const uint64_t new_total_mem = (uint64_t)total_mem + total_size;
  196|       |    if (!CheckSizeOverflow(new_total_mem) || new_total_mem > mem_limit) {
  197|       |      return 0;  // fake fail!
  198|       |    }
  199|       |  }
  200|       |#endif
  201|       |
  202|  26.5k|  return 1;
  203|  26.5k|}

webp_dec.c:GetLE32:
  116|    549|                                        data) {
  117|    549|  return GetLE16(data) | ((uint32_t)GetLE16(data + 2) << 16);
  118|    549|}
webp_dec.c:GetLE16:
  107|  1.11k|static WEBP_INLINE int GetLE16(const uint8_t* const WEBP_COUNTED_BY(2) data) {
  108|  1.11k|  return (int)(data[0] << 0) | (data[1] << 8);
  109|  1.11k|}
webp_dec.c:GetLE24:
  111|     14|static WEBP_INLINE int GetLE24(const uint8_t* const WEBP_COUNTED_BY(3) data) {
  112|     14|  return GetLE16(data) | (data[2] << 16);
  113|     14|}
utils.c:CheckSizeOverflow:
   47|  26.5k|WEBP_NODISCARD static WEBP_INLINE int CheckSizeOverflow(uint64_t size) {
   48|  26.5k|  return size == (size_t)size;
   49|  26.5k|}
buffer_dec.c:CheckStride:
  200|  5.02k|                                                  int width) {
  201|  5.02k|  uint64_t min_stride, abs_stride;
  202|  5.02k|  if (width <= 0 || step <= 0) return 0;
  ------------------
  |  Branch (202:7): [True: 0, False: 5.02k]
  |  Branch (202:21): [True: 0, False: 5.02k]
  ------------------
  203|  5.02k|  min_stride = (uint64_t)step * (uint64_t)width;
  204|       |  // Do not use abs(stride) as abs(INT_MIN) is undefined behavior.
  205|  5.02k|  abs_stride = (stride < 0) ? (uint64_t)-(int64_t)stride : (uint64_t)stride;
  ------------------
  |  Branch (205:16): [True: 0, False: 5.02k]
  ------------------
  206|  5.02k|  return (abs_stride >= min_stride);
  207|  5.02k|}
frame_dec.c:CheckSizeOverflow:
   47|  2.48k|WEBP_NODISCARD static WEBP_INLINE int CheckSizeOverflow(uint64_t size) {
   48|  2.48k|  return size == (size_t)size;
   49|  2.48k|}
vp8_dec.c:BitsLog2Floor:
  145|  2.08M|static WEBP_INLINE int BitsLog2Floor(uint32_t n) {
  146|  2.08M|  return 31 ^ __builtin_clz(n);
  147|  2.08M|}
dec.c:WebPUint32ToMem:
   95|  25.9k|static WEBP_INLINE void WebPUint32ToMem(uint8_t* const ptr, uint32_t val) {
   96|  25.9k|  WEBP_UNSAFE_MEMCPY(ptr, &val, sizeof(val));
  ------------------
  |  |  174|  25.9k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
   97|  25.9k|}
lossless.c:WebPUint32ToMem:
   95|  3.12M|static WEBP_INLINE void WebPUint32ToMem(uint8_t* const ptr, uint32_t val) {
   96|  3.12M|  WEBP_UNSAFE_MEMCPY(ptr, &val, sizeof(val));
  ------------------
  |  |  174|  3.12M|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
   97|  3.12M|}
dec_sse41.c:WebPMemToInt32:
   91|  77.7k|static WEBP_INLINE int32_t WebPMemToInt32(const uint8_t* const ptr) {
   92|  77.7k|  return (int32_t)WebPMemToUint32(ptr);
   93|  77.7k|}
dec_sse41.c:WebPMemToUint32:
   85|  77.7k|static WEBP_INLINE uint32_t WebPMemToUint32(const uint8_t* const ptr) {
   86|  77.7k|  uint32_t A;
   87|  77.7k|  WEBP_UNSAFE_MEMCPY(&A, ptr, sizeof(A));
  ------------------
  |  |  174|  77.7k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
   88|  77.7k|  return A;
   89|  77.7k|}
dec_sse2.c:WebPMemToInt32:
   91|  2.80M|static WEBP_INLINE int32_t WebPMemToInt32(const uint8_t* const ptr) {
   92|  2.80M|  return (int32_t)WebPMemToUint32(ptr);
   93|  2.80M|}
dec_sse2.c:WebPMemToUint32:
   85|  2.80M|static WEBP_INLINE uint32_t WebPMemToUint32(const uint8_t* const ptr) {
   86|  2.80M|  uint32_t A;
   87|  2.80M|  WEBP_UNSAFE_MEMCPY(&A, ptr, sizeof(A));
  ------------------
  |  |  174|  2.80M|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
   88|  2.80M|  return A;
   89|  2.80M|}
dec_sse2.c:WebPInt32ToMem:
   99|  2.40M|static WEBP_INLINE void WebPInt32ToMem(uint8_t* const ptr, int val) {
  100|  2.40M|  WebPUint32ToMem(ptr, (uint32_t)val);
  101|  2.40M|}
dec_sse2.c:WebPUint32ToMem:
   95|  2.40M|static WEBP_INLINE void WebPUint32ToMem(uint8_t* const ptr, uint32_t val) {
   96|  2.40M|  WEBP_UNSAFE_MEMCPY(ptr, &val, sizeof(val));
  ------------------
  |  |  174|  2.40M|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
   97|  2.40M|}
bit_reader_utils.c:BitsLog2Floor:
  145|   473k|static WEBP_INLINE int BitsLog2Floor(uint32_t n) {
  146|   473k|  return 31 ^ __builtin_clz(n);
  147|   473k|}
bit_reader_utils.c:WebPMemToUint32:
   85|   206k|static WEBP_INLINE uint32_t WebPMemToUint32(const uint8_t* const ptr) {
   86|   206k|  uint32_t A;
   87|   206k|  WEBP_UNSAFE_MEMCPY(&A, ptr, sizeof(A));
  ------------------
  |  |  174|   206k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
   88|   206k|  return A;
   89|   206k|}
tree_dec.c:BitsLog2Floor:
  145|  4.94M|static WEBP_INLINE int BitsLog2Floor(uint32_t n) {
  146|  4.94M|  return 31 ^ __builtin_clz(n);
  147|  4.94M|}

webp_dec.c:WebPInitDecBuffer:
  250|  4.77k|WEBP_NODISCARD static WEBP_INLINE int WebPInitDecBuffer(WebPDecBuffer* buffer) {
  251|  4.77k|  return WebPInitDecBufferInternal(buffer, WEBP_DECODER_ABI_VERSION);
  ------------------
  |  |   27|  4.77k|#define WEBP_DECODER_ABI_VERSION 0x0210  // MAJOR(8b) + MINOR(8b)
  ------------------
  252|  4.77k|}
webp_dec.c:WebPIsRGBMode:
  203|    702|static WEBP_INLINE int WebPIsRGBMode(WEBP_CSP_MODE mode) {
  204|    702|  return (mode < MODE_YUV);
  205|    702|}
buffer_dec.c:WebPIsRGBMode:
  203|  7.94k|static WEBP_INLINE int WebPIsRGBMode(WEBP_CSP_MODE mode) {
  204|  7.94k|  return (mode < MODE_YUV);
  205|  7.94k|}
io_dec.c:WebPIsRGBMode:
  203|  2.48k|static WEBP_INLINE int WebPIsRGBMode(WEBP_CSP_MODE mode) {
  204|  2.48k|  return (mode < MODE_YUV);
  205|  2.48k|}
io_dec.c:WebPIsAlphaMode:
  197|  2.48k|static WEBP_INLINE int WebPIsAlphaMode(WEBP_CSP_MODE mode) {
  198|  2.48k|  return (mode == MODE_RGBA || mode == MODE_BGRA || mode == MODE_ARGB ||
  ------------------
  |  Branch (198:11): [True: 448, False: 2.03k]
  |  Branch (198:32): [True: 310, False: 1.72k]
  |  Branch (198:53): [True: 443, False: 1.28k]
  ------------------
  199|  1.28k|          mode == MODE_RGBA_4444 || mode == MODE_YUVA ||
  ------------------
  |  Branch (199:11): [True: 0, False: 1.28k]
  |  Branch (199:37): [True: 0, False: 1.28k]
  ------------------
  200|  1.28k|          WebPIsPremultipliedMode(mode));
  ------------------
  |  Branch (200:11): [True: 0, False: 1.28k]
  ------------------
  201|  2.48k|}
io_dec.c:WebPIsPremultipliedMode:
  192|  2.48k|static WEBP_INLINE int WebPIsPremultipliedMode(WEBP_CSP_MODE mode) {
  193|  2.48k|  return (mode == MODE_rgbA || mode == MODE_bgrA || mode == MODE_Argb ||
  ------------------
  |  Branch (193:11): [True: 0, False: 2.48k]
  |  Branch (193:32): [True: 0, False: 2.48k]
  |  Branch (193:53): [True: 0, False: 2.48k]
  ------------------
  194|  2.48k|          mode == MODE_rgbA_4444);
  ------------------
  |  Branch (194:11): [True: 0, False: 2.48k]
  ------------------
  195|  2.48k|}
vp8l_dec.c:WebPIsPremultipliedMode:
  192|  19.9k|static WEBP_INLINE int WebPIsPremultipliedMode(WEBP_CSP_MODE mode) {
  193|  19.9k|  return (mode == MODE_rgbA || mode == MODE_bgrA || mode == MODE_Argb ||
  ------------------
  |  Branch (193:11): [True: 0, False: 19.9k]
  |  Branch (193:32): [True: 0, False: 19.9k]
  |  Branch (193:53): [True: 0, False: 19.9k]
  ------------------
  194|  19.9k|          mode == MODE_rgbA_4444);
  ------------------
  |  Branch (194:11): [True: 0, False: 19.9k]
  ------------------
  195|  19.9k|}
vp8l_dec.c:WebPIsRGBMode:
  203|  1.11M|static WEBP_INLINE int WebPIsRGBMode(WEBP_CSP_MODE mode) {
  204|  1.11M|  return (mode < MODE_YUV);
  205|  1.11M|}
vp8l_dec.c:WebPIsAlphaMode:
  197|  18.7k|static WEBP_INLINE int WebPIsAlphaMode(WEBP_CSP_MODE mode) {
  198|  18.7k|  return (mode == MODE_RGBA || mode == MODE_BGRA || mode == MODE_ARGB ||
  ------------------
  |  Branch (198:11): [True: 0, False: 18.7k]
  |  Branch (198:32): [True: 0, False: 18.7k]
  |  Branch (198:53): [True: 0, False: 18.7k]
  ------------------
  199|  18.7k|          mode == MODE_RGBA_4444 || mode == MODE_YUVA ||
  ------------------
  |  Branch (199:11): [True: 0, False: 18.7k]
  |  Branch (199:37): [True: 0, False: 18.7k]
  ------------------
  200|  18.7k|          WebPIsPremultipliedMode(mode));
  ------------------
  |  Branch (200:11): [True: 0, False: 18.7k]
  ------------------
  201|  18.7k|}

simple_api_fuzzer.cc:_ZN10fuzz_utilsL8FuzzHashEPKhm:
   66|  4.77k|static WEBP_INLINE uint8_t FuzzHash(const uint8_t* const data, size_t size) {
   67|  4.77k|  uint8_t value = 0;
   68|  4.77k|  size_t incr = size / 128;
   69|  4.77k|  if (!incr) incr = 1;
  ------------------
  |  Branch (69:7): [True: 4.20k, False: 562]
  ------------------
   70|   202k|  for (size_t i = 0; i < size; i += incr) value += data[i];
  ------------------
  |  Branch (70:22): [True: 197k, False: 4.77k]
  ------------------
   71|  4.77k|  return value;
   72|  4.77k|}

simple_api_fuzzer.cc:_ZN12_GLOBAL__N_113SimpleApiTestENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE:
   34|  5.05k|void SimpleApiTest(std::string_view data_in) {
   35|  5.05k|  const uint8_t* const data = reinterpret_cast<const uint8_t*>(data_in.data());
   36|  5.05k|  const size_t size = data_in.size();
   37|  5.05k|  int w, h;
   38|  5.05k|  if (!WebPGetInfo(data, size, &w, &h)) return;
  ------------------
  |  Branch (38:7): [True: 264, False: 4.79k]
  ------------------
   39|  4.79k|  if ((size_t)w * h > fuzz_utils::kFuzzPxLimit) return;
  ------------------
  |  Branch (39:7): [True: 24, False: 4.77k]
  ------------------
   40|       |
   41|  4.77k|  const uint8_t value = fuzz_utils::FuzzHash(data, size);
   42|  4.77k|  uint8_t* buf = NULL;
   43|       |
   44|       |  // For *Into functions, which decode into an external buffer, an
   45|       |  // intentionally too small buffer can be given with low probability.
   46|  4.77k|  if (value < 0x16) {
  ------------------
  |  Branch (46:7): [True: 435, False: 4.33k]
  ------------------
   47|    435|    buf = WebPDecodeRGBA(data, size, &w, &h);
   48|  4.33k|  } else if (value < 0x2b) {
  ------------------
  |  Branch (48:14): [True: 480, False: 3.85k]
  ------------------
   49|    480|    buf = WebPDecodeBGRA(data, size, &w, &h);
   50|    480|#if !defined(WEBP_REDUCE_CSP)
   51|  3.85k|  } else if (value < 0x40) {
  ------------------
  |  Branch (51:14): [True: 442, False: 3.41k]
  ------------------
   52|    442|    buf = WebPDecodeARGB(data, size, &w, &h);
   53|  3.41k|  } else if (value < 0x55) {
  ------------------
  |  Branch (53:14): [True: 422, False: 2.99k]
  ------------------
   54|    422|    buf = WebPDecodeRGB(data, size, &w, &h);
   55|  2.99k|  } else if (value < 0x6a) {
  ------------------
  |  Branch (55:14): [True: 432, False: 2.55k]
  ------------------
   56|    432|    buf = WebPDecodeBGR(data, size, &w, &h);
   57|    432|#endif  // !defined(WEBP_REDUCE_CSP)
   58|  2.55k|  } else if (value < 0x7f) {
  ------------------
  |  Branch (58:14): [True: 382, False: 2.17k]
  ------------------
   59|    382|    uint8_t *u, *v;
   60|    382|    int stride, uv_stride;
   61|    382|    buf = WebPDecodeYUV(data, size, &w, &h, &u, &v, &stride, &uv_stride);
   62|  2.17k|  } else if (value < 0xe8) {
  ------------------
  |  Branch (62:14): [True: 1.76k, False: 415]
  ------------------
   63|  1.76k|    const int stride = (value < 0xbe ? 4 : 3) * w;
  ------------------
  |  Branch (63:25): [True: 1.27k, False: 488]
  ------------------
   64|  1.76k|    size_t buf_size = stride * h;
   65|  1.76k|    if (value % 0x10 == 0) buf_size--;
  ------------------
  |  Branch (65:9): [True: 59, False: 1.70k]
  ------------------
   66|  1.76k|    uint8_t* const ext_buf = (uint8_t*)malloc(buf_size);
   67|  1.76k|    if (value < 0x94) {
  ------------------
  |  Branch (67:9): [True: 416, False: 1.34k]
  ------------------
   68|    416|      (void)WebPDecodeRGBAInto(data, size, ext_buf, buf_size, stride);
   69|    416|#if !defined(WEBP_REDUCE_CSP)
   70|  1.34k|    } else if (value < 0xa9) {
  ------------------
  |  Branch (70:16): [True: 388, False: 958]
  ------------------
   71|    388|      (void)WebPDecodeARGBInto(data, size, ext_buf, buf_size, stride);
   72|    958|    } else if (value < 0xbe) {
  ------------------
  |  Branch (72:16): [True: 470, False: 488]
  ------------------
   73|    470|      (void)WebPDecodeBGRInto(data, size, ext_buf, buf_size, stride);
   74|    488|    } else if (value < 0xd3) {
  ------------------
  |  Branch (74:16): [True: 386, False: 102]
  ------------------
   75|    386|      (void)WebPDecodeRGBInto(data, size, ext_buf, buf_size, stride);
   76|    386|#endif  // !defined(WEBP_REDUCE_CSP)
   77|    386|    } else {
   78|    102|      (void)WebPDecodeBGRAInto(data, size, ext_buf, buf_size, stride);
   79|    102|    }
   80|  1.76k|    free(ext_buf);
   81|  1.76k|  } else {
   82|    415|    size_t luma_size = w * h;
   83|    415|    const int uv_stride = (w + 1) / 2;
   84|    415|    size_t u_size = uv_stride * (h + 1) / 2;
   85|    415|    size_t v_size = uv_stride * (h + 1) / 2;
   86|    415|    if (value % 0x10 == 0) {
  ------------------
  |  Branch (86:9): [True: 24, False: 391]
  ------------------
   87|     24|      if (size & 1) luma_size--;
  ------------------
  |  Branch (87:11): [True: 13, False: 11]
  ------------------
   88|     24|      if (size & 2) u_size--;
  ------------------
  |  Branch (88:11): [True: 14, False: 10]
  ------------------
   89|     24|      if (size & 4) v_size--;
  ------------------
  |  Branch (89:11): [True: 14, False: 10]
  ------------------
   90|     24|    }
   91|    415|    uint8_t* const luma_buf = (uint8_t*)malloc(luma_size);
   92|    415|    uint8_t* const u_buf = (uint8_t*)malloc(u_size);
   93|    415|    uint8_t* const v_buf = (uint8_t*)malloc(v_size);
   94|    415|    (void)WebPDecodeYUVInto(data, size, luma_buf, luma_size,
   95|    415|                            w /* luma_stride */, u_buf, u_size, uv_stride,
   96|    415|                            v_buf, v_size, uv_stride);
   97|    415|    free(luma_buf);
   98|    415|    free(u_buf);
   99|    415|    free(v_buf);
  100|    415|  }
  101|       |
  102|  4.77k|  if (buf) WebPFree(buf);
  ------------------
  |  Branch (102:7): [True: 702, False: 4.06k]
  ------------------
  103|  4.77k|}