_ZN4absl12lts_2024011613base_internal16SchedulingHelperC2ENS1_14SchedulingModeE:
  116|     26|  explicit SchedulingHelper(base_internal::SchedulingMode mode) : mode_(mode) {
  117|     26|    if (mode_ == base_internal::SCHEDULE_KERNEL_ONLY) {
  ------------------
  |  Branch (117:9): [True: 0, False: 26]
  ------------------
  118|      0|      guard_result_ = base_internal::SchedulingGuard::DisableRescheduling();
  119|      0|    }
  120|     26|  }
_ZN4absl12lts_2024011613base_internal16SchedulingHelperD2Ev:
  122|     26|  ~SchedulingHelper() {
  123|     26|    if (mode_ == base_internal::SCHEDULE_KERNEL_ONLY) {
  ------------------
  |  Branch (123:9): [True: 0, False: 26]
  ------------------
  124|      0|      base_internal::SchedulingGuard::EnableRescheduling(guard_result_);
  125|      0|    }
  126|     26|  }
_ZN4absl12lts_2024011613base_internal11ControlWordEPNS0_9once_flagE:
  193|     46|    absl::Nonnull<once_flag*> flag) {
  194|     46|  return &flag->control_;
  195|     46|}
_ZN4absl12lts_202401169call_onceIMNS0_14flags_internal8FlagImplEFvvEJPS3_EEEvRNS0_9once_flagEOT_DpOT0_:
  212|     44|void call_once(absl::once_flag& flag, Callable&& fn, Args&&... args) {
  213|     44|  std::atomic<uint32_t>* once = base_internal::ControlWord(&flag);
  214|     44|  uint32_t s = once->load(std::memory_order_acquire);
  215|     44|  if (ABSL_PREDICT_FALSE(s != base_internal::kOnceDone)) {
  ------------------
  |  |  178|     44|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 24, False: 20]
  |  |  |  Branch (178:49): [Folded, False: 44]
  |  |  |  Branch (178:58): [True: 24, False: 20]
  |  |  ------------------
  ------------------
  216|     24|    base_internal::CallOnceImpl(
  217|     24|        once, base_internal::SCHEDULE_COOPERATIVE_AND_KERNEL,
  218|     24|        std::forward<Callable>(fn), std::forward<Args>(args)...);
  219|     24|  }
  220|     44|}
_ZN4absl12lts_2024011613base_internal12CallOnceImplIMNS0_14flags_internal8FlagImplEFvvEJPS4_EEEvPNSt3__16atomicIjEENS1_14SchedulingModeEOT_DpOT0_:
  153|     24|    Args&&... args) {
  154|       |#ifndef NDEBUG
  155|       |  {
  156|       |    uint32_t old_control = control->load(std::memory_order_relaxed);
  157|       |    if (old_control != kOnceInit &&
  158|       |        old_control != kOnceRunning &&
  159|       |        old_control != kOnceWaiter &&
  160|       |        old_control != kOnceDone) {
  161|       |      ABSL_RAW_LOG(FATAL, "Unexpected value for control word: 0x%lx",
  162|       |                   static_cast<unsigned long>(old_control));  // NOLINT
  163|       |    }
  164|       |  }
  165|       |#endif  // NDEBUG
  166|     24|  static const base_internal::SpinLockWaitTransition trans[] = {
  167|     24|      {kOnceInit, kOnceRunning, true},
  168|     24|      {kOnceRunning, kOnceWaiter, false},
  169|     24|      {kOnceDone, kOnceDone, true}};
  170|       |
  171|       |  // Must do this before potentially modifying control word's state.
  172|     24|  base_internal::SchedulingHelper maybe_disable_scheduling(scheduling_mode);
  173|       |  // Short circuit the simplest case to avoid procedure call overhead.
  174|       |  // The base_internal::SpinLockWait() call returns either kOnceInit or
  175|       |  // kOnceDone. If it returns kOnceDone, it must have loaded the control word
  176|       |  // with std::memory_order_acquire and seen a value of kOnceDone.
  177|     24|  uint32_t old_control = kOnceInit;
  178|     24|  if (control->compare_exchange_strong(old_control, kOnceRunning,
  ------------------
  |  Branch (178:7): [True: 24, False: 0]
  ------------------
  179|     24|                                       std::memory_order_relaxed) ||
  180|      0|      base_internal::SpinLockWait(control, ABSL_ARRAYSIZE(trans), trans,
  ------------------
  |  |   45|      0|  (sizeof(::absl::macros_internal::ArraySizeHelper(array)))
  ------------------
  |  Branch (180:7): [True: 0, False: 0]
  ------------------
  181|     24|                                  scheduling_mode) == kOnceInit) {
  182|     24|    base_internal::invoke(std::forward<Callable>(fn),
  183|     24|                          std::forward<Args>(args)...);
  184|     24|    old_control =
  185|     24|        control->exchange(base_internal::kOnceDone, std::memory_order_release);
  186|     24|    if (old_control == base_internal::kOnceWaiter) {
  ------------------
  |  Branch (186:9): [True: 0, False: 24]
  ------------------
  187|      0|      base_internal::SpinLockWake(control, true);
  188|      0|    }
  189|     24|  }  // else *control is already kOnceDone
  190|     24|}
_ZN4absl12lts_202401169call_onceIRFvvEJEEEvRNS0_9once_flagEOT_DpOT0_:
  212|      2|void call_once(absl::once_flag& flag, Callable&& fn, Args&&... args) {
  213|      2|  std::atomic<uint32_t>* once = base_internal::ControlWord(&flag);
  214|      2|  uint32_t s = once->load(std::memory_order_acquire);
  215|      2|  if (ABSL_PREDICT_FALSE(s != base_internal::kOnceDone)) {
  ------------------
  |  |  178|      2|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 2, False: 0]
  |  |  |  Branch (178:49): [Folded, False: 2]
  |  |  |  Branch (178:58): [True: 2, False: 0]
  |  |  ------------------
  ------------------
  216|      2|    base_internal::CallOnceImpl(
  217|      2|        once, base_internal::SCHEDULE_COOPERATIVE_AND_KERNEL,
  218|      2|        std::forward<Callable>(fn), std::forward<Args>(args)...);
  219|      2|  }
  220|      2|}
_ZN4absl12lts_2024011613base_internal12CallOnceImplIRFvvEJEEEvPNSt3__16atomicIjEENS1_14SchedulingModeEOT_DpOT0_:
  153|      2|    Args&&... args) {
  154|       |#ifndef NDEBUG
  155|       |  {
  156|       |    uint32_t old_control = control->load(std::memory_order_relaxed);
  157|       |    if (old_control != kOnceInit &&
  158|       |        old_control != kOnceRunning &&
  159|       |        old_control != kOnceWaiter &&
  160|       |        old_control != kOnceDone) {
  161|       |      ABSL_RAW_LOG(FATAL, "Unexpected value for control word: 0x%lx",
  162|       |                   static_cast<unsigned long>(old_control));  // NOLINT
  163|       |    }
  164|       |  }
  165|       |#endif  // NDEBUG
  166|      2|  static const base_internal::SpinLockWaitTransition trans[] = {
  167|      2|      {kOnceInit, kOnceRunning, true},
  168|      2|      {kOnceRunning, kOnceWaiter, false},
  169|      2|      {kOnceDone, kOnceDone, true}};
  170|       |
  171|       |  // Must do this before potentially modifying control word's state.
  172|      2|  base_internal::SchedulingHelper maybe_disable_scheduling(scheduling_mode);
  173|       |  // Short circuit the simplest case to avoid procedure call overhead.
  174|       |  // The base_internal::SpinLockWait() call returns either kOnceInit or
  175|       |  // kOnceDone. If it returns kOnceDone, it must have loaded the control word
  176|       |  // with std::memory_order_acquire and seen a value of kOnceDone.
  177|      2|  uint32_t old_control = kOnceInit;
  178|      2|  if (control->compare_exchange_strong(old_control, kOnceRunning,
  ------------------
  |  Branch (178:7): [True: 2, False: 0]
  ------------------
  179|      2|                                       std::memory_order_relaxed) ||
  180|      0|      base_internal::SpinLockWait(control, ABSL_ARRAYSIZE(trans), trans,
  ------------------
  |  |   45|      0|  (sizeof(::absl::macros_internal::ArraySizeHelper(array)))
  ------------------
  |  Branch (180:7): [True: 0, False: 0]
  ------------------
  181|      2|                                  scheduling_mode) == kOnceInit) {
  182|      2|    base_internal::invoke(std::forward<Callable>(fn),
  183|      2|                          std::forward<Args>(args)...);
  184|      2|    old_control =
  185|      2|        control->exchange(base_internal::kOnceDone, std::memory_order_release);
  186|      2|    if (old_control == base_internal::kOnceWaiter) {
  ------------------
  |  Branch (186:9): [True: 0, False: 2]
  ------------------
  187|      0|      base_internal::SpinLockWake(control, true);
  188|      0|    }
  189|      2|  }  // else *control is already kOnceDone
  190|      2|}

_ZN4absl12lts_202401168bit_castImlTnNSt3__19enable_ifIXaaaaeqstT_stT0_sr3std21is_trivially_copyableIS5_EE5valuesr3std21is_trivially_copyableIS4_EE5valueEiE4typeELi0EEES4_RKS5_:
  163|  11.0k|inline constexpr Dest bit_cast(const Source& source) {
  164|  11.0k|  return __builtin_bit_cast(Dest, source);
  165|  11.0k|}
_ZN4absl12lts_202401168bit_castIlmTnNSt3__19enable_ifIXaaaaeqstT_stT0_sr3std21is_trivially_copyableIS5_EE5valuesr3std21is_trivially_copyableIS4_EE5valueEiE4typeELi0EEES4_RKS5_:
  163|  5.53k|inline constexpr Dest bit_cast(const Source& source) {
  164|  5.53k|  return __builtin_bit_cast(Dest, source);
  165|  5.53k|}
_ZN4absl12lts_202401168bit_castINS0_14flags_internal19FlagValueAndInitBitIbEElTnNSt3__19enable_ifIXaaaaeqstT_stT0_sr3std21is_trivially_copyableIS8_EE5valuesr3std21is_trivially_copyableIS7_EE5valueEiE4typeELi0EEES7_RKS8_:
  163|      8|inline constexpr Dest bit_cast(const Source& source) {
  164|      8|  return __builtin_bit_cast(Dest, source);
  165|      8|}
_ZN4absl12lts_202401168bit_castIlNSt3__15arrayIcLm8EEETnNS2_9enable_ifIXaaaaeqstT_stT0_sr3std21is_trivially_copyableIS7_EE5valuesr3std21is_trivially_copyableIS6_EE5valueEiE4typeELi0EEES6_RKS7_:
  163|     10|inline constexpr Dest bit_cast(const Source& source) {
  164|     10|  return __builtin_bit_cast(Dest, source);
  165|     10|}
_ZN4absl12lts_202401168bit_castIdmTnNSt3__19enable_ifIXaaaaeqstT_stT0_sr3std21is_trivially_copyableIS5_EE5valuesr3std21is_trivially_copyableIS4_EE5valueEiE4typeELi0EEES4_RKS5_:
  163|  17.5k|inline constexpr Dest bit_cast(const Source& source) {
  164|  17.5k|  return __builtin_bit_cast(Dest, source);
  165|  17.5k|}

_ZN4absl12lts_202401169gbswap_32Ej:
   48|     20|inline uint32_t gbswap_32(uint32_t host_int) {
   49|     20|#if ABSL_HAVE_BUILTIN(__builtin_bswap32) || defined(__GNUC__)
   50|     20|  return __builtin_bswap32(host_int);
   51|       |#elif defined(_MSC_VER)
   52|       |  return _byteswap_ulong(host_int);
   53|       |#else
   54|       |  return (((host_int & uint32_t{0xFF}) << 24) |
   55|       |          ((host_int & uint32_t{0xFF00}) << 8) |
   56|       |          ((host_int & uint32_t{0xFF0000}) >> 8) |
   57|       |          ((host_int & uint32_t{0xFF000000}) >> 24));
   58|       |#endif
   59|     20|}
_ZN4absl12lts_202401169gbswap_16Et:
   61|      2|inline uint16_t gbswap_16(uint16_t host_int) {
   62|      2|#if ABSL_HAVE_BUILTIN(__builtin_bswap16) || defined(__GNUC__)
   63|      2|  return __builtin_bswap16(host_int);
   64|       |#elif defined(_MSC_VER)
   65|       |  return _byteswap_ushort(host_int);
   66|       |#else
   67|       |  return (((host_int & uint16_t{0xFF}) << 8) |
   68|       |          ((host_int & uint16_t{0xFF00}) >> 8));
   69|       |#endif
   70|      2|}
_ZN4absl12lts_2024011613little_endian8ToHost64Em:
  114|     16|inline uint64_t ToHost64(uint64_t x) { return x; }
_ZN4absl12lts_2024011613little_endian6ToHostEm:
  140|     16|inline uint64_t ToHost(uint64_t x) { return ToHost64(x); }
_ZN4absl12lts_2024011610big_endian8ToHost16Et:
  198|      2|inline uint16_t ToHost16(uint16_t x) { return gbswap_16(x); }
_ZN4absl12lts_2024011610big_endian8ToHost32Ej:
  201|     20|inline uint32_t ToHost32(uint32_t x) { return gbswap_32(x); }
_ZN4absl12lts_2024011610big_endian6Load16EPKv:
  254|      2|inline uint16_t Load16(absl::Nonnull<const void *> p) {
  255|      2|  return ToHost16(ABSL_INTERNAL_UNALIGNED_LOAD16(p));
  ------------------
  |  |   74|      2|  (absl::base_internal::UnalignedLoad16(_p))
  ------------------
  256|      2|}
_ZN4absl12lts_2024011610big_endian6Load32EPKv:
  262|     20|inline uint32_t Load32(absl::Nonnull<const void *> p) {
  263|     20|  return ToHost32(ABSL_INTERNAL_UNALIGNED_LOAD32(p));
  ------------------
  |  |   76|     20|  (absl::base_internal::UnalignedLoad32(_p))
  ------------------
  264|     20|}

_ZN4absl12lts_2024011613base_internal10FastTypeIdIbEEPKvv:
   42|      2|constexpr inline FastTypeIdType FastTypeId() {
   43|      2|  return &FastTypeTag<Type>::dummy_var;
   44|      2|}
_ZN4absl12lts_2024011613base_internal10FastTypeIdINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEPKvv:
   42|      2|constexpr inline FastTypeIdType FastTypeId() {
   43|      2|  return &FastTypeTag<Type>::dummy_var;
   44|      2|}

_ZN4absl12lts_2024011613base_internal8SpinLockC2Ev:
   58|     16|  SpinLock() : lockword_(kSpinLockCooperative) {
   59|     16|    ABSL_TSAN_MUTEX_CREATE(this, __tsan_mutex_not_static);
   60|     16|  }
_ZN4absl12lts_2024011613base_internal8SpinLock4LockEv:
   80|     18|  inline void Lock() ABSL_EXCLUSIVE_LOCK_FUNCTION() {
   81|     18|    ABSL_TSAN_MUTEX_PRE_LOCK(this, 0);
   82|     18|    if (!TryLockImpl()) {
  ------------------
  |  Branch (82:9): [True: 0, False: 18]
  ------------------
   83|      0|      SlowLock();
   84|      0|    }
   85|     18|    ABSL_TSAN_MUTEX_POST_LOCK(this, 0, 0);
   86|     18|  }
_ZN4absl12lts_2024011613base_internal8SpinLock6UnlockEv:
  102|     18|  inline void Unlock() ABSL_UNLOCK_FUNCTION() {
  103|     18|    ABSL_TSAN_MUTEX_PRE_UNLOCK(this, 0);
  104|     18|    uint32_t lock_value = lockword_.load(std::memory_order_relaxed);
  105|     18|    lock_value = lockword_.exchange(lock_value & kSpinLockCooperative,
  106|     18|                                    std::memory_order_release);
  107|       |
  108|     18|    if ((lock_value & kSpinLockDisabledScheduling) != 0) {
  ------------------
  |  Branch (108:9): [True: 0, False: 18]
  ------------------
  109|      0|      base_internal::SchedulingGuard::EnableRescheduling(true);
  110|      0|    }
  111|     18|    if ((lock_value & kWaitTimeMask) != 0) {
  ------------------
  |  Branch (111:9): [True: 0, False: 18]
  ------------------
  112|       |      // Collect contentionz profile info, and speed the wakeup of any waiter.
  113|       |      // The wait_cycles value indicates how long this thread spent waiting
  114|       |      // for the lock.
  115|      0|      SlowUnlock(lock_value);
  116|      0|    }
  117|     18|    ABSL_TSAN_MUTEX_POST_UNLOCK(this, 0);
  118|     18|  }
_ZN4absl12lts_2024011613base_internal8SpinLock11TryLockImplEv:
  192|     18|  inline bool TryLockImpl() {
  193|     18|    uint32_t lock_value = lockword_.load(std::memory_order_relaxed);
  194|     18|    return (TryLockInternal(lock_value, 0) & kSpinLockHeld) == 0;
  195|     18|  }
_ZN4absl12lts_2024011613base_internal14SpinLockHolderC2EPNS1_8SpinLockE:
  208|     18|      : lock_(l) {
  209|     18|    l->Lock();
  210|     18|  }
_ZN4absl12lts_2024011613base_internal14SpinLockHolderD2Ev:
  211|     18|  inline ~SpinLockHolder() ABSL_UNLOCK_FUNCTION() { lock_->Unlock(); }
_ZN4absl12lts_2024011613base_internal8SpinLock15TryLockInternalEjj:
  237|     18|                                          uint32_t wait_cycles) {
  238|     18|  if ((lock_value & kSpinLockHeld) != 0) {
  ------------------
  |  Branch (238:7): [True: 0, False: 18]
  ------------------
  239|      0|    return lock_value;
  240|      0|  }
  241|       |
  242|     18|  uint32_t sched_disabled_bit = 0;
  243|     18|  if ((lock_value & kSpinLockCooperative) == 0) {
  ------------------
  |  Branch (243:7): [True: 0, False: 18]
  ------------------
  244|       |    // For non-cooperative locks we must make sure we mark ourselves as
  245|       |    // non-reschedulable before we attempt to CompareAndSwap.
  246|      0|    if (base_internal::SchedulingGuard::DisableRescheduling()) {
  ------------------
  |  Branch (246:9): [True: 0, False: 0]
  ------------------
  247|      0|      sched_disabled_bit = kSpinLockDisabledScheduling;
  248|      0|    }
  249|      0|  }
  250|       |
  251|     18|  if (!lockword_.compare_exchange_strong(
  ------------------
  |  Branch (251:7): [True: 0, False: 18]
  ------------------
  252|     18|          lock_value,
  253|     18|          kSpinLockHeld | lock_value | wait_cycles | sched_disabled_bit,
  254|     18|          std::memory_order_acquire, std::memory_order_relaxed)) {
  255|      0|    base_internal::SchedulingGuard::EnableRescheduling(sched_disabled_bit != 0);
  256|      0|  }
  257|       |
  258|     18|  return lock_value;
  259|     18|}

_ZN4absl12lts_2024011613base_internal15UnalignedLoad64EPKv:
   51|     36|inline uint64_t UnalignedLoad64(absl::Nonnull<const void *> p) {
   52|     36|  uint64_t t;
   53|     36|  memcpy(&t, p, sizeof t);
   54|     36|  return t;
   55|     36|}
_ZN4absl12lts_2024011613base_internal15UnalignedLoad32EPKv:
   45|    104|inline uint32_t UnalignedLoad32(absl::Nonnull<const void *> p) {
   46|    104|  uint32_t t;
   47|    104|  memcpy(&t, p, sizeof t);
   48|    104|  return t;
   49|    104|}
_ZN4absl12lts_2024011613base_internal15UnalignedLoad16EPKv:
   39|      2|inline uint16_t UnalignedLoad16(absl::Nonnull<const void *> p) {
   40|      2|  uint16_t t;
   41|      2|  memcpy(&t, p, sizeof t);
   42|      2|  return t;
   43|      2|}

_ZN4absl12lts_2024011612NoDestructorINS0_14flags_internal12FlagRegistryEEC2IJETnNSt3__19enable_ifIXntsr3std7is_sameIFvDpRu7__decayIT_EEFvRS4_EEE5valueEiE4typeELi0EEEDpOS8_:
  127|      2|      : impl_(std::forward<Ts>(args)...) {}
_ZN4absl12lts_2024011612NoDestructorINS0_14flags_internal12FlagRegistryEE13PlacementImplC2IJEEEDpOT_:
  165|      2|    explicit PlacementImpl(Args&&... args) {
  166|      2|      new (&space_) T(std::forward<Args>(args)...);
  167|      2|    }
_ZN4absl12lts_2024011612NoDestructorINS0_14flags_internal12FlagRegistryEEdeEv:
  142|     30|  T& operator*() { return *get(); }
_ZN4absl12lts_2024011612NoDestructorINS0_14flags_internal12FlagRegistryEE3getEv:
  144|     30|  T* get() { return impl_.get(); }
_ZN4absl12lts_2024011612NoDestructorINS0_14flags_internal12FlagRegistryEE13PlacementImpl3getEv:
  171|     30|    T* get() { return Launder(reinterpret_cast<T*>(&space_)); }
_ZN4absl12lts_2024011612NoDestructorINS0_14flags_internal12FlagRegistryEE13PlacementImpl7LaunderIS3_EEPT_S8_:
  175|     30|    static P* Launder(P* p) {
  176|     30|#if defined(__cpp_lib_launder) && __cpp_lib_launder >= 201606L
  177|     30|      return std::launder(p);
  178|       |#elif ABSL_HAVE_BUILTIN(__builtin_launder)
  179|       |      return __builtin_launder(p);
  180|       |#else
  181|       |      // When `std::launder` or equivalent are not available, we rely on
  182|       |      // undefined behavior, which works as intended on Abseil's officially
  183|       |      // supported platforms as of Q3 2023.
  184|       |#if defined(__GNUC__) && !defined(__clang__)
  185|       |#pragma GCC diagnostic push
  186|       |#pragma GCC diagnostic ignored "-Wstrict-aliasing"
  187|       |#endif
  188|       |      return p;
  189|       |#if defined(__GNUC__) && !defined(__clang__)
  190|       |#pragma GCC diagnostic pop
  191|       |#endif
  192|       |#endif
  193|     30|    }

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

_ZN4absl12lts_2024011618container_internal17FlatHashMapPolicyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_15CommandLineFlagEE7elementEPNS1_13map_slot_typeIS7_S9_EE:
  597|     27|  static std::pair<const K, V>& element(slot_type* slot) { return slot->value; }
_ZN4absl12lts_2024011618container_internal17FlatHashMapPolicyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_15CommandLineFlagEE7destroyINS3_9allocatorINS3_4pairIKS7_S9_EEEEEEvPT_PNS1_13map_slot_typeIS7_S9_EE:
  577|     26|  static void destroy(Allocator* alloc, slot_type* slot) {
  578|     26|    slot_policy::destroy(alloc, slot);
  579|     26|  }
_ZN4absl12lts_2024011618container_internal17FlatHashMapPolicyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_15CommandLineFlagEE5applyINS1_12raw_hash_setISA_NS1_10StringHashENS1_8StringEqENS3_9allocatorINS3_4pairIKS7_S9_EEEEE12EqualElementIS7_EEJRSI_EEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSO_DpOSP_:
  590|      1|  apply(F&& f, Args&&... args) {
  591|      1|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  592|      1|                                                   std::forward<Args>(args)...);
  593|      1|  }
_ZN4absl12lts_2024011618container_internal17FlatHashMapPolicyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_15CommandLineFlagEE5applyINS1_12raw_hash_setISA_NS1_10StringHashENS1_8StringEqENS3_9allocatorINS3_4pairIKS7_S9_EEEEE19EmplaceDecomposableEJSI_EEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSM_DpOSN_:
  590|     26|  apply(F&& f, Args&&... args) {
  591|     26|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  592|     26|                                                   std::forward<Args>(args)...);
  593|     26|  }
_ZN4absl12lts_2024011618container_internal17FlatHashMapPolicyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_15CommandLineFlagEE9constructINS3_9allocatorINS3_4pairIKS7_S9_EEEEJRKNS3_21piecewise_construct_tENS3_5tupleIJOSE_EEENSK_IJOS9_EEEEEEvPT_PNS1_13map_slot_typeIS7_S9_EEDpOT0_:
  572|     26|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  573|     26|    slot_policy::construct(alloc, slot, std::forward<Args>(args)...);
  574|     26|  }
_ZN4absl12lts_2024011613flat_hash_mapINSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPNS0_15CommandLineFlagENS0_18container_internal10StringHashENS9_8StringEqENS2_9allocatorINS2_4pairIKS6_S8_EEEEEC2Ev:
  159|      2|  flat_hash_map() {}

_ZN4absl12lts_2024011618container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEvE7elementISB_EEDTclsrT_7elementfp_EEPNS1_13map_slot_typeIS8_SA_EE:
   75|     27|      -> decltype(P::element(slot)) {
   76|     27|    return P::element(slot);
   77|     27|  }
_ZN4absl12lts_2024011618container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEvE7destroyINS4_9allocatorINS4_4pairIKS8_SA_EEEEEEvPT_PNS1_13map_slot_typeIS8_SA_EE:
   49|     26|  static void destroy(Alloc* alloc, slot_type* slot) {
   50|     26|    Policy::destroy(alloc, slot);
   51|     26|  }
_ZN4absl12lts_2024011618container_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_:
   42|     26|  static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
   43|     26|    Policy::construct(alloc, slot, std::forward<Args>(args)...);
   44|     26|  }

_ZN4absl12lts_2024011618container_internal25internal_compressed_tuple7StorageINS1_12CommonFieldsELm0ELb0EEC2IS4_EENSt3__110in_place_tEOT_:
   90|      2|      : value(absl::forward<V>(v)) {}
_ZNR4absl12lts_2024011618container_internal25internal_compressed_tuple7StorageINS1_12CommonFieldsELm0ELb0EE3getEv:
   92|    276|  T& get() & { return value; }
_ZNKR4absl12lts_2024011618container_internal25internal_compressed_tuple7StorageINS1_12CommonFieldsELm0ELb0EE3getEv:
   91|    255|  constexpr const T& get() const& { return value; }
_ZNKR4absl12lts_2024011618container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorINS6_4pairIKNS6_17basic_string_viewIcNS6_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEEEEE3getILi0EEERKNS1_25internal_compressed_tuple4ElemISI_XT_EE4typeEv:
  246|    255|  constexpr const ElemT<I>& get() const& {
  247|    255|    return StorageT<I>::get();
  248|    255|  }
_ZNR4absl12lts_2024011618container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorINS6_4pairIKNS6_17basic_string_viewIcNS6_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEEEEE3getILi0EEERNS1_25internal_compressed_tuple4ElemISI_XT_EE4typeEv:
  241|    276|  ElemT<I>& get() & {
  242|    276|    return StorageT<I>::get();
  243|    276|  }
_ZNR4absl12lts_2024011618container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorINS6_4pairIKNS6_17basic_string_viewIcNS6_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEEEEE3getILi3EEERNS1_25internal_compressed_tuple4ElemISI_XT_EE4typeEv:
  241|     60|  ElemT<I>& get() & {
  242|     60|    return StorageT<I>::get();
  243|     60|  }
_ZNR4absl12lts_2024011618container_internal25internal_compressed_tuple7StorageINSt3__19allocatorINS4_4pairIKNS4_17basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEEELm3ELb1EE3getEv:
  106|     60|  T& get() & { return *this; }
_ZNR4absl12lts_2024011618container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorINS6_4pairIKNS6_17basic_string_viewIcNS6_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEEEEE3getILi2EEERNS1_25internal_compressed_tuple4ElemISI_XT_EE4typeEv:
  241|      1|  ElemT<I>& get() & {
  242|      1|    return StorageT<I>::get();
  243|      1|  }
_ZNR4absl12lts_2024011618container_internal25internal_compressed_tuple7StorageINS1_8StringEqELm2ELb1EE3getEv:
  106|      1|  T& get() & { return *this; }
_ZNR4absl12lts_2024011618container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorINS6_4pairIKNS6_17basic_string_viewIcNS6_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEEEEE3getILi1EEERNS1_25internal_compressed_tuple4ElemISI_XT_EE4typeEv:
  241|     26|  ElemT<I>& get() & {
  242|     26|    return StorageT<I>::get();
  243|     26|  }
_ZNR4absl12lts_2024011618container_internal25internal_compressed_tuple7StorageINS1_10StringHashELm1ELb1EE3getEv:
  106|     26|  T& get() & { return *this; }
_ZN4absl12lts_2024011618container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorINS6_4pairIKNS6_17basic_string_viewIcNS6_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEEEEEC2IS3_JS4_S5_SH_ETnNS6_9enable_ifIXsr4absl11conjunctionINS0_8negationINS6_7is_sameIFvSI_EFvNS6_5decayIT_E4typeEEEEEENS1_25internal_compressed_tuple27TupleItemsMoveConstructibleISI_JSP_DpT0_EEEEE5valueEbE4typeELb1EEEOSP_DpOSX_:
  236|      2|      : CompressedTuple::CompressedTupleImpl(absl::in_place,
  237|      2|                                             absl::forward<First>(first),
  238|      2|                                             absl::forward<Vs>(base)...) {}
_ZN4absl12lts_2024011618container_internal25internal_compressed_tuple19CompressedTupleImplINS1_15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorINS8_4pairIKNS8_17basic_string_viewIcNS8_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEEEEEENS8_16integer_sequenceImJLm0ELm1ELm2ELm3EEEELb1EEC2IJS5_S6_S7_SJ_EEENS8_10in_place_tEDpOT_:
  126|      8|      : Storage<Ts, I>(absl::in_place, absl::forward<Vs>(args))... {}
_ZN4absl12lts_2024011618container_internal25internal_compressed_tuple7StorageINS1_10StringHashELm1ELb1EEC2IS4_EENSt3__110in_place_tEOT_:
  103|      2|      : T(absl::forward<V>(v)) {}
_ZN4absl12lts_2024011618container_internal25internal_compressed_tuple7StorageINS1_8StringEqELm2ELb1EEC2IS4_EENSt3__110in_place_tEOT_:
  103|      2|      : T(absl::forward<V>(v)) {}
_ZN4absl12lts_2024011618container_internal25internal_compressed_tuple7StorageINSt3__19allocatorINS4_4pairIKNS4_17basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEEELm3ELb1EEC2ISF_EENS4_10in_place_tEOT_:
  103|      2|      : T(absl::forward<V>(v)) {}

_ZN4absl12lts_2024011618container_internal8AllocateILm8ENSt3__19allocatorIcEEEEPvPT0_m:
   55|      8|void* Allocate(Alloc* alloc, size_t n) {
   56|      8|  static_assert(Alignment > 0, "");
   57|      8|  assert(n && "n must be positive");
   58|      8|  using M = AlignedType<Alignment>;
   59|      8|  using A = typename absl::allocator_traits<Alloc>::template rebind_alloc<M>;
   60|      8|  using AT = typename absl::allocator_traits<Alloc>::template rebind_traits<M>;
   61|       |  // On macOS, "mem_alloc" is a #define with one argument defined in
   62|       |  // rpc/types.h, so we can't name the variable "mem_alloc" and initialize it
   63|       |  // with the "foo(bar)" syntax.
   64|      8|  A my_mem_alloc(*alloc);
   65|      8|  void* p = AT::allocate(my_mem_alloc, (n + sizeof(M) - 1) / sizeof(M));
   66|       |  assert(reinterpret_cast<uintptr_t>(p) % Alignment == 0 &&
   67|      8|         "allocator does not respect alignment");
   68|      8|  return p;
   69|      8|}
_ZN4absl12lts_2024011618container_internal27SanitizerPoisonMemoryRegionEPKvm:
  220|     32|inline void SanitizerPoisonMemoryRegion(const void* m, size_t s) {
  221|       |#ifdef ABSL_HAVE_ADDRESS_SANITIZER
  222|       |  ASAN_POISON_MEMORY_REGION(m, s);
  223|       |#endif
  224|       |#ifdef ABSL_HAVE_MEMORY_SANITIZER
  225|       |  __msan_poison(m, s);
  226|       |#endif
  227|     32|  (void)m;
  228|     32|  (void)s;
  229|     32|}
_ZN4absl12lts_2024011618container_internal29SanitizerUnpoisonMemoryRegionEPKvm:
  231|     38|inline void SanitizerUnpoisonMemoryRegion(const void* m, size_t s) {
  232|       |#ifdef ABSL_HAVE_ADDRESS_SANITIZER
  233|       |  ASAN_UNPOISON_MEMORY_REGION(m, s);
  234|       |#endif
  235|       |#ifdef ABSL_HAVE_MEMORY_SANITIZER
  236|       |  __msan_unpoison(m, s);
  237|       |#endif
  238|     38|  (void)m;
  239|     38|  (void)s;
  240|     38|}
_ZN4absl12lts_2024011618container_internal10DeallocateILm8ENSt3__19allocatorIcEEEEvPT0_Pvm:
   74|      6|void Deallocate(Alloc* alloc, void* p, size_t n) {
   75|      6|  static_assert(Alignment > 0, "");
   76|      6|  assert(n && "n must be positive");
   77|      6|  using M = AlignedType<Alignment>;
   78|      6|  using A = typename absl::allocator_traits<Alloc>::template rebind_alloc<M>;
   79|      6|  using AT = typename absl::allocator_traits<Alloc>::template rebind_traits<M>;
   80|       |  // On macOS, "mem_alloc" is a #define with one argument defined in
   81|       |  // rpc/types.h, so we can't name the variable "mem_alloc" and initialize it
   82|       |  // with the "foo(bar)" syntax.
   83|      6|  A my_mem_alloc(*alloc);
   84|      6|  AT::deallocate(my_mem_alloc, static_cast<M*>(p),
   85|      6|                 (n + sizeof(M) - 1) / sizeof(M));
   86|      6|}
_ZN4absl12lts_2024011618container_internal15map_slot_policyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_15CommandLineFlagEE7destroyINS3_9allocatorINS3_4pairIKS7_S9_EEEEEEvPT_PNS1_13map_slot_typeIS7_S9_EE:
  417|     26|  static void destroy(Allocator* alloc, slot_type* slot) {
  418|     26|    if (kMutableKeys::value) {
  ------------------
  |  Branch (418:9): [True: 26, Folded]
  ------------------
  419|     26|      absl::allocator_traits<Allocator>::destroy(*alloc, &slot->mutable_value);
  420|     26|    } else {
  421|      0|      absl::allocator_traits<Allocator>::destroy(*alloc, &slot->value);
  422|      0|    }
  423|     26|  }
_ZN4absl12lts_2024011618container_internal13DecomposePairINS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS5_9allocatorINS5_4pairIKS9_SB_EEEEE12EqualElementIS9_EEJRSI_EEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSO_DpOSP_:
  206|      1|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  207|      1|  return memory_internal::DecomposePairImpl(
  208|      1|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  209|      1|}
_ZN4absl12lts_2024011618container_internal15memory_internal17DecomposePairImplINS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS6_9allocatorINS6_4pairIKSA_SC_EEEEE12EqualElementISA_EERSI_NS6_5tupleIJRKSC_EEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNS6_19piecewise_constructEEclsr3stdE7declvalINSP_IJSU_EEEEEclsr3stdE7declvalIT1_EEEEOST_NSH_ISX_SY_EE:
  138|      1|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  139|      1|  const auto& key = std::get<0>(p.first);
  140|      1|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  141|      1|                            std::move(p.second));
  142|      1|}
_ZN4absl12lts_2024011618container_internal8PairArgsIKNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS3_4pairINS3_5tupleIJRKT_EEENSC_IJRKT0_EEEEERKNSB_ISD_SH_EE:
  187|      1|    const std::pair<F, S>& p) {
  188|      1|  return PairArgs(p.first, p.second);
  189|      1|}
_ZN4absl12lts_2024011618container_internal8PairArgsIRKNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEERKPNS0_15CommandLineFlagEEENS3_4pairINS3_5tupleIJOT_EEENSF_IJOT0_EEEEESH_SK_:
  181|      1|std::pair<std::tuple<F&&>, std::tuple<S&&>> PairArgs(F&& f, S&& s) {
  182|      1|  return {std::piecewise_construct, std::forward_as_tuple(std::forward<F>(f)),
  183|      1|          std::forward_as_tuple(std::forward<S>(s))};
  184|      1|}
_ZN4absl12lts_2024011618container_internal13DecomposePairINS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS5_9allocatorINS5_4pairIKS9_SB_EEEEE19EmplaceDecomposableEJSI_EEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSM_DpOSN_:
  206|     26|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  207|     26|  return memory_internal::DecomposePairImpl(
  208|     26|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  209|     26|}
_ZN4absl12lts_2024011618container_internal15memory_internal17DecomposePairImplINS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS6_9allocatorINS6_4pairIKSA_SC_EEEEE19EmplaceDecomposableEOSI_NS6_5tupleIJOSC_EEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNS6_19piecewise_constructEEclsr3stdE7declvalINSO_IJSS_EEEEEclsr3stdE7declvalIT1_EEEEOSR_NSH_ISV_SW_EE:
  138|     26|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  139|     26|  const auto& key = std::get<0>(p.first);
  140|     26|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  141|     26|                            std::move(p.second));
  142|     26|}
_ZN4absl12lts_2024011618container_internal15map_slot_policyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_15CommandLineFlagEE7emplaceEPNS1_13map_slot_typeIS7_S9_EE:
  348|     26|  static void emplace(slot_type* slot) {
  349|       |    // The construction of union doesn't do anything at runtime but it allows us
  350|       |    // to access its members without violating aliasing rules.
  351|     26|    new (slot) slot_type;
  352|     26|  }
_ZN4absl12lts_2024011618container_internal13map_slot_typeINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_15CommandLineFlagEEC2Ev:
  329|     26|  map_slot_type() {}
_ZN4absl12lts_2024011618container_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_:
  383|     26|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  384|     26|    emplace(slot);
  385|     26|    if (kMutableKeys::value) {
  ------------------
  |  Branch (385:9): [True: 26, Folded]
  ------------------
  386|     26|      absl::allocator_traits<Allocator>::construct(*alloc, &slot->mutable_value,
  387|     26|                                                   std::forward<Args>(args)...);
  388|     26|    } else {
  389|      0|      absl::allocator_traits<Allocator>::construct(*alloc, &slot->value,
  390|      0|                                                   std::forward<Args>(args)...);
  391|      0|    }
  392|     26|  }
_ZN4absl12lts_2024011618container_internal8PairArgsIKNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS3_4pairINS3_5tupleIJOT_EEENSC_IJOT0_EEEEEONSB_ISD_SG_EE:
  191|     26|std::pair<std::tuple<F&&>, std::tuple<S&&>> PairArgs(std::pair<F, S>&& p) {
  192|     26|  return PairArgs(std::forward<F>(p.first), std::forward<S>(p.second));
  193|     26|}
_ZN4absl12lts_2024011618container_internal8PairArgsIKNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS3_4pairINS3_5tupleIJOT_EEENSC_IJOT0_EEEEESE_SH_:
  181|     26|std::pair<std::tuple<F&&>, std::tuple<S&&>> PairArgs(F&& f, S&& s) {
  182|     26|  return {std::piecewise_construct, std::forward_as_tuple(std::forward<F>(f)),
  183|     26|          std::forward_as_tuple(std::forward<S>(s))};
  184|     26|}

_ZNK4absl12lts_2024011618container_internal10StringHashclENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   77|     26|  size_t operator()(absl::string_view v) const {
   78|     26|    return absl::Hash<absl::string_view>{}(v);
   79|     26|  }
_ZNK4absl12lts_2024011618container_internal8StringEqclENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEES7_:
   87|      1|  bool operator()(absl::string_view lhs, absl::string_view rhs) const {
   88|      1|    return lhs == rhs;
   89|      1|  }

_ZN4absl12lts_2024011618container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEvE5applyINS1_12raw_hash_setISB_NS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE12EqualElementIS8_EEJRSK_ESB_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSR_DpOSS_:
  133|      1|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  134|      1|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  135|      1|  }
_ZN4absl12lts_2024011618container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEvE5applyINS1_12raw_hash_setISB_NS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE19EmplaceDecomposableEJSK_ESB_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSP_DpOSQ_:
  133|     26|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  134|     26|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  135|     26|  }

_ZN4absl12lts_2024011618container_internal6SampleEm:
  210|      2|    size_t inline_element_size ABSL_ATTRIBUTE_UNUSED) {
  211|       |#if defined(ABSL_INTERNAL_HASHTABLEZ_SAMPLE)
  212|       |  if (ABSL_PREDICT_TRUE(--global_next_sample.next_sample > 0)) {
  213|       |    return HashtablezInfoHandle(nullptr);
  214|       |  }
  215|       |  return HashtablezInfoHandle(
  216|       |      SampleSlow(global_next_sample, inline_element_size));
  217|       |#else
  218|      2|  return HashtablezInfoHandle(nullptr);
  219|      2|#endif  // !ABSL_PER_THREAD_TLS
  220|      2|}
_ZN4absl12lts_2024011618container_internal20HashtablezInfoHandleC2EDn:
  187|      2|  explicit HashtablezInfoHandle(std::nullptr_t) {}
_ZNK4absl12lts_2024011618container_internal20HashtablezInfoHandle9IsSampledEv:
  190|      8|  inline bool IsSampled() const { return false; }
_ZN4absl12lts_2024011618container_internal20HashtablezInfoHandle20RecordStorageChangedEmm:
  191|      2|  inline void RecordStorageChanged(size_t /*size*/, size_t /*capacity*/) {}
_ZN4absl12lts_2024011618container_internal20HashtablezInfoHandle12RecordInsertEmm:
  195|     26|  inline void RecordInsert(size_t /*hash*/, size_t /*distance_from_desired*/) {}

_ZN4absl12lts_2024011618container_internal12raw_hash_mapINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEEC2Ev:
   64|      2|  raw_hash_map() {}

_ZN4absl12lts_2024011618container_internal17ClearBackingArrayERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEb:
  256|      2|                       bool reuse) {
  257|      2|  c.set_size(0);
  258|      2|  if (reuse) {
  ------------------
  |  Branch (258:7): [True: 2, False: 0]
  ------------------
  259|      2|    ResetCtrl(c, policy.slot_size);
  260|      2|    ResetGrowthLeft(c);
  261|      2|    c.infoz().RecordStorageChanged(0, c.capacity());
  262|      2|  } else {
  263|       |    // We need to record infoz before calling dealloc, which will unregister
  264|       |    // infoz.
  265|      0|    c.infoz().RecordClearedReservation();
  266|      0|    c.infoz().RecordStorageChanged(0, 0);
  267|      0|    (*policy.dealloc)(c, policy);
  268|      0|    c.set_control(EmptyGroup());
  269|      0|    c.set_generation_ptr(EmptyGeneration());
  270|      0|    c.set_slots(nullptr);
  271|      0|    c.set_capacity(0);
  272|      0|  }
  273|      2|}
_ZNK4absl12lts_2024011618container_internal19HashSetResizeHelper38GrowIntoSingleGroupShuffleControlBytesEPNS1_6ctrl_tEm:
  276|      6|    ctrl_t* new_ctrl, size_t new_capacity) const {
  277|      6|  assert(is_single_group(new_capacity));
  278|      6|  constexpr size_t kHalfWidth = Group::kWidth / 2;
  279|      6|  assert(old_capacity_ < kHalfWidth);
  280|       |
  281|      6|  const size_t half_old_capacity = old_capacity_ / 2;
  282|       |
  283|       |  // NOTE: operations are done with compile time known size = kHalfWidth.
  284|       |  // Compiler optimizes that into single ASM operation.
  285|       |
  286|       |  // Copy second half of bytes to the beginning.
  287|       |  // We potentially copy more bytes in order to have compile time known size.
  288|       |  // Mirrored bytes from the old_ctrl_ will also be copied.
  289|       |  // In case of old_capacity_ == 3, we will copy 1st element twice.
  290|       |  // Examples:
  291|       |  // old_ctrl = 0S0EEEEEEE...
  292|       |  // new_ctrl = S0EEEEEEEE...
  293|       |  //
  294|       |  // old_ctrl = 01S01EEEEE...
  295|       |  // new_ctrl = 1S01EEEEEE...
  296|       |  //
  297|       |  // old_ctrl = 0123456S0123456EE...
  298|       |  // new_ctrl = 456S0123?????????...
  299|      6|  std::memcpy(new_ctrl, old_ctrl_ + half_old_capacity + 1, kHalfWidth);
  300|       |  // Clean up copied kSentinel from old_ctrl.
  301|      6|  new_ctrl[half_old_capacity] = ctrl_t::kEmpty;
  302|       |
  303|       |  // Clean up damaged or uninitialized bytes.
  304|       |
  305|       |  // Clean bytes after the intended size of the copy.
  306|       |  // Example:
  307|       |  // new_ctrl = 1E01EEEEEEE????
  308|       |  // *new_ctrl= 1E0EEEEEEEE????
  309|       |  // position      /
  310|      6|  std::memset(new_ctrl + old_capacity_ + 1, static_cast<int8_t>(ctrl_t::kEmpty),
  311|      6|              kHalfWidth);
  312|       |  // Clean non-mirrored bytes that are not initialized.
  313|       |  // For small old_capacity that may be inside of mirrored bytes zone.
  314|       |  // Examples:
  315|       |  // new_ctrl = 1E0EEEEEEEE??????????....
  316|       |  // *new_ctrl= 1E0EEEEEEEEEEEEE?????....
  317|       |  // position           /
  318|       |  //
  319|       |  // new_ctrl = 456E0123???????????...
  320|       |  // *new_ctrl= 456E0123EEEEEEEE???...
  321|       |  // position           /
  322|      6|  std::memset(new_ctrl + kHalfWidth, static_cast<int8_t>(ctrl_t::kEmpty),
  323|      6|              kHalfWidth);
  324|       |  // Clean last mirrored bytes that are not initialized
  325|       |  // and will not be overwritten by mirroring.
  326|       |  // Examples:
  327|       |  // new_ctrl = 1E0EEEEEEEEEEEEE????????
  328|       |  // *new_ctrl= 1E0EEEEEEEEEEEEEEEEEEEEE
  329|       |  // position           S       /
  330|       |  //
  331|       |  // new_ctrl = 456E0123EEEEEEEE???????????????
  332|       |  // *new_ctrl= 456E0123EEEEEEEE???????EEEEEEEE
  333|       |  // position                  S       /
  334|      6|  std::memset(new_ctrl + new_capacity + kHalfWidth,
  335|      6|              static_cast<int8_t>(ctrl_t::kEmpty), kHalfWidth);
  336|       |
  337|       |  // Create mirrored bytes. old_capacity_ < kHalfWidth
  338|       |  // Example:
  339|       |  // new_ctrl = 456E0123EEEEEEEE???????EEEEEEEE
  340|       |  // *new_ctrl= 456E0123EEEEEEEE456E0123EEEEEEE
  341|       |  // position                  S/
  342|      6|  ctrl_t g[kHalfWidth];
  343|      6|  std::memcpy(g, new_ctrl, kHalfWidth);
  344|      6|  std::memcpy(new_ctrl + new_capacity + 1, g, kHalfWidth);
  345|       |
  346|       |  // Finally set sentinel to its place.
  347|      6|  new_ctrl[new_capacity] = ctrl_t::kSentinel;
  348|      6|}
_ZNK4absl12lts_2024011618container_internal19HashSetResizeHelper43GrowIntoSingleGroupShuffleTransferableSlotsEPvS3_m:
  351|      6|    void* old_slots, void* new_slots, size_t slot_size) const {
  352|      6|  assert(old_capacity_ > 0);
  353|      6|  const size_t half_old_capacity = old_capacity_ / 2;
  354|       |
  355|      6|  SanitizerUnpoisonMemoryRegion(old_slots, slot_size * old_capacity_);
  356|      6|  std::memcpy(new_slots,
  357|      6|              SlotAddress(old_slots, half_old_capacity + 1, slot_size),
  358|      6|              slot_size * half_old_capacity);
  359|      6|  std::memcpy(SlotAddress(new_slots, half_old_capacity + 1, slot_size),
  360|      6|              old_slots, slot_size * (half_old_capacity + 1));
  361|      6|}
_ZN4absl12lts_2024011618container_internal19HashSetResizeHelper35GrowSizeIntoSingleGroupTransferableERNS1_12CommonFieldsEPvm:
  364|      6|    CommonFields& c, void* old_slots, size_t slot_size) {
  365|      6|  assert(old_capacity_ < Group::kWidth / 2);
  366|      6|  assert(is_single_group(c.capacity()));
  367|      6|  assert(IsGrowingIntoSingleGroupApplicable(old_capacity_, c.capacity()));
  368|       |
  369|      6|  GrowIntoSingleGroupShuffleControlBytes(c.control(), c.capacity());
  370|      6|  GrowIntoSingleGroupShuffleTransferableSlots(old_slots, c.slot_array(),
  371|      6|                                              slot_size);
  372|       |
  373|       |  // We poison since GrowIntoSingleGroupShuffleTransferableSlots
  374|       |  // may leave empty slots unpoisoned.
  375|      6|  PoisonSingleGroupEmptySlots(c, slot_size);
  376|      6|}

_ZN4absl12lts_2024011618container_internal12CommonFieldsC2Ev:
 1028|      2|  CommonFields() = default;
_ZN4absl12lts_2024011618container_internal10EmptyGroupEv:
  521|      2|inline ctrl_t* EmptyGroup() {
  522|       |  // Const must be cast away here; no uses of this function will actually write
  523|       |  // to it, because it is only used for empty tables.
  524|      2|  return const_cast<ctrl_t*>(kEmptyGroup + 16);
  525|      2|}
_ZN4absl12lts_2024011618container_internal5probeERKNS1_12CommonFieldsEm:
 1420|     60|inline probe_seq<Group::kWidth> probe(const CommonFields& common, size_t hash) {
 1421|     60|  return probe(common.control(), common.capacity(), hash);
 1422|     60|}
_ZN4absl12lts_2024011618container_internal5probeEPKNS1_6ctrl_tEmm:
 1417|     60|                                      size_t hash) {
 1418|     60|  return probe_seq<Group::kWidth>(H1(hash, ctrl), capacity);
 1419|     60|}
_ZN4absl12lts_2024011618container_internal2H1EmPKNS1_6ctrl_tE:
  552|     60|inline size_t H1(size_t hash, const ctrl_t* ctrl) {
  553|     60|  return (hash >> 7) ^ PerTableSalt(ctrl);
  554|     60|}
_ZN4absl12lts_2024011618container_internal12PerTableSaltEPKNS1_6ctrl_tE:
  545|     60|inline size_t PerTableSalt(const ctrl_t* ctrl) {
  546|       |  // The low bits of the pointer have little or no entropy because of
  547|       |  // alignment. We shift the pointer to try to use higher entropy bits. A
  548|       |  // good number seems to be 12 bits, because that aligns with page size.
  549|     60|  return reinterpret_cast<uintptr_t>(ctrl) >> 12;
  550|     60|}
_ZN4absl12lts_2024011618container_internal9probe_seqILm16EEC2Emm:
  316|     60|  probe_seq(size_t hash, size_t mask) {
  317|       |    assert(((mask + 1) & mask) == 0 && "not a mask");
  318|     60|    mask_ = mask;
  319|     60|    offset_ = hash & mask_;
  320|     60|  }
_ZNK4absl12lts_2024011618container_internal12CommonFields7controlEv:
 1038|    410|  ctrl_t* control() const { return control_; }
_ZNK4absl12lts_2024011618container_internal12CommonFields8capacityEv:
 1065|    242|  size_t capacity() const { return capacity_; }
_ZNK4absl12lts_2024011618container_internal9probe_seqILm16EE6offsetEv:
  323|     60|  size_t offset() const { return offset_; }
_ZN4absl12lts_2024011618container_internal13GroupSse2ImplC2EPKNS1_6ctrl_tE:
  615|     54|  explicit GroupSse2Impl(const ctrl_t* pos) {
  616|     54|    ctrl = _mm_loadu_si128(reinterpret_cast<const __m128i*>(pos));
  617|     54|  }
_ZNK4absl12lts_2024011618container_internal13GroupSse2Impl5MatchEh:
  620|     26|  BitMask<uint16_t, kWidth> Match(h2_t hash) const {
  621|     26|    auto match = _mm_set1_epi8(static_cast<char>(hash));
  622|     26|    BitMask<uint16_t, kWidth> result = BitMask<uint16_t, kWidth>(0);
  623|     26|    result = BitMask<uint16_t, kWidth>(
  624|     26|        static_cast<uint16_t>(_mm_movemask_epi8(_mm_cmpeq_epi8(match, ctrl))));
  625|     26|    return result;
  626|     26|  }
_ZN4absl12lts_2024011618container_internal7BitMaskItLi16ELi0EEC2Et:
  437|     78|  explicit BitMask(T mask) : Base(mask) {}
_ZN4absl12lts_2024011618container_internal18NonIterableBitMaskItLi16ELi0EEC2Et:
  389|    130|  explicit NonIterableBitMask(T mask) : mask_(mask) {}
_ZN4absl12lts_2024011618container_internal2H2Em:
  559|     52|inline h2_t H2(size_t hash) { return hash & 0x7F; }
_ZNK4absl12lts_2024011618container_internal7BitMaskItLi16ELi0EE5beginEv:
  454|     26|  BitMask begin() const { return *this; }
_ZNK4absl12lts_2024011618container_internal7BitMaskItLi16ELi0EE3endEv:
  455|     26|  BitMask end() const { return BitMask(0); }
_ZN4absl12lts_2024011618container_internalneERKNS1_7BitMaskItLi16ELi0EEES5_:
  461|     27|  friend bool operator!=(const BitMask& a, const BitMask& b) {
  462|     27|    return a.mask_ != b.mask_;
  463|     27|  }
_ZNK4absl12lts_2024011618container_internal7BitMaskItLi16ELi0EEdeEv:
  452|      1|  uint32_t operator*() const { return Base::LowestBitSet(); }
_ZNK4absl12lts_2024011618container_internal18NonIterableBitMaskItLi16ELi0EE12LowestBitSetEv:
  394|     27|  uint32_t LowestBitSet() const {
  395|     27|    return container_internal::TrailingZeros(mask_) >> Shift;
  396|     27|  }
_ZN4absl12lts_2024011618container_internal13TrailingZerosItEEjT_:
  372|     27|uint32_t TrailingZeros(T x) {
  373|     27|  ABSL_ASSUME(x != 0);
  ------------------
  |  |  259|     27|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
  374|     27|  return static_cast<uint32_t>(countr_zero(x));
  375|     27|}
_ZNK4absl12lts_2024011618container_internal12CommonFields10slot_arrayEv:
 1047|    137|  void* slot_array() const { return slots_; }
_ZNK4absl12lts_2024011618container_internal9probe_seqILm16EE6offsetEm:
  324|     27|  size_t offset(size_t i) const { return (offset_ + i) & mask_; }
_ZN4absl12lts_2024011618container_internal7BitMaskItLi16ELi0EEppEv:
  443|      1|  BitMask& operator++() {
  444|      1|    if (Shift == 3) {
  ------------------
  |  Branch (444:9): [Folded, False: 1]
  ------------------
  445|      0|      constexpr uint64_t msbs = 0x8080808080808080ULL;
  446|      0|      this->mask_ &= msbs;
  447|      0|    }
  448|      1|    this->mask_ &= (this->mask_ - 1);
  449|      1|    return *this;
  450|      1|  }
_ZNK4absl12lts_2024011618container_internal13GroupSse2Impl9MaskEmptyEv:
  629|     26|  NonIterableBitMask<uint16_t, kWidth> MaskEmpty() const {
  630|       |#ifdef ABSL_INTERNAL_HAVE_SSSE3
  631|       |    // This only works because ctrl_t::kEmpty is -128.
  632|       |    return NonIterableBitMask<uint16_t, kWidth>(
  633|       |        static_cast<uint16_t>(_mm_movemask_epi8(_mm_sign_epi8(ctrl, ctrl))));
  634|       |#else
  635|     26|    auto match = _mm_set1_epi8(static_cast<char>(ctrl_t::kEmpty));
  636|     26|    return NonIterableBitMask<uint16_t, kWidth>(
  637|     26|        static_cast<uint16_t>(_mm_movemask_epi8(_mm_cmpeq_epi8(match, ctrl))));
  638|     26|#endif
  639|     26|  }
_ZNK4absl12lts_2024011618container_internal18NonIterableBitMaskItLi16ELi0EEcvbEv:
  391|     52|  explicit operator bool() const { return this->mask_ != 0; }
_ZNK4absl12lts_2024011618container_internal12CommonFields41should_rehash_for_bug_detection_on_insertEv:
 1101|     26|  bool should_rehash_for_bug_detection_on_insert() const {
 1102|     26|    return CommonFieldsGenerationInfo::
 1103|     26|        should_rehash_for_bug_detection_on_insert(control(), capacity());
 1104|     26|  }
_ZNK4absl12lts_2024011618container_internal34CommonFieldsGenerationInfoDisabled41should_rehash_for_bug_detection_on_insertEPKNS1_6ctrl_tEm:
  926|     26|  bool should_rehash_for_bug_detection_on_insert(const ctrl_t*, size_t) const {
  927|     26|    return false;
  928|     26|  }
_ZN4absl12lts_2024011618container_internal19HashSetResizeHelperC2ERNS1_12CommonFieldsE:
 1525|      8|      : old_ctrl_(c.control()),
 1526|      8|        old_capacity_(c.capacity()),
 1527|      8|        had_infoz_(c.has_infoz()) {}
_ZNK4absl12lts_2024011618container_internal12CommonFields9has_infozEv:
 1084|     42|  bool has_infoz() const {
 1085|     42|    return ABSL_PREDICT_FALSE((size_ & HasInfozMask()) != 0);
  ------------------
  |  |  178|     42|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:49): [Folded, False: 42]
  |  |  |  Branch (178:58): [True: 0, False: 42]
  |  |  ------------------
  ------------------
 1086|     42|  }
_ZN4absl12lts_2024011618container_internal12CommonFields12HasInfozMaskEv:
 1131|     44|  static constexpr size_t HasInfozMask() {
 1132|     44|    return (size_t{1} << HasInfozShift()) - 1;
 1133|     44|  }
_ZN4absl12lts_2024011618container_internal12CommonFields13HasInfozShiftEv:
 1130|    100|  static constexpr size_t HasInfozShift() { return 1; }
_ZN4absl12lts_2024011618container_internal12CommonFields12set_capacityEm:
 1066|      8|  void set_capacity(size_t c) {
 1067|       |    assert(c == 0 || IsValidCapacity(c));
 1068|      8|    capacity_ = c;
 1069|      8|  }
_ZN4absl12lts_2024011618container_internal12CommonFields5infozEv:
 1091|     34|  HashtablezInfoHandle infoz() {
 1092|     34|    return has_infoz()
  ------------------
  |  Branch (1092:12): [True: 0, False: 34]
  ------------------
 1093|     34|               ? *reinterpret_cast<HashtablezInfoHandle*>(backing_array_start())
 1094|     34|               : HashtablezInfoHandle();
 1095|     34|  }
_ZN4absl12lts_2024011618container_internal9AllocSizeEmmmb:
 1019|     14|                        bool has_infoz) {
 1020|     14|  return SlotOffset(capacity, slot_align, has_infoz) + capacity * slot_size;
 1021|     14|}
_ZNK4absl12lts_2024011618container_internal34CommonFieldsGenerationInfoDisabled10generationEv:
  939|      8|  GenerationType generation() const { return 0; }
_ZN4absl12lts_2024011618container_internal34CommonFieldsGenerationInfoDisabled18set_generation_ptrEPh:
  942|      8|  void set_generation_ptr(GenerationType*) {}
_ZN4absl12lts_2024011618container_internal16GenerationOffsetEmb:
 1001|     30|inline size_t GenerationOffset(size_t capacity, bool has_infoz) {
 1002|       |  assert(IsValidCapacity(capacity));
 1003|     30|  const size_t num_control_bytes = capacity + 1 + NumClonedBytes();
 1004|     30|  return ControlOffset(has_infoz) + num_control_bytes;
 1005|     30|}
_ZN4absl12lts_2024011618container_internal14NumClonedBytesEv:
  997|     86|constexpr size_t NumClonedBytes() { return Group::kWidth - 1; }
_ZN4absl12lts_2024011618container_internal34CommonFieldsGenerationInfoDisabled14set_generationEh:
  940|      8|  void set_generation(GenerationType) {}
_ZN4absl12lts_2024011618container_internal14NextGenerationEh:
  254|      8|constexpr GenerationType NextGeneration(GenerationType generation) {
  255|      8|  return ++generation == SentinelEmptyGeneration() ? ++generation : generation;
  ------------------
  |  Branch (255:10): [True: 0, False: 8]
  ------------------
  256|      8|}
_ZN4absl12lts_2024011618container_internal23SentinelEmptyGenerationEv:
  252|      8|constexpr GenerationType SentinelEmptyGeneration() { return 0; }
_ZN4absl12lts_2024011618container_internal12CommonFields11set_controlEPNS1_6ctrl_tE:
 1039|      8|  void set_control(ctrl_t* c) { control_ = c; }
_ZN4absl12lts_2024011618container_internal13ControlOffsetEb:
  988|     44|inline size_t ControlOffset(bool has_infoz) {
  989|     44|  return (has_infoz ? sizeof(HashtablezInfoHandle) : 0) + sizeof(size_t);
  ------------------
  |  Branch (989:11): [True: 0, False: 44]
  ------------------
  990|     44|}
_ZN4absl12lts_2024011618container_internal12CommonFields9set_slotsEPv:
 1048|      8|  void set_slots(void* s) { slots_ = s; }
_ZN4absl12lts_2024011618container_internal10SlotOffsetEmmb:
 1009|     22|inline size_t SlotOffset(size_t capacity, size_t slot_align, bool has_infoz) {
 1010|       |  assert(IsValidCapacity(capacity));
 1011|     22|  return (GenerationOffset(capacity, has_infoz) + NumGenerationBytes() +
 1012|     22|          slot_align - 1) &
 1013|     22|         (~slot_align + 1);
 1014|     22|}
_ZN4absl12lts_2024011618container_internal18NumGenerationBytesEv:
  263|     22|constexpr size_t NumGenerationBytes() { return 0; }
_ZN4absl12lts_2024011618container_internal15ResetGrowthLeftERNS1_12CommonFieldsE:
 1464|     10|inline void ResetGrowthLeft(CommonFields& common) {
 1465|     10|  common.set_growth_left(CapacityToGrowth(common.capacity()) - common.size());
 1466|     10|}
_ZN4absl12lts_2024011618container_internal12CommonFields15set_growth_leftEm:
 1078|     36|  void set_growth_left(size_t gl) {
 1079|     36|    size_t* gl_ptr = reinterpret_cast<size_t*>(control()) - 1;
 1080|       |    assert(reinterpret_cast<uintptr_t>(gl_ptr) % alignof(size_t) == 0);
 1081|     36|    *gl_ptr = gl;
 1082|     36|  }
_ZN4absl12lts_2024011618container_internal16CapacityToGrowthEm:
 1197|     10|inline size_t CapacityToGrowth(size_t capacity) {
 1198|     10|  assert(IsValidCapacity(capacity));
 1199|       |  // `capacity*7/8`
 1200|     10|  if (Group::kWidth == 8 && capacity == 7) {
  ------------------
  |  Branch (1200:7): [Folded, False: 10]
  |  Branch (1200:29): [True: 0, False: 0]
  ------------------
 1201|       |    // x-x/8 does not work when x==7.
 1202|      0|    return 6;
 1203|      0|  }
 1204|     10|  return capacity - capacity / 8;
 1205|     10|}
_ZN4absl12lts_2024011618container_internal19HashSetResizeHelper34IsGrowingIntoSingleGroupApplicableEmm:
 1686|     16|                                                 size_t new_capacity) {
 1687|       |    // NOTE that `old_capacity < new_capacity` in order to have
 1688|       |    // `old_capacity < Group::kWidth / 2` to make faster copies of 8 bytes.
 1689|     16|    return is_single_group(new_capacity) && old_capacity < new_capacity;
  ------------------
  |  Branch (1689:12): [True: 16, False: 0]
  |  Branch (1689:45): [True: 16, False: 0]
  ------------------
 1690|     16|  }
_ZN4absl12lts_2024011618container_internal15is_single_groupEm:
 1411|     16|inline bool is_single_group(size_t capacity) {
 1412|     16|  return capacity <= Group::kWidth;
 1413|     16|}
_ZN4absl12lts_2024011618container_internal9ResetCtrlERNS1_12CommonFieldsEm:
 1470|      4|inline void ResetCtrl(CommonFields& common, size_t slot_size) {
 1471|      4|  const size_t capacity = common.capacity();
 1472|      4|  ctrl_t* ctrl = common.control();
 1473|      4|  std::memset(ctrl, static_cast<int8_t>(ctrl_t::kEmpty),
 1474|      4|              capacity + 1 + NumClonedBytes());
 1475|      4|  ctrl[capacity] = ctrl_t::kSentinel;
 1476|      4|  SanitizerPoisonMemoryRegion(common.slot_array(), slot_size * capacity);
 1477|      4|}
_ZN4absl12lts_2024011618container_internal12CommonFields13set_has_infozEb:
 1087|      8|  void set_has_infoz(bool has_infoz) {
 1088|      8|    size_ = (size() << HasInfozShift()) | static_cast<size_t>(has_infoz);
 1089|      8|  }
_ZNK4absl12lts_2024011618container_internal12CommonFields4sizeEv:
 1051|     20|  size_t size() const { return size_ >> HasInfozShift(); }
_ZNK4absl12lts_2024011618container_internal19HashSetResizeHelper12old_capacityEv:
 1557|      8|  size_t old_capacity() const { return old_capacity_; }
_ZNK4absl12lts_2024011618container_internal19HashSetResizeHelper27PoisonSingleGroupEmptySlotsERNS1_12CommonFieldsEm:
 1753|      6|  void PoisonSingleGroupEmptySlots(CommonFields& c, size_t slot_size) const {
 1754|       |    // poison non full items
 1755|     56|    for (size_t i = 0; i < c.capacity(); ++i) {
  ------------------
  |  Branch (1755:24): [True: 50, False: 6]
  ------------------
 1756|     50|      if (!IsFull(c.control()[i])) {
  ------------------
  |  Branch (1756:11): [True: 28, False: 22]
  ------------------
 1757|     28|        SanitizerPoisonMemoryRegion(SlotAddress(c.slot_array(), i, slot_size),
 1758|     28|                                    slot_size);
 1759|     28|      }
 1760|     50|    }
 1761|      6|  }
_ZN4absl12lts_2024011618container_internal11SlotAddressEPvmm:
 1513|     40|inline void* SlotAddress(void* slot_array, size_t slot, size_t slot_size) {
 1514|     40|  return reinterpret_cast<void*>(reinterpret_cast<char*>(slot_array) +
 1515|     40|                                 (slot * slot_size));
 1516|     40|}
_ZN4absl12lts_2024011618container_internal6IsFullENS1_6ctrl_tE:
  563|    106|inline bool IsFull(ctrl_t c) { return c >= static_cast<ctrl_t>(0); }
_ZN4absl12lts_2024011618container_internal19HashSetResizeHelper13DeallocateOldILm8ENSt3__19allocatorIcEEEEvT0_mPv:
 1676|      6|  void DeallocateOld(CharAlloc alloc_ref, size_t slot_size, void* old_slots) {
 1677|      6|    SanitizerUnpoisonMemoryRegion(old_slots, slot_size * old_capacity_);
 1678|      6|    Deallocate<BackingArrayAlignment(AlignOfSlot)>(
 1679|      6|        &alloc_ref, old_ctrl_ - ControlOffset(had_infoz_),
 1680|      6|        AllocSize(old_capacity_, slot_size, AlignOfSlot, had_infoz_));
 1681|      6|  }
_ZNK4absl12lts_2024011618container_internal12CommonFields11growth_leftEv:
 1073|     52|  size_t growth_left() const {
 1074|     52|    const size_t* gl_ptr = reinterpret_cast<size_t*>(control()) - 1;
 1075|       |    assert(reinterpret_cast<uintptr_t>(gl_ptr) % alignof(size_t) == 0);
 1076|     52|    return *gl_ptr;
 1077|     52|  }
_ZN4absl12lts_2024011618container_internal12NextCapacityEm:
 1167|      8|inline size_t NextCapacity(size_t n) {
 1168|       |  assert(IsValidCapacity(n) || n == 0);
 1169|      8|  return n * 2 + 1;
 1170|      8|}
_ZN4absl12lts_2024011618container_internal19find_first_non_fullIvEENS1_8FindInfoERKNS1_12CommonFieldsEm:
 1432|     26|inline FindInfo find_first_non_full(const CommonFields& common, size_t hash) {
 1433|     26|  auto seq = probe(common, hash);
 1434|     26|  const ctrl_t* ctrl = common.control();
 1435|     26|  while (true) {
  ------------------
  |  Branch (1435:10): [True: 26, Folded]
  ------------------
 1436|     26|    GroupEmptyOrDeleted g{ctrl + seq.offset()};
 1437|     26|    auto mask = g.MaskEmptyOrDeleted();
 1438|     26|    if (mask) {
  ------------------
  |  Branch (1438:9): [True: 26, False: 0]
  ------------------
 1439|       |#if !defined(NDEBUG)
 1440|       |      // We want to add entropy even when ASLR is not enabled.
 1441|       |      // In debug build we will randomly insert in either the front or back of
 1442|       |      // the group.
 1443|       |      // TODO(kfm,sbenza): revisit after we do unconditional mixing
 1444|       |      if (!is_small(common.capacity()) && ShouldInsertBackwards(hash, ctrl)) {
 1445|       |        return {seq.offset(mask.HighestBitSet()), seq.index()};
 1446|       |      }
 1447|       |#endif
 1448|     26|      return {seq.offset(mask.LowestBitSet()), seq.index()};
 1449|     26|    }
 1450|      0|    seq.next();
 1451|       |    assert(seq.index() <= common.capacity() && "full table!");
 1452|      0|  }
 1453|     26|}
_ZNK4absl12lts_2024011618container_internal13GroupSse2Impl18MaskEmptyOrDeletedEv:
  650|     26|  NonIterableBitMask<uint16_t, kWidth> MaskEmptyOrDeleted() const {
  651|     26|    auto special = _mm_set1_epi8(static_cast<char>(ctrl_t::kSentinel));
  652|     26|    return NonIterableBitMask<uint16_t, kWidth>(static_cast<uint16_t>(
  653|     26|        _mm_movemask_epi8(_mm_cmpgt_epi8_fixed(special, ctrl))));
  654|     26|  }
_ZN4absl12lts_2024011618container_internal20_mm_cmpgt_epi8_fixedEDv2_xS2_:
  601|     28|inline __m128i _mm_cmpgt_epi8_fixed(__m128i a, __m128i b) {
  602|       |#if defined(__GNUC__) && !defined(__clang__)
  603|       |  if (std::is_unsigned<char>::value) {
  604|       |    const __m128i mask = _mm_set1_epi8(0x80);
  605|       |    const __m128i diff = _mm_subs_epi8(b, a);
  606|       |    return _mm_cmpeq_epi8(_mm_and_si128(diff, mask), mask);
  607|       |  }
  608|       |#endif
  609|     28|  return _mm_cmpgt_epi8(a, b);
  610|     28|}
_ZNK4absl12lts_2024011618container_internal9probe_seqILm16EE5indexEv:
  332|     26|  size_t index() const { return index_; }
_ZN4absl12lts_2024011618container_internal9IsDeletedENS1_6ctrl_tE:
  564|      8|inline bool IsDeleted(ctrl_t c) { return c == ctrl_t::kDeleted; }
_ZN4absl12lts_2024011618container_internal19HashSetResizeHelper27FindFirstNonFullAfterResizeERKNS1_12CommonFieldsEmm:
 1537|      8|                                              size_t hash) {
 1538|      8|    if (!IsGrowingIntoSingleGroupApplicable(old_capacity, c.capacity())) {
  ------------------
  |  Branch (1538:9): [True: 0, False: 8]
  ------------------
 1539|      0|      return find_first_non_full(c, hash);
 1540|      0|    }
 1541|       |    // Find a location for the new element non-deterministically.
 1542|       |    // Note that any position is correct.
 1543|       |    // It will located at `half_old_capacity` or one of the other
 1544|       |    // empty slots with approximately 50% probability each.
 1545|      8|    size_t offset = probe(c, hash).offset();
 1546|       |
 1547|       |    // Note that we intentionally use unsigned int underflow.
 1548|      8|    if (offset - (old_capacity + 1) >= old_capacity) {
  ------------------
  |  Branch (1548:9): [True: 8, False: 0]
  ------------------
 1549|       |      // Offset fall on kSentinel or into the mostly occupied first half.
 1550|      8|      offset = old_capacity / 2;
 1551|      8|    }
 1552|       |    assert(IsEmpty(c.control()[offset]));
 1553|      8|    return FindInfo{offset, 0};
 1554|      8|  }
_ZN4absl12lts_2024011618container_internal12CommonFields14increment_sizeEv:
 1055|     26|  void increment_size() {
 1056|       |    assert(size() < capacity());
 1057|     26|    size_ += size_t{1} << HasInfozShift();
 1058|     26|  }
_ZN4absl12lts_2024011618container_internal7IsEmptyENS1_6ctrl_tE:
  562|     26|inline bool IsEmpty(ctrl_t c) { return c == ctrl_t::kEmpty; }
_ZN4absl12lts_2024011618container_internal7SetCtrlERKNS1_12CommonFieldsEmhm:
 1502|     26|                    size_t slot_size) {
 1503|     26|  SetCtrl(common, i, static_cast<ctrl_t>(h), slot_size);
 1504|     26|}
_ZN4absl12lts_2024011618container_internal7SetCtrlERKNS1_12CommonFieldsEmNS1_6ctrl_tEm:
 1484|     26|                    size_t slot_size) {
 1485|     26|  const size_t capacity = common.capacity();
 1486|     26|  assert(i < capacity);
 1487|       |
 1488|     26|  auto* slot_i = static_cast<const char*>(common.slot_array()) + i * slot_size;
 1489|     26|  if (IsFull(h)) {
  ------------------
  |  Branch (1489:7): [True: 26, False: 0]
  ------------------
 1490|     26|    SanitizerUnpoisonMemoryRegion(slot_i, slot_size);
 1491|     26|  } else {
 1492|      0|    SanitizerPoisonMemoryRegion(slot_i, slot_size);
 1493|      0|  }
 1494|       |
 1495|     26|  ctrl_t* ctrl = common.control();
 1496|     26|  ctrl[i] = h;
 1497|     26|  ctrl[((i - NumClonedBytes()) & capacity) + (NumClonedBytes() & capacity)] = h;
 1498|     26|}
_ZN4absl12lts_2024011618container_internal34CommonFieldsGenerationInfoDisabled36maybe_increment_generation_on_insertEv:
  932|     26|  void maybe_increment_generation_on_insert() {}
_ZNK4absl12lts_2024011618container_internal34CommonFieldsGenerationInfoDisabled14generation_ptrEv:
  941|     30|  GenerationType* generation_ptr() const { return nullptr; }
_ZN4absl12lts_2024011618container_internal37HashSetIteratorGenerationInfoDisabledC2EPKh:
  965|     30|  explicit HashSetIteratorGenerationInfoDisabled(const GenerationType*) {}
_ZN4absl12lts_2024011618container_internal16IsEmptyOrDeletedENS1_6ctrl_tE:
  565|     30|inline bool IsEmptyOrDeleted(ctrl_t c) { return c < ctrl_t::kSentinel; }
_ZNK4absl12lts_2024011618container_internal13GroupSse2Impl26CountLeadingEmptyOrDeletedEv:
  657|      2|  uint32_t CountLeadingEmptyOrDeleted() const {
  658|      2|    auto special = _mm_set1_epi8(static_cast<char>(ctrl_t::kSentinel));
  659|      2|    return TrailingZeros(static_cast<uint32_t>(
  660|      2|        _mm_movemask_epi8(_mm_cmpgt_epi8_fixed(special, ctrl)) + 1));
  661|      2|  }
_ZN4absl12lts_2024011618container_internal13TrailingZerosIjEEjT_:
  372|      2|uint32_t TrailingZeros(T x) {
  373|      2|  ABSL_ASSUME(x != 0);
  ------------------
  |  |  259|      2|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
  374|      2|  return static_cast<uint32_t>(countr_zero(x));
  375|      2|}
_ZN4absl12lts_2024011618container_internal26AssertIsValidForComparisonEPKNS1_6ctrl_tEhPKh:
 1290|     56|                                       const GenerationType* generation_ptr) {
 1291|     56|  if (!SwisstableDebugEnabled()) return;
  ------------------
  |  Branch (1291:7): [True: 56, Folded]
  ------------------
 1292|      0|  const bool ctrl_is_valid_for_comparison =
 1293|      0|      ctrl == nullptr || ctrl == EmptyGroup() || IsFull(*ctrl);
  ------------------
  |  Branch (1293:7): [True: 0, False: 0]
  |  Branch (1293:26): [True: 0, False: 0]
  |  Branch (1293:50): [True: 0, False: 0]
  ------------------
 1294|      0|  if (SwisstableGenerationsEnabled()) {
  ------------------
  |  Branch (1294:7): [Folded, False: 0]
  ------------------
 1295|      0|    if (ABSL_PREDICT_FALSE(generation != *generation_ptr)) {
  ------------------
  |  |  178|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 0]
  |  |  |  Branch (178:49): [Folded, False: 0]
  |  |  |  Branch (178:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1296|      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()
  |  |  |  |  ------------------
  |  |  |  |  |  |  225|      0|  do {                                           \
  |  |  |  |  |  |  226|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  227|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  228|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  203|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  229|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (229:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1297|      0|                   "Invalid iterator comparison. The table could have rehashed "
 1298|      0|                   "or moved since this iterator was initialized.");
 1299|      0|    }
 1300|      0|    if (ABSL_PREDICT_FALSE(!ctrl_is_valid_for_comparison)) {
  ------------------
  |  |  178|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 0]
  |  |  |  Branch (178:49): [Folded, False: 0]
  |  |  |  Branch (178:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1301|      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()
  |  |  |  |  ------------------
  |  |  |  |  |  |  225|      0|  do {                                           \
  |  |  |  |  |  |  226|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  227|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  228|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  203|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  229|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (229:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1302|      0|          FATAL, "Invalid iterator comparison. The element was likely erased.");
 1303|      0|    }
 1304|      0|  } else {
 1305|      0|    ABSL_HARDENING_ASSERT(
  ------------------
  |  |  128|      0|#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |   95|      0|  (false ? static_cast<void>(expr) : static_cast<void>(0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (95:4): [Folded, False: 0]
  |  |  |  |  |  Branch (95:30): [True: 0, False: 0]
  |  |  |  |  |  Branch (95:30): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1306|      0|        ctrl_is_valid_for_comparison &&
 1307|      0|        "Invalid iterator comparison. The element might have been erased or "
 1308|      0|        "the table might have rehashed. Consider running with --config=asan to "
 1309|      0|        "diagnose rehashing issues.");
 1310|      0|  }
 1311|      0|}
_ZNK4absl12lts_2024011618container_internal37HashSetIteratorGenerationInfoDisabled10generationEv:
  967|    108|  GenerationType generation() const { return 0; }
_ZNK4absl12lts_2024011618container_internal37HashSetIteratorGenerationInfoDisabled14generation_ptrEv:
  969|    164|  const GenerationType* generation_ptr() const { return nullptr; }
_ZN4absl12lts_2024011618container_internal19AssertSameContainerEPKNS1_6ctrl_tES4_RKPKvS8_PKhSA_:
 1339|     28|                                const GenerationType* generation_ptr_b) {
 1340|     28|  if (!SwisstableDebugEnabled()) return;
  ------------------
  |  Branch (1340:7): [True: 28, Folded]
  ------------------
 1341|       |  // `SwisstableDebugEnabled()` is also true for release builds with hardening
 1342|       |  // enabled. To minimize their impact in those builds:
 1343|       |  // - use `ABSL_PREDICT_FALSE()` to provide a compiler hint for code layout
 1344|       |  // - use `ABSL_RAW_LOG()` with a format string to reduce code size and improve
 1345|       |  //   the chances that the hot paths will be inlined.
 1346|      0|  const bool a_is_default = ctrl_a == EmptyGroup();
 1347|      0|  const bool b_is_default = ctrl_b == EmptyGroup();
 1348|      0|  if (ABSL_PREDICT_FALSE(a_is_default != b_is_default)) {
  ------------------
  |  |  178|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 0]
  |  |  |  Branch (178:49): [Folded, False: 0]
  |  |  |  Branch (178:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1349|      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()
  |  |  |  |  ------------------
  |  |  |  |  |  |  225|      0|  do {                                           \
  |  |  |  |  |  |  226|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  227|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  228|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  203|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  229|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (229:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1350|      0|        FATAL,
 1351|      0|        "Invalid iterator comparison. Comparing default-constructed iterator "
 1352|      0|        "with non-default-constructed iterator.");
 1353|      0|  }
 1354|      0|  if (a_is_default && b_is_default) return;
  ------------------
  |  Branch (1354:7): [True: 0, False: 0]
  |  Branch (1354:23): [True: 0, False: 0]
  ------------------
 1355|       |
 1356|      0|  if (SwisstableGenerationsEnabled()) {
  ------------------
  |  Branch (1356:7): [Folded, False: 0]
  ------------------
 1357|      0|    if (ABSL_PREDICT_TRUE(generation_ptr_a == generation_ptr_b)) return;
  ------------------
  |  |  179|      0|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (179:30): [True: 0, False: 0]
  |  |  |  Branch (179:48): [Folded, False: 0]
  |  |  |  Branch (179:57): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1358|      0|    const bool a_is_empty = IsEmptyGeneration(generation_ptr_a);
 1359|      0|    const bool b_is_empty = IsEmptyGeneration(generation_ptr_b);
 1360|      0|    if (a_is_empty != b_is_empty) {
  ------------------
  |  Branch (1360:9): [True: 0, False: 0]
  ------------------
 1361|      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()
  |  |  |  |  ------------------
  |  |  |  |  |  |  225|      0|  do {                                           \
  |  |  |  |  |  |  226|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  227|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  228|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  203|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  229|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (229:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1362|      0|                   "Invalid iterator comparison. Comparing iterator from a "
 1363|      0|                   "non-empty hashtable with an iterator from an empty "
 1364|      0|                   "hashtable.");
 1365|      0|    }
 1366|      0|    if (a_is_empty && b_is_empty) {
  ------------------
  |  Branch (1366:9): [True: 0, False: 0]
  |  Branch (1366:23): [True: 0, False: 0]
  ------------------
 1367|      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()
  |  |  |  |  ------------------
  |  |  |  |  |  |  225|      0|  do {                                           \
  |  |  |  |  |  |  226|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  227|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  228|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  203|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  229|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (229:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1368|      0|                   "Invalid iterator comparison. Comparing iterators from "
 1369|      0|                   "different empty hashtables.");
 1370|      0|    }
 1371|      0|    const bool a_is_end = ctrl_a == nullptr;
 1372|      0|    const bool b_is_end = ctrl_b == nullptr;
 1373|      0|    if (a_is_end || b_is_end) {
  ------------------
  |  Branch (1373:9): [True: 0, False: 0]
  |  Branch (1373:21): [True: 0, False: 0]
  ------------------
 1374|      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()
  |  |  |  |  ------------------
  |  |  |  |  |  |  225|      0|  do {                                           \
  |  |  |  |  |  |  226|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  227|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  228|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  203|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  229|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (229:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1375|      0|                   "Invalid iterator comparison. Comparing iterator with an "
 1376|      0|                   "end() iterator from a different hashtable.");
 1377|      0|    }
 1378|      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()
  |  |  |  |  ------------------
  |  |  |  |  |  |  225|      0|  do {                                           \
  |  |  |  |  |  |  226|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  227|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  228|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  203|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  229|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (229:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1379|      0|                 "Invalid iterator comparison. Comparing non-end() iterators "
 1380|      0|                 "from different hashtables.");
 1381|      0|  } else {
 1382|      0|    ABSL_HARDENING_ASSERT(
  ------------------
  |  |  128|      0|#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |   95|      0|  (false ? static_cast<void>(expr) : static_cast<void>(0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (95:4): [Folded, False: 0]
  |  |  |  |  |  Branch (95:30): [True: 0, False: 0]
  |  |  |  |  |  Branch (95:30): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1383|      0|        AreItersFromSameContainer(ctrl_a, ctrl_b, slot_a, slot_b) &&
 1384|      0|        "Invalid iterator comparison. The iterators may be from different "
 1385|      0|        "containers or the container might have rehashed or moved. Consider "
 1386|      0|        "running with --config=asan to diagnose issues.");
 1387|      0|  }
 1388|      0|}
_ZN4absl12lts_2024011618container_internal12AssertIsFullEPKNS1_6ctrl_tEhPKhPKc:
 1248|     52|                         const char* operation) {
 1249|     52|  if (!SwisstableDebugEnabled()) return;
  ------------------
  |  Branch (1249:7): [True: 52, Folded]
  ------------------
 1250|       |  // `SwisstableDebugEnabled()` is also true for release builds with hardening
 1251|       |  // enabled. To minimize their impact in those builds:
 1252|       |  // - use `ABSL_PREDICT_FALSE()` to provide a compiler hint for code layout
 1253|       |  // - use `ABSL_RAW_LOG()` with a format string to reduce code size and improve
 1254|       |  //   the chances that the hot paths will be inlined.
 1255|      0|  if (ABSL_PREDICT_FALSE(ctrl == nullptr)) {
  ------------------
  |  |  178|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 0]
  |  |  |  Branch (178:49): [Folded, False: 0]
  |  |  |  Branch (178:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1256|      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()
  |  |  |  |  ------------------
  |  |  |  |  |  |  225|      0|  do {                                           \
  |  |  |  |  |  |  226|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  227|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  228|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  203|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  229|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (229:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1257|      0|  }
 1258|      0|  if (ABSL_PREDICT_FALSE(ctrl == EmptyGroup())) {
  ------------------
  |  |  178|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 0]
  |  |  |  Branch (178:49): [Folded, False: 0]
  |  |  |  Branch (178:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1259|      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()
  |  |  |  |  ------------------
  |  |  |  |  |  |  225|      0|  do {                                           \
  |  |  |  |  |  |  226|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  227|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  228|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  203|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  229|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (229:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1260|      0|                 operation);
 1261|      0|  }
 1262|      0|  if (SwisstableGenerationsEnabled()) {
  ------------------
  |  Branch (1262:7): [Folded, False: 0]
  ------------------
 1263|      0|    if (ABSL_PREDICT_FALSE(generation != *generation_ptr)) {
  ------------------
  |  |  178|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 0]
  |  |  |  Branch (178:49): [Folded, False: 0]
  |  |  |  Branch (178:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1264|      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()
  |  |  |  |  ------------------
  |  |  |  |  |  |  225|      0|  do {                                           \
  |  |  |  |  |  |  226|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  227|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  228|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  203|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  229|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (229:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1265|      0|                   "%s called on invalid iterator. The table could have "
 1266|      0|                   "rehashed or moved since this iterator was initialized.",
 1267|      0|                   operation);
 1268|      0|    }
 1269|      0|    if (ABSL_PREDICT_FALSE(!IsFull(*ctrl))) {
  ------------------
  |  |  178|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 0]
  |  |  |  Branch (178:49): [Folded, False: 0]
  |  |  |  Branch (178:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1270|      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()
  |  |  |  |  ------------------
  |  |  |  |  |  |  225|      0|  do {                                           \
  |  |  |  |  |  |  226|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  227|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  228|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  203|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  229|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (229:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1271|      0|          FATAL,
 1272|      0|          "%s called on invalid iterator. The element was likely erased.",
 1273|      0|          operation);
 1274|      0|    }
 1275|      0|  } else {
 1276|      0|    if (ABSL_PREDICT_FALSE(!IsFull(*ctrl))) {
  ------------------
  |  |  178|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 0]
  |  |  |  Branch (178:49): [Folded, False: 0]
  |  |  |  Branch (178:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1277|       |      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()
  |  |  |  |  ------------------
  |  |  |  |  |  |  225|      0|  do {                                           \
  |  |  |  |  |  |  226|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  227|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  228|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  203|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  229|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (229:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1278|      0|          FATAL,
 1279|      0|          "%s called on invalid iterator. The element might have been erased "
 1280|      0|          "or the table might have rehashed. Consider running with "
 1281|      0|          "--config=asan to diagnose rehashing issues.",
 1282|      0|          operation);
 1283|      0|    }
 1284|      0|  }
 1285|      0|}
_ZN4absl12lts_2024011618container_internal34CommonFieldsGenerationInfoDisabled19set_reserved_growthEm:
  936|      2|  void set_reserved_growth(size_t) {}
_ZN4absl12lts_2024011618container_internal34CommonFieldsGenerationInfoDisabled20set_reservation_sizeEm:
  938|      2|  void set_reservation_size(size_t) {}
_ZN4absl12lts_2024011618container_internal12CommonFields8set_sizeEm:
 1052|      2|  void set_size(size_t s) {
 1053|      2|    size_ = (s << HasInfozShift()) | (size_ & HasInfozMask());
 1054|      2|  }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE5beginEv:
 2266|      2|  iterator begin() ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2267|      2|    auto it = iterator_at(0);
 2268|      2|    it.skip_empty_or_deleted();
 2269|      2|    return it;
 2270|      2|  }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE11iterator_atEm:
 3159|     28|  iterator iterator_at(size_t i) ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3160|     28|    return {control() + i, slot_array() + i, common().generation_ptr()};
 3161|     28|  }
_ZNK4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE7controlEv:
 3196|    116|  ctrl_t* control() const { return common().control(); }
_ZNK4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE6commonEv:
 3194|    255|  const CommonFields& common() const { return settings_.template get<0>(); }
_ZNK4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE10slot_arrayEv:
 3197|     65|  slot_type* slot_array() const {
 3198|     65|    return static_cast<slot_type*>(common().slot_array());
 3199|     65|  }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE6commonEv:
 3193|    276|  CommonFields& common() { return settings_.template get<0>(); }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE8iteratorC2EPNS1_6ctrl_tEPNS1_13map_slot_typeIS8_SA_EEPKh:
 1984|     28|        : HashSetIteratorGenerationInfo(generation_ptr),
 1985|     28|          ctrl_(ctrl),
 1986|     28|          slot_(slot) {
 1987|       |      // This assumption helps the compiler know that any non-end iterator is
 1988|       |      // not equal to any end iterator.
 1989|     28|      ABSL_ASSUME(ctrl != nullptr);
  ------------------
  |  |  259|     28|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1990|     28|    }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE8iterator21skip_empty_or_deletedEv:
 1999|     28|    void skip_empty_or_deleted() {
 2000|     30|      while (IsEmptyOrDeleted(*ctrl_)) {
  ------------------
  |  Branch (2000:14): [True: 2, False: 28]
  ------------------
 2001|      2|        uint32_t shift =
 2002|      2|            GroupEmptyOrDeleted{ctrl_}.CountLeadingEmptyOrDeleted();
 2003|      2|        ctrl_ += shift;
 2004|      2|        slot_ += shift;
 2005|      2|      }
 2006|     28|      if (ABSL_PREDICT_FALSE(*ctrl_ == ctrl_t::kSentinel)) ctrl_ = nullptr;
  ------------------
  |  |  178|     28|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 2, False: 26]
  |  |  |  Branch (178:49): [Folded, False: 28]
  |  |  |  Branch (178:58): [True: 2, False: 26]
  |  |  ------------------
  ------------------
 2007|     28|    }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE3endEv:
 2271|      2|  iterator end() ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2272|      2|    return iterator(common().generation_ptr());
 2273|      2|  }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE8iteratorC2EPKh:
 1993|      2|        : HashSetIteratorGenerationInfo(generation_ptr), ctrl_(nullptr) {}
_ZN4absl12lts_2024011618container_internalneERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE8iteratorESM_:
 1977|     28|    friend bool operator!=(const iterator& a, const iterator& b) {
 1978|     28|      return !(a == b);
 1979|     28|    }
_ZN4absl12lts_2024011618container_internaleqERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE8iteratorESM_:
 1970|     28|    friend bool operator==(const iterator& a, const iterator& b) {
 1971|     28|      AssertIsValidForComparison(a.ctrl_, a.generation(), a.generation_ptr());
 1972|     28|      AssertIsValidForComparison(b.ctrl_, b.generation(), b.generation_ptr());
 1973|     28|      AssertSameContainer(a.ctrl_, b.ctrl_, a.slot_, b.slot_,
 1974|     28|                          a.generation_ptr(), b.generation_ptr());
 1975|     28|      return a.ctrl_ == b.ctrl_;
 1976|     28|    }
_ZNK4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE8iteratordeEv:
 1944|     26|    reference operator*() const {
 1945|     26|      AssertIsFull(ctrl_, generation(), generation_ptr(), "operator*()");
 1946|     26|      return unchecked_deref();
 1947|     26|    }
_ZNK4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE8iterator15unchecked_derefEv:
 2029|     26|    reference unchecked_deref() const { return PolicyTraits::element(slot_); }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE8iteratorppEv:
 1956|     26|    iterator& operator++() {
 1957|     26|      AssertIsFull(ctrl_, generation(), generation_ptr(), "operator++");
 1958|     26|      ++ctrl_;
 1959|     26|      ++slot_;
 1960|     26|      skip_empty_or_deleted();
 1961|     26|      return *this;
 1962|     26|    }
_ZNK4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE8capacityEv:
 2288|     20|  size_t capacity() const { return common().capacity(); }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE13destroy_slotsEv:
 2861|      2|  inline void destroy_slots() {
 2862|      2|    const size_t cap = capacity();
 2863|      2|    const ctrl_t* ctrl = control();
 2864|      2|    slot_type* slot = slot_array();
 2865|     32|    for (size_t i = 0; i != cap; ++i) {
  ------------------
  |  Branch (2865:24): [True: 30, False: 2]
  ------------------
 2866|     30|      if (IsFull(ctrl[i])) {
  ------------------
  |  Branch (2866:11): [True: 26, False: 4]
  ------------------
 2867|     26|        destroy(slot + i);
 2868|     26|      }
 2869|     30|    }
 2870|      2|  }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE7destroyEPNS1_13map_slot_typeIS8_SA_EE:
 2854|     26|  inline void destroy(slot_type* slot) {
 2855|     26|    PolicyTraits::destroy(&alloc_ref(), slot);
 2856|     26|  }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE9alloc_refEv:
 3206|     60|  allocator_type& alloc_ref() { return settings_.template get<3>(); }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE5infozEv:
 3200|     26|  HashtablezInfoHandle infoz() { return common().infoz(); }
_ZNK4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE19prefetch_heap_blockEv:
 3187|     26|  void prefetch_heap_block() const {
 3188|     26|#if ABSL_HAVE_BUILTIN(__builtin_prefetch) || defined(__GNUC__)
 3189|     26|    __builtin_prefetch(control(), 0, 1);
 3190|     26|#endif
 3191|     26|  }
_ZNK4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE12EqualElementIS8_EclIS8_JRKNS4_21piecewise_construct_tENS4_5tupleIJRSG_EEENSQ_IJRKSA_EEEEEEbRKT_DpOT0_:
 2813|      1|    bool operator()(const K2& lhs, Args&&...) const {
 2814|      1|      return eq(lhs, rhs);
 2815|      1|    }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE6eq_refEv:
 3204|      1|  key_equal& eq_ref() { return settings_.template get<2>(); }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE8hash_refEv:
 3202|     26|  hasher& hash_ref() { return settings_.template get<1>(); }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE6insertISH_TnNS4_9enable_ifIXsr4absl11disjunctionINS4_14is_convertibleIT_NSF_IS8_SA_EEEENSJ_22SameAsElementReferenceISN_EEEE5valueEiE4typeELi0ESH_TnNSL_IXsr14IsDecomposableIT1_EE5valueEiE4typeELi0ETnPSN_LPSH_0EEENSF_INSJ_8iteratorEbEEOSN_:
 2320|     26|  std::pair<iterator, bool> insert(T&& value) ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2321|     26|    return emplace(std::forward<T>(value));
 2322|     26|  }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE7emplaceIJSH_ETnNS4_9enable_ifIXsr14IsDecomposableIDpT_EE5valueEiE4typeELi0EEENSF_INSJ_8iteratorEbEEDpOSM_:
 2422|     26|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2423|     26|    return PolicyTraits::apply(EmplaceDecomposable{*this},
 2424|     26|                               std::forward<Args>(args)...);
 2425|     26|  }
_ZNK4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE19EmplaceDecomposableclIS8_JRKNS4_21piecewise_construct_tENS4_5tupleIJOSG_EEENSP_IJOSA_EEEEEENSF_INSJ_8iteratorEbEERKT_DpOT0_:
 2822|     26|    std::pair<iterator, bool> operator()(const K& key, Args&&... args) const {
 2823|     26|      auto res = s.find_or_prepare_insert(key);
 2824|     26|      if (res.second) {
  ------------------
  |  Branch (2824:11): [True: 26, False: 0]
  ------------------
 2825|     26|        s.emplace_at(res.first, std::forward<Args>(args)...);
 2826|     26|      }
 2827|     26|      return {s.iterator_at(res.first), res.second};
 2828|     26|    }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE22find_or_prepare_insertIS8_EENSF_ImbEERKT_:
 3086|     26|  std::pair<size_t, bool> find_or_prepare_insert(const K& key) {
 3087|     26|    prefetch_heap_block();
 3088|     26|    auto hash = hash_ref()(key);
 3089|     26|    auto seq = probe(common(), hash);
 3090|     26|    const ctrl_t* ctrl = control();
 3091|     26|    while (true) {
  ------------------
  |  Branch (3091:12): [True: 26, Folded]
  ------------------
 3092|     26|      Group g{ctrl + seq.offset()};
 3093|     26|      for (uint32_t i : g.Match(H2(hash))) {
  ------------------
  |  Branch (3093:23): [True: 1, False: 26]
  ------------------
 3094|      1|        if (ABSL_PREDICT_TRUE(PolicyTraits::apply(
  ------------------
  |  |  179|      1|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (179:30): [True: 0, False: 1]
  |  |  |  Branch (179:48): [Folded, False: 1]
  |  |  |  Branch (179:57): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 3095|      1|                EqualElement<K>{key, eq_ref()},
 3096|      1|                PolicyTraits::element(slot_array() + seq.offset(i)))))
 3097|      0|          return {seq.offset(i), false};
 3098|      1|      }
 3099|     26|      if (ABSL_PREDICT_TRUE(g.MaskEmpty())) break;
  ------------------
  |  |  179|     26|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (179:30): [True: 26, False: 0]
  |  |  |  Branch (179:48): [Folded, False: 26]
  |  |  |  Branch (179:57): [True: 26, False: 0]
  |  |  ------------------
  ------------------
 3100|      0|      seq.next();
 3101|      0|      assert(seq.index() <= capacity() && "full table!");
 3102|      0|    }
 3103|     26|    return {prepare_insert(hash), true};
 3104|     26|  }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE14prepare_insertEm:
 3110|     26|  size_t prepare_insert(size_t hash) ABSL_ATTRIBUTE_NOINLINE {
 3111|     26|    const bool rehash_for_bug_detection =
 3112|     26|        common().should_rehash_for_bug_detection_on_insert();
 3113|     26|    if (rehash_for_bug_detection) {
  ------------------
  |  Branch (3113:9): [True: 0, False: 26]
  ------------------
 3114|       |      // Move to a different heap allocation in order to detect bugs.
 3115|      0|      const size_t cap = capacity();
 3116|      0|      resize(growth_left() > 0 ? cap : NextCapacity(cap));
  ------------------
  |  Branch (3116:14): [True: 0, False: 0]
  ------------------
 3117|      0|    }
 3118|     26|    auto target = find_first_non_full(common(), hash);
 3119|     26|    if (!rehash_for_bug_detection &&
  ------------------
  |  Branch (3119:9): [True: 26, False: 0]
  ------------------
 3120|     26|        ABSL_PREDICT_FALSE(growth_left() == 0 &&
  ------------------
  |  |  178|     34|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 8, False: 18]
  |  |  |  Branch (178:49): [Folded, False: 26]
  |  |  |  Branch (178:59): [True: 8, False: 18]
  |  |  |  Branch (178:59): [True: 8, False: 0]
  |  |  ------------------
  ------------------
 3121|     26|                           !IsDeleted(control()[target.offset]))) {
 3122|      8|      size_t old_capacity = capacity();
 3123|      8|      rehash_and_grow_if_necessary();
 3124|       |      // NOTE: It is safe to use `FindFirstNonFullAfterResize`.
 3125|       |      // `FindFirstNonFullAfterResize` must be called right after resize.
 3126|       |      // `rehash_and_grow_if_necessary` may *not* call `resize`
 3127|       |      // and perform `drop_deletes_without_resize` instead. But this
 3128|       |      // could happen only on big tables.
 3129|       |      // For big tables `FindFirstNonFullAfterResize` will always
 3130|       |      // fallback to normal `find_first_non_full`, so it is safe to use it.
 3131|      8|      target = HashSetResizeHelper::FindFirstNonFullAfterResize(
 3132|      8|          common(), old_capacity, hash);
 3133|      8|    }
 3134|     26|    common().increment_size();
 3135|     26|    set_growth_left(growth_left() - IsEmpty(control()[target.offset]));
 3136|     26|    SetCtrl(common(), target.offset, H2(hash), sizeof(slot_type));
 3137|     26|    common().maybe_increment_generation_on_insert();
 3138|     26|    infoz().RecordInsert(hash, target.probe_length);
 3139|     26|    return target.offset;
 3140|     26|  }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE6resizeEm:
 2905|      8|  ABSL_ATTRIBUTE_NOINLINE void resize(size_t new_capacity) {
 2906|      8|    assert(IsValidCapacity(new_capacity));
 2907|      8|    HashSetResizeHelper resize_helper(common());
 2908|      8|    auto* old_slots = slot_array();
 2909|      8|    common().set_capacity(new_capacity);
 2910|       |    // Note that `InitializeSlots` does different number initialization steps
 2911|       |    // depending on the values of `transfer_uses_memcpy` and capacities.
 2912|       |    // Refer to the comment in `InitializeSlots` for more details.
 2913|      8|    const bool grow_single_group =
 2914|      8|        resize_helper.InitializeSlots<CharAlloc, sizeof(slot_type),
 2915|      8|                                      PolicyTraits::transfer_uses_memcpy(),
 2916|      8|                                      alignof(slot_type)>(
 2917|      8|            common(), const_cast<std::remove_const_t<slot_type>*>(old_slots),
 2918|      8|            CharAlloc(alloc_ref()));
 2919|       |
 2920|      8|    if (resize_helper.old_capacity() == 0) {
  ------------------
  |  Branch (2920:9): [True: 2, False: 6]
  ------------------
 2921|       |      // InitializeSlots did all the work including infoz().RecordRehash().
 2922|      2|      return;
 2923|      2|    }
 2924|       |
 2925|      6|    if (grow_single_group) {
  ------------------
  |  Branch (2925:9): [True: 6, False: 0]
  ------------------
 2926|      6|      if (PolicyTraits::transfer_uses_memcpy()) {
  ------------------
  |  Branch (2926:11): [True: 6, Folded]
  ------------------
 2927|       |        // InitializeSlots did all the work.
 2928|      6|        return;
 2929|      6|      }
 2930|       |      // We want GrowSizeIntoSingleGroup to be called here in order to make
 2931|       |      // InitializeSlots not depend on PolicyTraits.
 2932|      0|      resize_helper.GrowSizeIntoSingleGroup<PolicyTraits>(common(), alloc_ref(),
 2933|      0|                                                          old_slots);
 2934|      0|    } else {
 2935|       |      // InitializeSlots prepares control bytes to correspond to empty table.
 2936|      0|      auto* new_slots = slot_array();
 2937|      0|      size_t total_probe_length = 0;
 2938|      0|      for (size_t i = 0; i != resize_helper.old_capacity(); ++i) {
  ------------------
  |  Branch (2938:26): [True: 0, False: 0]
  ------------------
 2939|      0|        if (IsFull(resize_helper.old_ctrl()[i])) {
  ------------------
  |  Branch (2939:13): [True: 0, False: 0]
  ------------------
 2940|      0|          size_t hash = PolicyTraits::apply(
 2941|      0|              HashElement{hash_ref()}, PolicyTraits::element(old_slots + i));
 2942|      0|          auto target = find_first_non_full(common(), hash);
 2943|      0|          size_t new_i = target.offset;
 2944|      0|          total_probe_length += target.probe_length;
 2945|      0|          SetCtrl(common(), new_i, H2(hash), sizeof(slot_type));
 2946|      0|          transfer(new_slots + new_i, old_slots + i);
 2947|      0|        }
 2948|      0|      }
 2949|      0|      infoz().RecordRehash(total_probe_length);
 2950|      0|    }
 2951|      0|    resize_helper.DeallocateOld<alignof(slot_type)>(
 2952|      0|        CharAlloc(alloc_ref()), sizeof(slot_type),
 2953|      0|        const_cast<std::remove_const_t<slot_type>*>(old_slots));
 2954|      0|  }
_ZN4absl12lts_2024011618container_internal19HashSetResizeHelper15InitializeSlotsINSt3__19allocatorIcEELm24ELb1ELm8EEEbRNS1_12CommonFieldsEPvT_:
 1595|      8|                                               Alloc alloc) {
 1596|      8|    assert(c.capacity());
 1597|       |    // Folks with custom allocators often make unwarranted assumptions about the
 1598|       |    // behavior of their classes vis-a-vis trivial destructability and what
 1599|       |    // calls they will or won't make.  Avoid sampling for people with custom
 1600|       |    // allocators to get us out of this mess.  This is not a hard guarantee but
 1601|       |    // a workaround while we plan the exact guarantee we want to provide.
 1602|      8|    const size_t sample_size =
 1603|      8|        (std::is_same<Alloc, std::allocator<char>>::value &&
  ------------------
  |  Branch (1603:10): [True: 8, Folded]
  ------------------
 1604|      8|         c.slot_array() == nullptr)
  ------------------
  |  Branch (1604:10): [True: 2, False: 6]
  ------------------
 1605|      8|            ? SizeOfSlot
 1606|      8|            : 0;
 1607|      8|    HashtablezInfoHandle infoz =
 1608|      8|        sample_size > 0 ? Sample(sample_size) : c.infoz();
  ------------------
  |  Branch (1608:9): [True: 2, False: 6]
  ------------------
 1609|       |
 1610|      8|    const bool has_infoz = infoz.IsSampled();
 1611|      8|    const size_t cap = c.capacity();
 1612|      8|    const size_t alloc_size =
 1613|      8|        AllocSize(cap, SizeOfSlot, AlignOfSlot, has_infoz);
 1614|      8|    char* mem = static_cast<char*>(
 1615|      8|        Allocate<BackingArrayAlignment(AlignOfSlot)>(&alloc, alloc_size));
 1616|      8|    const GenerationType old_generation = c.generation();
 1617|      8|    c.set_generation_ptr(reinterpret_cast<GenerationType*>(
 1618|      8|        mem + GenerationOffset(cap, has_infoz)));
 1619|      8|    c.set_generation(NextGeneration(old_generation));
 1620|      8|    c.set_control(reinterpret_cast<ctrl_t*>(mem + ControlOffset(has_infoz)));
 1621|      8|    c.set_slots(mem + SlotOffset(cap, AlignOfSlot, has_infoz));
 1622|      8|    ResetGrowthLeft(c);
 1623|       |
 1624|      8|    const bool grow_single_group =
 1625|      8|        IsGrowingIntoSingleGroupApplicable(old_capacity_, c.capacity());
 1626|      8|    if (old_capacity_ != 0 && grow_single_group) {
  ------------------
  |  Branch (1626:9): [True: 6, False: 2]
  |  Branch (1626:31): [True: 6, False: 0]
  ------------------
 1627|      6|      if (TransferUsesMemcpy) {
  ------------------
  |  Branch (1627:11): [True: 6, Folded]
  ------------------
 1628|      6|        GrowSizeIntoSingleGroupTransferable(c, old_slots, SizeOfSlot);
 1629|      6|        DeallocateOld<AlignOfSlot>(alloc, SizeOfSlot, old_slots);
 1630|      6|      } else {
 1631|      0|        GrowIntoSingleGroupShuffleControlBytes(c.control(), c.capacity());
 1632|      0|      }
 1633|      6|    } else {
 1634|      2|      ResetCtrl(c, SizeOfSlot);
 1635|      2|    }
 1636|       |
 1637|      8|    c.set_has_infoz(has_infoz);
 1638|      8|    if (has_infoz) {
  ------------------
  |  Branch (1638:9): [True: 0, False: 8]
  ------------------
 1639|      0|      infoz.RecordStorageChanged(c.size(), cap);
 1640|      0|      if (grow_single_group || old_capacity_ == 0) {
  ------------------
  |  Branch (1640:11): [True: 0, False: 0]
  |  Branch (1640:32): [True: 0, False: 0]
  ------------------
 1641|      0|        infoz.RecordRehash(0);
 1642|      0|      }
 1643|      0|      c.set_infoz(infoz);
 1644|      0|    }
 1645|      8|    return grow_single_group;
 1646|      8|  }
_ZNK4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE11growth_leftEv:
 3181|     52|  size_t growth_left() const { return common().growth_left(); }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE28rehash_and_grow_if_necessaryEv:
 2970|      8|  void rehash_and_grow_if_necessary() {
 2971|      8|    const size_t cap = capacity();
 2972|      8|    if (cap > Group::kWidth &&
  ------------------
  |  Branch (2972:9): [True: 0, False: 8]
  ------------------
 2973|       |        // Do these calculations in 64-bit to avoid overflow.
 2974|      0|        size() * uint64_t{32} <= cap * uint64_t{25}) {
  ------------------
  |  Branch (2974:9): [True: 0, False: 0]
  ------------------
 2975|       |      // Squash DELETED without growing if there is enough capacity.
 2976|       |      //
 2977|       |      // Rehash in place if the current size is <= 25/32 of capacity.
 2978|       |      // Rationale for such a high factor: 1) drop_deletes_without_resize() is
 2979|       |      // faster than resize, and 2) it takes quite a bit of work to add
 2980|       |      // tombstones.  In the worst case, seems to take approximately 4
 2981|       |      // insert/erase pairs to create a single tombstone and so if we are
 2982|       |      // rehashing because of tombstones, we can afford to rehash-in-place as
 2983|       |      // long as we are reclaiming at least 1/8 the capacity without doing more
 2984|       |      // than 2X the work.  (Where "work" is defined to be size() for rehashing
 2985|       |      // or rehashing in place, and 1 for an insert or erase.)  But rehashing in
 2986|       |      // place is faster per operation than inserting or even doubling the size
 2987|       |      // of the table, so we actually afford to reclaim even less space from a
 2988|       |      // resize-in-place.  The decision is to rehash in place if we can reclaim
 2989|       |      // at about 1/8th of the usable capacity (specifically 3/28 of the
 2990|       |      // capacity) which means that the total cost of rehashing will be a small
 2991|       |      // fraction of the total work.
 2992|       |      //
 2993|       |      // Here is output of an experiment using the BM_CacheInSteadyState
 2994|       |      // benchmark running the old case (where we rehash-in-place only if we can
 2995|       |      // reclaim at least 7/16*capacity) vs. this code (which rehashes in place
 2996|       |      // if we can recover 3/32*capacity).
 2997|       |      //
 2998|       |      // Note that although in the worst-case number of rehashes jumped up from
 2999|       |      // 15 to 190, but the number of operations per second is almost the same.
 3000|       |      //
 3001|       |      // Abridged output of running BM_CacheInSteadyState benchmark from
 3002|       |      // raw_hash_set_benchmark.   N is the number of insert/erase operations.
 3003|       |      //
 3004|       |      //      | OLD (recover >= 7/16        | NEW (recover >= 3/32)
 3005|       |      // size |    N/s LoadFactor NRehashes |    N/s LoadFactor NRehashes
 3006|       |      //  448 | 145284       0.44        18 | 140118       0.44        19
 3007|       |      //  493 | 152546       0.24        11 | 151417       0.48        28
 3008|       |      //  538 | 151439       0.26        11 | 151152       0.53        38
 3009|       |      //  583 | 151765       0.28        11 | 150572       0.57        50
 3010|       |      //  628 | 150241       0.31        11 | 150853       0.61        66
 3011|       |      //  672 | 149602       0.33        12 | 150110       0.66        90
 3012|       |      //  717 | 149998       0.35        12 | 149531       0.70       129
 3013|       |      //  762 | 149836       0.37        13 | 148559       0.74       190
 3014|       |      //  807 | 149736       0.39        14 | 151107       0.39        14
 3015|       |      //  852 | 150204       0.42        15 | 151019       0.42        15
 3016|      0|      drop_deletes_without_resize();
 3017|      8|    } else {
 3018|       |      // Otherwise grow the container.
 3019|      8|      resize(NextCapacity(cap));
 3020|      8|    }
 3021|      8|  }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE18GetPolicyFunctionsEv:
 3236|      2|  static const PolicyFunctions& GetPolicyFunctions() {
 3237|      2|    static constexpr PolicyFunctions value = {
 3238|      2|        sizeof(slot_type),
 3239|      2|        &raw_hash_set::hash_slot_fn,
 3240|      2|        PolicyTraits::transfer_uses_memcpy()
  ------------------
  |  Branch (3240:9): [True: 0, Folded]
  ------------------
 3241|      2|            ? TransferRelocatable<sizeof(slot_type)>
 3242|      2|            : &raw_hash_set::transfer_slot_fn,
 3243|      2|        (std::is_same<SlotAlloc, std::allocator<slot_type>>::value
  ------------------
  |  Branch (3243:10): [True: 0, Folded]
  ------------------
 3244|      2|             ? &DeallocateStandard<alignof(slot_type)>
 3245|      2|             : &raw_hash_set::dealloc_fn),
 3246|      2|    };
 3247|      2|    return value;
 3248|      2|  }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE15set_growth_leftEm:
 3182|     26|  void set_growth_left(size_t gl) { return common().set_growth_left(gl); }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE10emplace_atIJRKNS4_21piecewise_construct_tENS4_5tupleIJOSG_EEENSO_IJOSA_EEEEEEvmDpOT_:
 3151|     26|  void emplace_at(size_t i, Args&&... args) {
 3152|     26|    construct(slot_array() + i, std::forward<Args>(args)...);
 3153|       |
 3154|       |    assert(PolicyTraits::apply(FindElement{*this}, *iterator_at(i)) ==
 3155|     26|               iterator_at(i) &&
 3156|     26|           "constructed value does not match the lookup key");
 3157|     26|  }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE9constructIJRKNS4_21piecewise_construct_tENS4_5tupleIJOSG_EEENSO_IJOSA_EEEEEEvPNS1_13map_slot_typeIS8_SA_EEDpOT_:
 2851|     26|  inline void construct(slot_type* slot, Args&&... args) {
 2852|     26|    PolicyTraits::construct(&alloc_ref(), slot, std::forward<Args>(args)...);
 2853|     26|  }
_ZNK4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE4sizeEv:
 2287|      2|  size_t size() const { return common().size(); }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE5clearEv:
 2291|      2|  ABSL_ATTRIBUTE_REINITIALIZES void clear() {
 2292|       |    // Iterating over this container is O(bucket_count()). When bucket_count()
 2293|       |    // is much greater than size(), iteration becomes prohibitively expensive.
 2294|       |    // For clear() it is more important to reuse the allocated array when the
 2295|       |    // container is small because allocation takes comparatively long time
 2296|       |    // compared to destruction of the elements of the container. So we pick the
 2297|       |    // largest bucket_count() threshold for which iteration is still fast and
 2298|       |    // past that we simply deallocate the array.
 2299|      2|    const size_t cap = capacity();
 2300|      2|    if (cap == 0) {
  ------------------
  |  Branch (2300:9): [True: 0, False: 2]
  ------------------
 2301|       |      // Already guaranteed to be empty; so nothing to do.
 2302|      2|    } else {
 2303|      2|      destroy_slots();
 2304|      2|      ClearBackingArray(common(), GetPolicyFunctions(), /*reuse=*/cap < 128);
 2305|      2|    }
 2306|      2|    common().set_reserved_growth(0);
 2307|      2|    common().set_reservation_size(0);
 2308|      2|  }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEEC2Ev:
 2088|      2|      std::is_nothrow_default_constructible<allocator_type>::value) {}

_ZNK4absl12lts_2024011615CommandLineFlag8IsOfTypeIbEEbv:
   74|      2|  inline bool IsOfType() const {
   75|      2|    return TypeId() == base_internal::FastTypeId<T>();
   76|      2|  }

_ZN25AbslFlagDefaultGenForfuzz3GenEPv:
  252|      4|    static void Gen(void* absl_flag_default_loc) {                            \
  253|      4|      new (absl_flag_default_loc) Type(AbslFlagDefaultGenFor##name{}.value);  \
  254|      4|    }                                                                         \
_ZN29AbslFlagDefaultGenForfuzz_for3GenEPv:
  252|      2|    static void Gen(void* absl_flag_default_loc) {                            \
  253|      2|      new (absl_flag_default_loc) Type(AbslFlagDefaultGenFor##name{}.value);  \
  254|      2|    }                                                                         \
_ZN36AbslFlagDefaultGenForcorpus_database3GenEPv:
  252|      2|    static void Gen(void* absl_flag_default_loc) {                            \
  253|      2|      new (absl_flag_default_loc) Type(AbslFlagDefaultGenFor##name{}.value);  \
  254|      2|    }                                                                         \
_ZN41AbslFlagDefaultGenFortime_limit_per_input3GenEPv:
  252|      2|    static void Gen(void* absl_flag_default_loc) {                            \
  253|      2|      new (absl_flag_default_loc) Type(AbslFlagDefaultGenFor##name{}.value);  \
  254|      2|    }                                                                         \
_ZN4absl12lts_202401167GetFlagINS0_8DurationEEET_RKNS0_14flags_internal4FlagIS3_EE:
   95|      4|ABSL_MUST_USE_RESULT T GetFlag(const absl::Flag<T>& flag) {
   96|      4|  return flags_internal::FlagImplPeer::InvokeGet<T>(flag);
   97|      4|}
_ZN4absl12lts_202401167GetFlagImEET_RKNS0_14flags_internal4FlagIS2_EE:
   95|      4|ABSL_MUST_USE_RESULT T GetFlag(const absl::Flag<T>& flag) {
   96|      4|  return flags_internal::FlagImplPeer::InvokeGet<T>(flag);
   97|      4|}
_ZN4absl12lts_202401167GetFlagIbEET_RKNS0_14flags_internal4FlagIS2_EE:
   95|      8|ABSL_MUST_USE_RESULT T GetFlag(const absl::Flag<T>& flag) {
   96|      8|  return flags_internal::FlagImplPeer::InvokeGet<T>(flag);
   97|      8|}
_ZN4absl12lts_202401167GetFlagINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEET_RKNS0_14flags_internal4FlagIS9_EE:
   95|      4|ABSL_MUST_USE_RESULT T GetFlag(const absl::Flag<T>& flag) {
   96|      4|  return flags_internal::FlagImplPeer::InvokeGet<T>(flag);
   97|      4|}
_ZN29AbslFlagDefaultGenForflagfile3GenEPv:
  252|      2|    static void Gen(void* absl_flag_default_loc) {                            \
  253|      2|      new (absl_flag_default_loc) Type(AbslFlagDefaultGenFor##name{}.value);  \
  254|      2|    }                                                                         \
_ZN28AbslFlagDefaultGenForfromenv3GenEPv:
  252|      2|    static void Gen(void* absl_flag_default_loc) {                            \
  253|      2|      new (absl_flag_default_loc) Type(AbslFlagDefaultGenFor##name{}.value);  \
  254|      2|    }                                                                         \
_ZN31AbslFlagDefaultGenFortryfromenv3GenEPv:
  252|      2|    static void Gen(void* absl_flag_default_loc) {                            \
  253|      2|      new (absl_flag_default_loc) Type(AbslFlagDefaultGenFor##name{}.value);  \
  254|      2|    }                                                                         \
_ZN4absl12lts_202401167GetFlagINSt3__16vectorINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS7_IS9_EEEEEET_RKNS0_14flags_internal4FlagISC_EE:
   95|     10|ABSL_MUST_USE_RESULT T GetFlag(const absl::Flag<T>& flag) {
   96|     10|  return flags_internal::FlagImplPeer::InvokeGet<T>(flag);
   97|     10|}

_ZN4absl12lts_2024011614flags_internal15DynValueDeleterC2EPFPvNS1_6FlagOpEPKvS3_S3_E:
  135|      2|DynValueDeleter::DynValueDeleter(FlagOpFn op_arg) : op(op_arg) {}
_ZNK4absl12lts_2024011614flags_internal15DynValueDeleterclEPv:
  137|      2|void DynValueDeleter::operator()(void* ptr) const {
  138|      2|  if (op == nullptr) return;
  ------------------
  |  Branch (138:7): [True: 0, False: 2]
  ------------------
  139|       |
  140|      2|  Delete(op, ptr);
  141|      2|}
_ZN4absl12lts_2024011614flags_internal8FlagImpl4InitEv:
  143|     24|void FlagImpl::Init() {
  144|     24|  new (&data_guard_) absl::Mutex;
  145|       |
  146|     24|  auto def_kind = static_cast<FlagDefaultKind>(def_kind_);
  147|       |
  148|     24|  switch (ValueStorageKind()) {
  ------------------
  |  Branch (148:11): [True: 24, False: 0]
  ------------------
  149|      6|    case FlagValueStorageKind::kValueAndInitBit:
  ------------------
  |  Branch (149:5): [True: 6, False: 18]
  ------------------
  150|     10|    case FlagValueStorageKind::kOneWordAtomic: {
  ------------------
  |  Branch (150:5): [True: 4, False: 20]
  ------------------
  151|     10|      alignas(int64_t) std::array<char, sizeof(int64_t)> buf{};
  152|     10|      if (def_kind == FlagDefaultKind::kGenFunc) {
  ------------------
  |  Branch (152:11): [True: 0, False: 10]
  ------------------
  153|      0|        (*default_value_.gen_func)(buf.data());
  154|     10|      } else {
  155|     10|        assert(def_kind != FlagDefaultKind::kDynamicValue);
  156|     10|        std::memcpy(buf.data(), &default_value_, Sizeof(op_));
  157|     10|      }
  158|     10|      if (ValueStorageKind() == FlagValueStorageKind::kValueAndInitBit) {
  ------------------
  |  Branch (158:11): [True: 6, False: 4]
  ------------------
  159|       |        // We presume here the memory layout of FlagValueAndInitBit struct.
  160|      6|        uint8_t initialized = 1;
  161|      6|        std::memcpy(buf.data() + Sizeof(op_), &initialized,
  162|      6|                    sizeof(initialized));
  163|      6|      }
  164|       |      // Type can contain valid uninitialized bits, e.g. padding.
  165|     10|      ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(buf.data(), buf.size());
  166|     10|      OneWordValue().store(absl::bit_cast<int64_t>(buf),
  167|     10|                           std::memory_order_release);
  168|     10|      break;
  169|      6|    }
  170|      4|    case FlagValueStorageKind::kSequenceLocked: {
  ------------------
  |  Branch (170:5): [True: 4, False: 20]
  ------------------
  171|       |      // For this storage kind the default_value_ always points to gen_func
  172|       |      // during initialization.
  173|      4|      assert(def_kind == FlagDefaultKind::kGenFunc);
  174|      4|      (*default_value_.gen_func)(AtomicBufferValue());
  175|      4|      break;
  176|      6|    }
  177|     10|    case FlagValueStorageKind::kAlignedBuffer:
  ------------------
  |  Branch (177:5): [True: 10, False: 14]
  ------------------
  178|       |      // For this storage kind the default_value_ always points to gen_func
  179|       |      // during initialization.
  180|     10|      assert(def_kind == FlagDefaultKind::kGenFunc);
  181|     10|      (*default_value_.gen_func)(AlignedBufferValue());
  182|     10|      break;
  183|     24|  }
  184|     24|  seq_lock_.MarkInitialized();
  185|     24|}
_ZNK4absl12lts_2024011614flags_internal8FlagImpl9DataGuardEv:
  187|     44|absl::Mutex* FlagImpl::DataGuard() const {
  188|     44|  absl::call_once(const_cast<FlagImpl*>(this)->init_control_, &FlagImpl::Init,
  189|     44|                  const_cast<FlagImpl*>(this));
  190|       |
  191|       |  // data_guard_ is initialized inside Init.
  192|     44|  return reinterpret_cast<absl::Mutex*>(&data_guard_);
  193|     44|}
_ZNK4absl12lts_2024011614flags_internal8FlagImpl13MakeInitValueEv:
  220|      2|std::unique_ptr<void, DynValueDeleter> FlagImpl::MakeInitValue() const {
  221|      2|  void* res = nullptr;
  222|      2|  switch (DefaultKind()) {
  223|      0|    case FlagDefaultKind::kDynamicValue:
  ------------------
  |  Branch (223:5): [True: 0, False: 2]
  ------------------
  224|      0|      res = flags_internal::Clone(op_, default_value_.dynamic_value);
  225|      0|      break;
  226|      2|    case FlagDefaultKind::kGenFunc:
  ------------------
  |  Branch (226:5): [True: 2, False: 0]
  ------------------
  227|      2|      res = flags_internal::Alloc(op_);
  228|      2|      (*default_value_.gen_func)(res);
  229|      2|      break;
  230|      0|    default:
  ------------------
  |  Branch (230:5): [True: 0, False: 2]
  ------------------
  231|      0|      res = flags_internal::Clone(op_, &default_value_);
  232|      0|      break;
  233|      2|  }
  234|      2|  return {res, DynValueDeleter{op_}};
  235|      2|}
_ZN4absl12lts_2024011614flags_internal8FlagImpl10StoreValueEPKv:
  237|      2|void FlagImpl::StoreValue(const void* src) {
  238|      2|  switch (ValueStorageKind()) {
  ------------------
  |  Branch (238:11): [True: 2, False: 0]
  ------------------
  239|      0|    case FlagValueStorageKind::kValueAndInitBit:
  ------------------
  |  Branch (239:5): [True: 0, False: 2]
  ------------------
  240|      0|    case FlagValueStorageKind::kOneWordAtomic: {
  ------------------
  |  Branch (240:5): [True: 0, False: 2]
  ------------------
  241|       |      // Load the current value to avoid setting 'init' bit manually.
  242|      0|      int64_t one_word_val = OneWordValue().load(std::memory_order_acquire);
  243|      0|      std::memcpy(&one_word_val, src, Sizeof(op_));
  244|      0|      OneWordValue().store(one_word_val, std::memory_order_release);
  245|      0|      seq_lock_.IncrementModificationCount();
  246|      0|      break;
  247|      0|    }
  248|      0|    case FlagValueStorageKind::kSequenceLocked: {
  ------------------
  |  Branch (248:5): [True: 0, False: 2]
  ------------------
  249|      0|      seq_lock_.Write(AtomicBufferValue(), src, Sizeof(op_));
  250|      0|      break;
  251|      0|    }
  252|      2|    case FlagValueStorageKind::kAlignedBuffer:
  ------------------
  |  Branch (252:5): [True: 2, False: 0]
  ------------------
  253|      2|      Copy(op_, src, AlignedBufferValue());
  254|      2|      seq_lock_.IncrementModificationCount();
  255|      2|      break;
  256|      2|  }
  257|      2|  modified_ = true;
  258|      2|  InvokeCallback();
  259|      2|}
_ZNK4absl12lts_2024011614flags_internal8FlagImpl4NameEv:
  261|    222|absl::string_view FlagImpl::Name() const { return name_; }
_ZNK4absl12lts_2024011614flags_internal8FlagImpl8FilenameEv:
  263|     26|std::string FlagImpl::Filename() const {
  264|     26|  return flags_internal::GetUsageConfig().normalize_filename(filename_);
  265|     26|}
_ZNK4absl12lts_2024011614flags_internal8FlagImpl6TypeIdEv:
  272|      2|FlagFastTypeId FlagImpl::TypeId() const {
  273|      2|  return flags_internal::FastTypeId(op_);
  274|      2|}
_ZN4absl12lts_2024011614flags_internal8FlagImpl11SetCallbackEPFvvE:
  317|      8|void FlagImpl::SetCallback(const FlagCallbackFunc mutation_callback) {
  318|      8|  absl::MutexLock l(DataGuard());
  319|       |
  320|      8|  if (callback_ == nullptr) {
  ------------------
  |  Branch (320:7): [True: 8, False: 0]
  ------------------
  321|      8|    callback_ = new FlagCallback;
  322|      8|  }
  323|      8|  callback_->func = mutation_callback;
  324|       |
  325|      8|  InvokeCallback();
  326|      8|}
_ZNK4absl12lts_2024011614flags_internal8FlagImpl14InvokeCallbackEv:
  328|     10|void FlagImpl::InvokeCallback() const {
  329|     10|  if (!callback_) return;
  ------------------
  |  Branch (329:7): [True: 2, False: 8]
  ------------------
  330|       |
  331|       |  // Make a copy of the C-style function pointer that we are about to invoke
  332|       |  // before we release the lock guarding it.
  333|      8|  FlagCallbackFunc cb = callback_->func;
  334|       |
  335|       |  // If the flag has a mutation callback this function invokes it. While the
  336|       |  // callback is being invoked the primary flag's mutex is unlocked and it is
  337|       |  // re-locked back after call to callback is completed. Callback invocation is
  338|       |  // guarded by flag's secondary mutex instead which prevents concurrent
  339|       |  // callback invocation. Note that it is possible for other thread to grab the
  340|       |  // primary lock and update flag's value at any time during the callback
  341|       |  // invocation. This is by design. Callback can get a value of the flag if
  342|       |  // necessary, but it might be different from the value initiated the callback
  343|       |  // and it also can be different by the time the callback invocation is
  344|       |  // completed. Requires that *primary_lock be held in exclusive mode; it may be
  345|       |  // released and reacquired by the implementation.
  346|      8|  MutexRelock relock(*DataGuard());
  347|      8|  absl::MutexLock lock(&callback_->guard);
  348|      8|  cb();
  349|      8|}
_ZNK4absl12lts_2024011614flags_internal8FlagImpl18AlignedBufferValueEv:
  414|     26|void* FlagImpl::AlignedBufferValue() const {
  415|       |  assert(ValueStorageKind() == FlagValueStorageKind::kAlignedBuffer);
  416|     26|  return OffsetValue<void>();
  417|     26|}
_ZNK4absl12lts_2024011614flags_internal8FlagImpl17AtomicBufferValueEv:
  419|      8|std::atomic<uint64_t>* FlagImpl::AtomicBufferValue() const {
  420|       |  assert(ValueStorageKind() == FlagValueStorageKind::kSequenceLocked);
  421|      8|  return OffsetValue<std::atomic<uint64_t>>();
  422|      8|}
_ZNK4absl12lts_2024011614flags_internal8FlagImpl12OneWordValueEv:
  424|     18|std::atomic<int64_t>& FlagImpl::OneWordValue() const {
  425|       |  assert(ValueStorageKind() == FlagValueStorageKind::kOneWordAtomic ||
  426|     18|         ValueStorageKind() == FlagValueStorageKind::kValueAndInitBit);
  427|     18|  return OffsetValue<FlagOneWordValue>()->value;
  428|     18|}
_ZNK4absl12lts_2024011614flags_internal8FlagImpl8TryParseENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEERNS3_12basic_stringIcS6_NS3_9allocatorIcEEEE:
  435|      2|    absl::string_view value, std::string& err) const {
  436|      2|  std::unique_ptr<void, DynValueDeleter> tentative_value = MakeInitValue();
  437|       |
  438|      2|  std::string parse_err;
  439|      2|  if (!flags_internal::Parse(op_, value, tentative_value.get(), &parse_err)) {
  ------------------
  |  Branch (439:7): [True: 0, False: 2]
  ------------------
  440|      0|    absl::string_view err_sep = parse_err.empty() ? "" : "; ";
  ------------------
  |  Branch (440:33): [True: 0, False: 0]
  ------------------
  441|      0|    err = absl::StrCat("Illegal value '", value, "' specified for flag '",
  442|      0|                       Name(), "'", err_sep, parse_err);
  443|      0|    return nullptr;
  444|      0|  }
  445|       |
  446|      2|  return tentative_value;
  447|      2|}
_ZNK4absl12lts_2024011614flags_internal8FlagImpl4ReadEPv:
  449|     18|void FlagImpl::Read(void* dst) const {
  450|     18|  auto* guard = DataGuard();  // Make sure flag initialized
  451|     18|  switch (ValueStorageKind()) {
  ------------------
  |  Branch (451:11): [True: 18, False: 0]
  ------------------
  452|      0|    case FlagValueStorageKind::kValueAndInitBit:
  ------------------
  |  Branch (452:5): [True: 0, False: 18]
  ------------------
  453|      0|    case FlagValueStorageKind::kOneWordAtomic: {
  ------------------
  |  Branch (453:5): [True: 0, False: 18]
  ------------------
  454|      0|      const int64_t one_word_val =
  455|      0|          OneWordValue().load(std::memory_order_acquire);
  456|      0|      std::memcpy(dst, &one_word_val, Sizeof(op_));
  457|      0|      break;
  458|      0|    }
  459|      4|    case FlagValueStorageKind::kSequenceLocked: {
  ------------------
  |  Branch (459:5): [True: 4, False: 14]
  ------------------
  460|      4|      ReadSequenceLockedData(dst);
  461|      4|      break;
  462|      0|    }
  463|     14|    case FlagValueStorageKind::kAlignedBuffer: {
  ------------------
  |  Branch (463:5): [True: 14, False: 4]
  ------------------
  464|     14|      absl::MutexLock l(guard);
  465|     14|      flags_internal::CopyConstruct(op_, AlignedBufferValue(), dst);
  466|     14|      break;
  467|      0|    }
  468|     18|  }
  469|     18|}
_ZNK4absl12lts_2024011614flags_internal8FlagImpl11ReadOneWordEv:
  471|      4|int64_t FlagImpl::ReadOneWord() const {
  472|       |  assert(ValueStorageKind() == FlagValueStorageKind::kOneWordAtomic ||
  473|      4|         ValueStorageKind() == FlagValueStorageKind::kValueAndInitBit);
  474|      4|  auto* guard = DataGuard();  // Make sure flag initialized
  475|      4|  (void)guard;
  476|      4|  return OneWordValue().load(std::memory_order_acquire);
  477|      4|}
_ZNK4absl12lts_2024011614flags_internal8FlagImpl11ReadOneBoolEv:
  479|      4|bool FlagImpl::ReadOneBool() const {
  480|       |  assert(ValueStorageKind() == FlagValueStorageKind::kValueAndInitBit);
  481|      4|  auto* guard = DataGuard();  // Make sure flag initialized
  482|      4|  (void)guard;
  483|      4|  return absl::bit_cast<FlagValueAndInitBit<bool>>(
  484|      4|             OneWordValue().load(std::memory_order_acquire))
  485|      4|      .value;
  486|      4|}
_ZNK4absl12lts_2024011614flags_internal8FlagImpl22ReadSequenceLockedDataEPv:
  488|      4|void FlagImpl::ReadSequenceLockedData(void* dst) const {
  489|      4|  size_t size = Sizeof(op_);
  490|       |  // Attempt to read using the sequence lock.
  491|      4|  if (ABSL_PREDICT_TRUE(seq_lock_.TryRead(dst, AtomicBufferValue(), size))) {
  ------------------
  |  |  179|      4|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (179:30): [True: 4, False: 0]
  |  |  |  Branch (179:48): [Folded, False: 4]
  |  |  |  Branch (179:57): [True: 4, False: 0]
  |  |  ------------------
  ------------------
  492|      4|    return;
  493|      4|  }
  494|       |  // We failed due to contention. Acquire the lock to prevent contention
  495|       |  // and try again.
  496|      0|  absl::ReaderMutexLock l(DataGuard());
  497|      0|  bool success = seq_lock_.TryRead(dst, AtomicBufferValue(), size);
  498|       |  assert(success);
  499|      0|  static_cast<void>(success);
  500|      0|}
_ZN4absl12lts_2024011614flags_internal8FlagImpl9ParseFromENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEENS1_15FlagSettingModeENS1_11ValueSourceERNS3_12basic_stringIcS6_NS3_9allocatorIcEEEE:
  528|      2|                         ValueSource source, std::string& err) {
  529|      2|  absl::MutexLock l(DataGuard());
  530|       |
  531|      2|  switch (set_mode) {
  ------------------
  |  Branch (531:11): [True: 2, False: 0]
  ------------------
  532|      2|    case SET_FLAGS_VALUE: {
  ------------------
  |  Branch (532:5): [True: 2, False: 0]
  ------------------
  533|       |      // set or modify the flag's value
  534|      2|      auto tentative_value = TryParse(value, err);
  535|      2|      if (!tentative_value) return false;
  ------------------
  |  Branch (535:11): [True: 0, False: 2]
  ------------------
  536|       |
  537|      2|      StoreValue(tentative_value.get());
  538|       |
  539|      2|      if (source == kCommandLine) {
  ------------------
  |  Branch (539:11): [True: 2, False: 0]
  ------------------
  540|      2|        on_command_line_ = true;
  541|      2|      }
  542|      2|      break;
  543|      2|    }
  544|      0|    case SET_FLAG_IF_DEFAULT: {
  ------------------
  |  Branch (544:5): [True: 0, False: 2]
  ------------------
  545|       |      // set the flag's value, but only if it hasn't been set by someone else
  546|      0|      if (modified_) {
  ------------------
  |  Branch (546:11): [True: 0, False: 0]
  ------------------
  547|       |        // TODO(rogeeff): review and fix this semantic. Currently we do not fail
  548|       |        // in this case if flag is modified. This is misleading since the flag's
  549|       |        // value is not updated even though we return true.
  550|       |        // *err = absl::StrCat(Name(), " is already set to ",
  551|       |        //                     CurrentValue(), "\n");
  552|       |        // return false;
  553|      0|        return true;
  554|      0|      }
  555|      0|      auto tentative_value = TryParse(value, err);
  556|      0|      if (!tentative_value) return false;
  ------------------
  |  Branch (556:11): [True: 0, False: 0]
  ------------------
  557|       |
  558|      0|      StoreValue(tentative_value.get());
  559|      0|      break;
  560|      0|    }
  561|      0|    case SET_FLAGS_DEFAULT: {
  ------------------
  |  Branch (561:5): [True: 0, False: 2]
  ------------------
  562|      0|      auto tentative_value = TryParse(value, err);
  563|      0|      if (!tentative_value) return false;
  ------------------
  |  Branch (563:11): [True: 0, False: 0]
  ------------------
  564|       |
  565|      0|      if (DefaultKind() == FlagDefaultKind::kDynamicValue) {
  ------------------
  |  Branch (565:11): [True: 0, False: 0]
  ------------------
  566|      0|        void* old_value = default_value_.dynamic_value;
  567|      0|        default_value_.dynamic_value = tentative_value.release();
  568|      0|        tentative_value.reset(old_value);
  569|      0|      } else {
  570|      0|        default_value_.dynamic_value = tentative_value.release();
  571|      0|        def_kind_ = static_cast<uint8_t>(FlagDefaultKind::kDynamicValue);
  572|      0|      }
  573|       |
  574|      0|      if (!modified_) {
  ------------------
  |  Branch (574:11): [True: 0, False: 0]
  ------------------
  575|       |        // Need to set both default value *and* current, in this case.
  576|      0|        StoreValue(default_value_.dynamic_value);
  577|      0|        modified_ = false;
  578|      0|      }
  579|      0|      break;
  580|      0|    }
  581|      2|  }
  582|       |
  583|      2|  return true;
  584|      2|}
flag.cc:_ZN4absl12lts_2024011614flags_internal12_GLOBAL__N_111MutexRelockC2ERNS0_5MutexE:
   71|      8|  explicit MutexRelock(absl::Mutex& mu) : mu_(mu) { mu_.Unlock(); }
flag.cc:_ZN4absl12lts_2024011614flags_internal12_GLOBAL__N_111MutexRelockD2Ev:
   72|      8|  ~MutexRelock() { mu_.Lock(); }
_ZNK4absl12lts_2024011614flags_internal8FlagImpl11OffsetValueIvEEPT_v:
  406|     26|StorageT* FlagImpl::OffsetValue() const {
  407|     26|  char* p = reinterpret_cast<char*>(const_cast<FlagImpl*>(this));
  408|       |  // The offset is deduced via Flag value type specific op_.
  409|     26|  ptrdiff_t offset = flags_internal::ValueOffset(op_);
  410|       |
  411|     26|  return reinterpret_cast<StorageT*>(p + offset);
  412|     26|}
_ZNK4absl12lts_2024011614flags_internal8FlagImpl11OffsetValueINSt3__16atomicImEEEEPT_v:
  406|      8|StorageT* FlagImpl::OffsetValue() const {
  407|      8|  char* p = reinterpret_cast<char*>(const_cast<FlagImpl*>(this));
  408|       |  // The offset is deduced via Flag value type specific op_.
  409|      8|  ptrdiff_t offset = flags_internal::ValueOffset(op_);
  410|       |
  411|      8|  return reinterpret_cast<StorageT*>(p + offset);
  412|      8|}
_ZNK4absl12lts_2024011614flags_internal8FlagImpl11OffsetValueINS1_16FlagOneWordValueEEEPT_v:
  406|     18|StorageT* FlagImpl::OffsetValue() const {
  407|     18|  char* p = reinterpret_cast<char*>(const_cast<FlagImpl*>(this));
  408|       |  // The offset is deduced via Flag value type specific op_.
  409|     18|  ptrdiff_t offset = flags_internal::ValueOffset(op_);
  410|       |
  411|     18|  return reinterpret_cast<StorageT*>(p + offset);
  412|     18|}

_ZN4absl12lts_2024011614flags_internal16InitDefaultValueINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEET_SA_:
  277|      6|constexpr T InitDefaultValue(T t) {
  278|      6|  return t;
  279|      6|}
_ZN4absl12lts_2024011614flags_internal16InitDefaultValueINS0_8DurationEEET_S4_:
  277|      4|constexpr T InitDefaultValue(T t) {
  278|      4|  return t;
  279|      4|}
_ZN4absl12lts_2024011614flags_internal12FlagImplPeer9InvokeGetINS0_8DurationENS1_4FlagIS4_EEEET_RKT0_:
  697|      4|  static T InvokeGet(const FlagType& flag) {
  698|      4|    return flag.Get();
  699|      4|  }
_ZNK4absl12lts_2024011614flags_internal4FlagINS0_8DurationEE3GetEv:
  657|      4|  T Get() const {
  658|       |    // See implementation notes in CommandLineFlag::Get().
  659|      4|    union U {
  660|      4|      T value;
  661|      4|      U() {}
  662|      4|      ~U() { value.~T(); }
  663|      4|    };
  664|      4|    U u;
  665|       |
  666|       |#if !defined(NDEBUG)
  667|       |    impl_.AssertValidType(base_internal::FastTypeId<T>(), &GenRuntimeTypeId<T>);
  668|       |#endif
  669|       |
  670|      4|    if (ABSL_PREDICT_FALSE(!value_.Get(impl_.seq_lock_, u.value))) {
  ------------------
  |  |  178|      4|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 4, False: 0]
  |  |  |  Branch (178:49): [Folded, False: 4]
  |  |  |  Branch (178:58): [True: 4, False: 0]
  |  |  ------------------
  ------------------
  671|      4|      impl_.Read(&u.value);
  672|      4|    }
  673|      4|    return std::move(u.value);
  674|      4|  }
_ZZNK4absl12lts_2024011614flags_internal4FlagINS0_8DurationEE3GetEvEN1UC2Ev:
  661|      4|      U() {}
_ZNK4absl12lts_2024011614flags_internal9FlagValueINS0_8DurationELNS1_20FlagValueStorageKindE2EE3GetERKNS1_12SequenceLockERS3_:
  384|      4|  bool Get(const SequenceLock& lock, T& dst) const {
  385|      4|    return lock.TryRead(&dst, value_words, sizeof(T));
  386|      4|  }
_ZZNK4absl12lts_2024011614flags_internal4FlagINS0_8DurationEE3GetEvEN1UD2Ev:
  662|      4|      ~U() { value.~T(); }
_ZN4absl12lts_2024011614flags_internal12FlagImplPeer9InvokeGetImNS1_4FlagImEEEET_RKT0_:
  697|      4|  static T InvokeGet(const FlagType& flag) {
  698|      4|    return flag.Get();
  699|      4|  }
_ZNK4absl12lts_2024011614flags_internal4FlagImE3GetEv:
  657|      4|  T Get() const {
  658|       |    // See implementation notes in CommandLineFlag::Get().
  659|      4|    union U {
  660|      4|      T value;
  661|      4|      U() {}
  662|      4|      ~U() { value.~T(); }
  663|      4|    };
  664|      4|    U u;
  665|       |
  666|       |#if !defined(NDEBUG)
  667|       |    impl_.AssertValidType(base_internal::FastTypeId<T>(), &GenRuntimeTypeId<T>);
  668|       |#endif
  669|       |
  670|      4|    if (ABSL_PREDICT_FALSE(!value_.Get(impl_.seq_lock_, u.value))) {
  ------------------
  |  |  178|      4|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 4, False: 0]
  |  |  |  Branch (178:49): [Folded, False: 4]
  |  |  |  Branch (178:58): [True: 4, False: 0]
  |  |  ------------------
  ------------------
  671|      4|      impl_.Read(&u.value);
  672|      4|    }
  673|      4|    return std::move(u.value);
  674|      4|  }
_ZZNK4absl12lts_2024011614flags_internal4FlagImE3GetEvEN1UC2Ev:
  661|      4|      U() {}
_ZNK4absl12lts_2024011614flags_internal9FlagValueImLNS1_20FlagValueStorageKindE1EE3GetERKNS1_12SequenceLockERm:
  372|      4|  bool Get(const SequenceLock&, T& dst) const {
  373|      4|    int64_t one_word_val = value.load(std::memory_order_acquire);
  374|      4|    if (ABSL_PREDICT_FALSE(one_word_val == UninitializedFlagValue())) {
  ------------------
  |  |  178|      4|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 4, False: 0]
  |  |  |  Branch (178:49): [Folded, False: 4]
  |  |  |  Branch (178:58): [True: 4, False: 0]
  |  |  ------------------
  ------------------
  375|      4|      return false;
  376|      4|    }
  377|      0|    std::memcpy(&dst, static_cast<const void*>(&one_word_val), sizeof(T));
  378|      0|    return true;
  379|      4|  }
_ZN4absl12lts_2024011614flags_internal22UninitializedFlagValueEv:
  301|      4|constexpr int64_t UninitializedFlagValue() {
  302|      4|  return static_cast<int64_t>(0xababababababababll);
  303|      4|}
_ZNK4absl12lts_2024011614flags_internal8FlagImpl4ReadImTnNSt3__19enable_ifIXeqclsr14flags_internalE11StorageKindIT_EELNS1_20FlagValueStorageKindE1EEiE4typeELi0EEEvPS6_:
  457|      4|  void Read(T* value) const ABSL_LOCKS_EXCLUDED(*DataGuard()) {
  458|      4|    int64_t v = ReadOneWord();
  459|      4|    std::memcpy(value, static_cast<const void*>(&v), sizeof(T));
  460|      4|  }
_ZZNK4absl12lts_2024011614flags_internal4FlagImE3GetEvEN1UD2Ev:
  662|      4|      ~U() { value.~T(); }
_ZN4absl12lts_2024011614flags_internal7FlagOpsIbEEPvNS1_6FlagOpEPKvS3_S3_:
  713|     22|void* FlagOps(FlagOp op, const void* v1, void* v2, void* v3) {
  714|     22|  switch (op) {
  ------------------
  |  Branch (714:11): [True: 22, False: 0]
  ------------------
  715|      0|    case FlagOp::kAlloc: {
  ------------------
  |  Branch (715:5): [True: 0, False: 22]
  ------------------
  716|      0|      std::allocator<T> alloc;
  717|      0|      return std::allocator_traits<std::allocator<T>>::allocate(alloc, 1);
  718|      0|    }
  719|      0|    case FlagOp::kDelete: {
  ------------------
  |  Branch (719:5): [True: 0, False: 22]
  ------------------
  720|      0|      T* p = static_cast<T*>(v2);
  721|      0|      p->~T();
  722|      0|      std::allocator<T> alloc;
  723|      0|      std::allocator_traits<std::allocator<T>>::deallocate(alloc, p, 1);
  724|      0|      return nullptr;
  725|      0|    }
  726|      0|    case FlagOp::kCopy:
  ------------------
  |  Branch (726:5): [True: 0, False: 22]
  ------------------
  727|      0|      *static_cast<T*>(v2) = *static_cast<const T*>(v1);
  728|      0|      return nullptr;
  729|      0|    case FlagOp::kCopyConstruct:
  ------------------
  |  Branch (729:5): [True: 0, False: 22]
  ------------------
  730|      0|      new (v2) T(*static_cast<const T*>(v1));
  731|      0|      return nullptr;
  732|     12|    case FlagOp::kSizeof:
  ------------------
  |  Branch (732:5): [True: 12, False: 10]
  ------------------
  733|     12|      return reinterpret_cast<void*>(static_cast<uintptr_t>(sizeof(T)));
  734|      0|    case FlagOp::kFastTypeId:
  ------------------
  |  Branch (734:5): [True: 0, False: 22]
  ------------------
  735|      0|      return const_cast<void*>(base_internal::FastTypeId<T>());
  736|      0|    case FlagOp::kRuntimeTypeId:
  ------------------
  |  Branch (736:5): [True: 0, False: 22]
  ------------------
  737|      0|      return const_cast<std::type_info*>(GenRuntimeTypeId<T>());
  738|      0|    case FlagOp::kParse: {
  ------------------
  |  Branch (738:5): [True: 0, False: 22]
  ------------------
  739|       |      // Initialize the temporary instance of type T based on current value in
  740|       |      // destination (which is going to be flag's default value).
  741|      0|      T temp(*static_cast<T*>(v2));
  742|      0|      if (!absl::ParseFlag<T>(*static_cast<const absl::string_view*>(v1), &temp,
  ------------------
  |  Branch (742:11): [True: 0, False: 0]
  ------------------
  743|      0|                              static_cast<std::string*>(v3))) {
  744|      0|        return nullptr;
  745|      0|      }
  746|      0|      *static_cast<T*>(v2) = std::move(temp);
  747|      0|      return v2;
  748|      0|    }
  749|      0|    case FlagOp::kUnparse:
  ------------------
  |  Branch (749:5): [True: 0, False: 22]
  ------------------
  750|      0|      *static_cast<std::string*>(v2) =
  751|      0|          absl::UnparseFlag<T>(*static_cast<const T*>(v1));
  752|      0|      return nullptr;
  753|     10|    case FlagOp::kValueOffset: {
  ------------------
  |  Branch (753:5): [True: 10, False: 12]
  ------------------
  754|       |      // Round sizeof(FlagImp) to a multiple of alignof(FlagValue<T>) to get the
  755|       |      // offset of the data.
  756|     10|      size_t round_to = alignof(FlagValue<T>);
  757|     10|      size_t offset =
  758|     10|          (sizeof(FlagImpl) + round_to - 1) / round_to * round_to;
  759|     10|      return reinterpret_cast<void*>(offset);
  760|      0|    }
  761|     22|  }
  762|      0|  return nullptr;
  763|     22|}
_ZN4absl12lts_2024011614flags_internal13FlagRegistrarIbLb1EEC2ERNS1_4FlagIbEEPKc:
  773|      6|  explicit FlagRegistrar(Flag<T>& flag, const char* filename) : flag_(flag) {
  774|      6|    if (do_register)
  ------------------
  |  Branch (774:9): [True: 6, Folded]
  ------------------
  775|      6|      flags_internal::RegisterCommandLineFlag(flag_.impl_, filename);
  776|      6|  }
_ZNO4absl12lts_2024011614flags_internal13FlagRegistrarIbLb1EE8OnUpdateEPFvvE:
  778|      2|  FlagRegistrar OnUpdate(FlagCallbackFunc cb) && {
  779|      2|    flag_.impl_.SetCallback(cb);
  780|      2|    return *this;
  781|      2|  }
_ZN4absl12lts_2024011614flags_internal12FlagImplPeer9InvokeGetIbNS1_4FlagIbEEEET_RKT0_:
  697|      8|  static T InvokeGet(const FlagType& flag) {
  698|      8|    return flag.Get();
  699|      8|  }
_ZNK4absl12lts_2024011614flags_internal4FlagIbE3GetEv:
  657|      8|  T Get() const {
  658|       |    // See implementation notes in CommandLineFlag::Get().
  659|      8|    union U {
  660|      8|      T value;
  661|      8|      U() {}
  662|      8|      ~U() { value.~T(); }
  663|      8|    };
  664|      8|    U u;
  665|       |
  666|       |#if !defined(NDEBUG)
  667|       |    impl_.AssertValidType(base_internal::FastTypeId<T>(), &GenRuntimeTypeId<T>);
  668|       |#endif
  669|       |
  670|      8|    if (ABSL_PREDICT_FALSE(!value_.Get(impl_.seq_lock_, u.value))) {
  ------------------
  |  |  178|      8|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 4, False: 4]
  |  |  |  Branch (178:49): [Folded, False: 8]
  |  |  |  Branch (178:58): [True: 4, False: 4]
  |  |  ------------------
  ------------------
  671|      4|      impl_.Read(&u.value);
  672|      4|    }
  673|      8|    return std::move(u.value);
  674|      8|  }
_ZZNK4absl12lts_2024011614flags_internal4FlagIbE3GetEvEN1UC2Ev:
  661|      8|      U() {}
_ZNK4absl12lts_2024011614flags_internal9FlagValueIbLNS1_20FlagValueStorageKindE0EE3GetERKNS1_12SequenceLockERb:
  359|      8|  bool Get(const SequenceLock&, T& dst) const {
  360|      8|    int64_t storage = value.load(std::memory_order_acquire);
  361|      8|    if (ABSL_PREDICT_FALSE(storage == 0)) {
  ------------------
  |  |  178|      8|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 4, False: 4]
  |  |  |  Branch (178:49): [Folded, False: 8]
  |  |  |  Branch (178:58): [True: 4, False: 4]
  |  |  ------------------
  ------------------
  362|      4|      return false;
  363|      4|    }
  364|      4|    dst = absl::bit_cast<FlagValueAndInitBit<T>>(storage).value;
  365|      4|    return true;
  366|      8|  }
_ZNK4absl12lts_2024011614flags_internal8FlagImpl4ReadEPb:
  450|      4|  void Read(bool* value) const ABSL_LOCKS_EXCLUDED(*DataGuard()) {
  451|      4|    *value = ReadOneBool();
  452|      4|  }
_ZZNK4absl12lts_2024011614flags_internal4FlagIbE3GetEvEN1UD2Ev:
  662|      8|      ~U() { value.~T(); }
_ZNK4absl12lts_2024011614flags_internal13FlagRegistrarIbLb1EEcvNS1_18FlagRegistrarEmptyEEv:
  786|      6|  operator FlagRegistrarEmpty() const { return {}; }  // NOLINT
_ZN4absl12lts_2024011614flags_internal7FlagOpsINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEPvNS1_6FlagOpEPKvSA_SA_:
  713|     24|void* FlagOps(FlagOp op, const void* v1, void* v2, void* v3) {
  714|     24|  switch (op) {
  ------------------
  |  Branch (714:11): [True: 24, False: 0]
  ------------------
  715|      2|    case FlagOp::kAlloc: {
  ------------------
  |  Branch (715:5): [True: 2, False: 22]
  ------------------
  716|      2|      std::allocator<T> alloc;
  717|      2|      return std::allocator_traits<std::allocator<T>>::allocate(alloc, 1);
  718|      0|    }
  719|      2|    case FlagOp::kDelete: {
  ------------------
  |  Branch (719:5): [True: 2, False: 22]
  ------------------
  720|      2|      T* p = static_cast<T*>(v2);
  721|      2|      p->~T();
  722|      2|      std::allocator<T> alloc;
  723|      2|      std::allocator_traits<std::allocator<T>>::deallocate(alloc, p, 1);
  724|      2|      return nullptr;
  725|      0|    }
  726|      2|    case FlagOp::kCopy:
  ------------------
  |  Branch (726:5): [True: 2, False: 22]
  ------------------
  727|      2|      *static_cast<T*>(v2) = *static_cast<const T*>(v1);
  728|      2|      return nullptr;
  729|      4|    case FlagOp::kCopyConstruct:
  ------------------
  |  Branch (729:5): [True: 4, False: 20]
  ------------------
  730|      4|      new (v2) T(*static_cast<const T*>(v1));
  731|      4|      return nullptr;
  732|      0|    case FlagOp::kSizeof:
  ------------------
  |  Branch (732:5): [True: 0, False: 24]
  ------------------
  733|      0|      return reinterpret_cast<void*>(static_cast<uintptr_t>(sizeof(T)));
  734|      2|    case FlagOp::kFastTypeId:
  ------------------
  |  Branch (734:5): [True: 2, False: 22]
  ------------------
  735|      2|      return const_cast<void*>(base_internal::FastTypeId<T>());
  736|      0|    case FlagOp::kRuntimeTypeId:
  ------------------
  |  Branch (736:5): [True: 0, False: 24]
  ------------------
  737|      0|      return const_cast<std::type_info*>(GenRuntimeTypeId<T>());
  738|      2|    case FlagOp::kParse: {
  ------------------
  |  Branch (738:5): [True: 2, False: 22]
  ------------------
  739|       |      // Initialize the temporary instance of type T based on current value in
  740|       |      // destination (which is going to be flag's default value).
  741|      2|      T temp(*static_cast<T*>(v2));
  742|      2|      if (!absl::ParseFlag<T>(*static_cast<const absl::string_view*>(v1), &temp,
  ------------------
  |  Branch (742:11): [True: 0, False: 2]
  ------------------
  743|      2|                              static_cast<std::string*>(v3))) {
  744|      0|        return nullptr;
  745|      0|      }
  746|      2|      *static_cast<T*>(v2) = std::move(temp);
  747|      2|      return v2;
  748|      2|    }
  749|      0|    case FlagOp::kUnparse:
  ------------------
  |  Branch (749:5): [True: 0, False: 24]
  ------------------
  750|      0|      *static_cast<std::string*>(v2) =
  751|      0|          absl::UnparseFlag<T>(*static_cast<const T*>(v1));
  752|      0|      return nullptr;
  753|     10|    case FlagOp::kValueOffset: {
  ------------------
  |  Branch (753:5): [True: 10, False: 14]
  ------------------
  754|       |      // Round sizeof(FlagImp) to a multiple of alignof(FlagValue<T>) to get the
  755|       |      // offset of the data.
  756|     10|      size_t round_to = alignof(FlagValue<T>);
  757|     10|      size_t offset =
  758|     10|          (sizeof(FlagImpl) + round_to - 1) / round_to * round_to;
  759|     10|      return reinterpret_cast<void*>(offset);
  760|      2|    }
  761|     24|  }
  762|      0|  return nullptr;
  763|     24|}
_ZN4absl12lts_2024011614flags_internal13FlagRegistrarINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEELb1EEC2ERNS1_4FlagIS9_EEPKc:
  773|      4|  explicit FlagRegistrar(Flag<T>& flag, const char* filename) : flag_(flag) {
  774|      4|    if (do_register)
  ------------------
  |  Branch (774:9): [True: 4, Folded]
  ------------------
  775|      4|      flags_internal::RegisterCommandLineFlag(flag_.impl_, filename);
  776|      4|  }
_ZNK4absl12lts_2024011614flags_internal13FlagRegistrarINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEELb1EEcvNS1_18FlagRegistrarEmptyEEv:
  786|      4|  operator FlagRegistrarEmpty() const { return {}; }  // NOLINT
_ZN4absl12lts_2024011614flags_internal7FlagOpsINS0_8DurationEEEPvNS1_6FlagOpEPKvS4_S4_:
  713|     12|void* FlagOps(FlagOp op, const void* v1, void* v2, void* v3) {
  714|     12|  switch (op) {
  ------------------
  |  Branch (714:11): [True: 12, False: 0]
  ------------------
  715|      0|    case FlagOp::kAlloc: {
  ------------------
  |  Branch (715:5): [True: 0, False: 12]
  ------------------
  716|      0|      std::allocator<T> alloc;
  717|      0|      return std::allocator_traits<std::allocator<T>>::allocate(alloc, 1);
  718|      0|    }
  719|      0|    case FlagOp::kDelete: {
  ------------------
  |  Branch (719:5): [True: 0, False: 12]
  ------------------
  720|      0|      T* p = static_cast<T*>(v2);
  721|      0|      p->~T();
  722|      0|      std::allocator<T> alloc;
  723|      0|      std::allocator_traits<std::allocator<T>>::deallocate(alloc, p, 1);
  724|      0|      return nullptr;
  725|      0|    }
  726|      0|    case FlagOp::kCopy:
  ------------------
  |  Branch (726:5): [True: 0, False: 12]
  ------------------
  727|      0|      *static_cast<T*>(v2) = *static_cast<const T*>(v1);
  728|      0|      return nullptr;
  729|      0|    case FlagOp::kCopyConstruct:
  ------------------
  |  Branch (729:5): [True: 0, False: 12]
  ------------------
  730|      0|      new (v2) T(*static_cast<const T*>(v1));
  731|      0|      return nullptr;
  732|      4|    case FlagOp::kSizeof:
  ------------------
  |  Branch (732:5): [True: 4, False: 8]
  ------------------
  733|      4|      return reinterpret_cast<void*>(static_cast<uintptr_t>(sizeof(T)));
  734|      0|    case FlagOp::kFastTypeId:
  ------------------
  |  Branch (734:5): [True: 0, False: 12]
  ------------------
  735|      0|      return const_cast<void*>(base_internal::FastTypeId<T>());
  736|      0|    case FlagOp::kRuntimeTypeId:
  ------------------
  |  Branch (736:5): [True: 0, False: 12]
  ------------------
  737|      0|      return const_cast<std::type_info*>(GenRuntimeTypeId<T>());
  738|      0|    case FlagOp::kParse: {
  ------------------
  |  Branch (738:5): [True: 0, False: 12]
  ------------------
  739|       |      // Initialize the temporary instance of type T based on current value in
  740|       |      // destination (which is going to be flag's default value).
  741|      0|      T temp(*static_cast<T*>(v2));
  742|      0|      if (!absl::ParseFlag<T>(*static_cast<const absl::string_view*>(v1), &temp,
  ------------------
  |  Branch (742:11): [True: 0, False: 0]
  ------------------
  743|      0|                              static_cast<std::string*>(v3))) {
  744|      0|        return nullptr;
  745|      0|      }
  746|      0|      *static_cast<T*>(v2) = std::move(temp);
  747|      0|      return v2;
  748|      0|    }
  749|      0|    case FlagOp::kUnparse:
  ------------------
  |  Branch (749:5): [True: 0, False: 12]
  ------------------
  750|      0|      *static_cast<std::string*>(v2) =
  751|      0|          absl::UnparseFlag<T>(*static_cast<const T*>(v1));
  752|      0|      return nullptr;
  753|      8|    case FlagOp::kValueOffset: {
  ------------------
  |  Branch (753:5): [True: 8, False: 4]
  ------------------
  754|       |      // Round sizeof(FlagImp) to a multiple of alignof(FlagValue<T>) to get the
  755|       |      // offset of the data.
  756|      8|      size_t round_to = alignof(FlagValue<T>);
  757|      8|      size_t offset =
  758|      8|          (sizeof(FlagImpl) + round_to - 1) / round_to * round_to;
  759|      8|      return reinterpret_cast<void*>(offset);
  760|      0|    }
  761|     12|  }
  762|      0|  return nullptr;
  763|     12|}
_ZN4absl12lts_2024011614flags_internal13FlagRegistrarINS0_8DurationELb1EEC2ERNS1_4FlagIS3_EEPKc:
  773|      4|  explicit FlagRegistrar(Flag<T>& flag, const char* filename) : flag_(flag) {
  774|      4|    if (do_register)
  ------------------
  |  Branch (774:9): [True: 4, Folded]
  ------------------
  775|      4|      flags_internal::RegisterCommandLineFlag(flag_.impl_, filename);
  776|      4|  }
_ZNK4absl12lts_2024011614flags_internal13FlagRegistrarINS0_8DurationELb1EEcvNS1_18FlagRegistrarEmptyEEv:
  786|      4|  operator FlagRegistrarEmpty() const { return {}; }  // NOLINT
_ZN4absl12lts_2024011614flags_internal7FlagOpsImEEPvNS1_6FlagOpEPKvS3_S3_:
  713|     12|void* FlagOps(FlagOp op, const void* v1, void* v2, void* v3) {
  714|     12|  switch (op) {
  ------------------
  |  Branch (714:11): [True: 12, False: 0]
  ------------------
  715|      0|    case FlagOp::kAlloc: {
  ------------------
  |  Branch (715:5): [True: 0, False: 12]
  ------------------
  716|      0|      std::allocator<T> alloc;
  717|      0|      return std::allocator_traits<std::allocator<T>>::allocate(alloc, 1);
  718|      0|    }
  719|      0|    case FlagOp::kDelete: {
  ------------------
  |  Branch (719:5): [True: 0, False: 12]
  ------------------
  720|      0|      T* p = static_cast<T*>(v2);
  721|      0|      p->~T();
  722|      0|      std::allocator<T> alloc;
  723|      0|      std::allocator_traits<std::allocator<T>>::deallocate(alloc, p, 1);
  724|      0|      return nullptr;
  725|      0|    }
  726|      0|    case FlagOp::kCopy:
  ------------------
  |  Branch (726:5): [True: 0, False: 12]
  ------------------
  727|      0|      *static_cast<T*>(v2) = *static_cast<const T*>(v1);
  728|      0|      return nullptr;
  729|      0|    case FlagOp::kCopyConstruct:
  ------------------
  |  Branch (729:5): [True: 0, False: 12]
  ------------------
  730|      0|      new (v2) T(*static_cast<const T*>(v1));
  731|      0|      return nullptr;
  732|      4|    case FlagOp::kSizeof:
  ------------------
  |  Branch (732:5): [True: 4, False: 8]
  ------------------
  733|      4|      return reinterpret_cast<void*>(static_cast<uintptr_t>(sizeof(T)));
  734|      0|    case FlagOp::kFastTypeId:
  ------------------
  |  Branch (734:5): [True: 0, False: 12]
  ------------------
  735|      0|      return const_cast<void*>(base_internal::FastTypeId<T>());
  736|      0|    case FlagOp::kRuntimeTypeId:
  ------------------
  |  Branch (736:5): [True: 0, False: 12]
  ------------------
  737|      0|      return const_cast<std::type_info*>(GenRuntimeTypeId<T>());
  738|      0|    case FlagOp::kParse: {
  ------------------
  |  Branch (738:5): [True: 0, False: 12]
  ------------------
  739|       |      // Initialize the temporary instance of type T based on current value in
  740|       |      // destination (which is going to be flag's default value).
  741|      0|      T temp(*static_cast<T*>(v2));
  742|      0|      if (!absl::ParseFlag<T>(*static_cast<const absl::string_view*>(v1), &temp,
  ------------------
  |  Branch (742:11): [True: 0, False: 0]
  ------------------
  743|      0|                              static_cast<std::string*>(v3))) {
  744|      0|        return nullptr;
  745|      0|      }
  746|      0|      *static_cast<T*>(v2) = std::move(temp);
  747|      0|      return v2;
  748|      0|    }
  749|      0|    case FlagOp::kUnparse:
  ------------------
  |  Branch (749:5): [True: 0, False: 12]
  ------------------
  750|      0|      *static_cast<std::string*>(v2) =
  751|      0|          absl::UnparseFlag<T>(*static_cast<const T*>(v1));
  752|      0|      return nullptr;
  753|      8|    case FlagOp::kValueOffset: {
  ------------------
  |  Branch (753:5): [True: 8, False: 4]
  ------------------
  754|       |      // Round sizeof(FlagImp) to a multiple of alignof(FlagValue<T>) to get the
  755|       |      // offset of the data.
  756|      8|      size_t round_to = alignof(FlagValue<T>);
  757|      8|      size_t offset =
  758|      8|          (sizeof(FlagImpl) + round_to - 1) / round_to * round_to;
  759|      8|      return reinterpret_cast<void*>(offset);
  760|      0|    }
  761|     12|  }
  762|      0|  return nullptr;
  763|     12|}
_ZN4absl12lts_2024011614flags_internal13FlagRegistrarImLb1EEC2ERNS1_4FlagImEEPKc:
  773|      4|  explicit FlagRegistrar(Flag<T>& flag, const char* filename) : flag_(flag) {
  774|      4|    if (do_register)
  ------------------
  |  Branch (774:9): [True: 4, Folded]
  ------------------
  775|      4|      flags_internal::RegisterCommandLineFlag(flag_.impl_, filename);
  776|      4|  }
_ZNK4absl12lts_2024011614flags_internal13FlagRegistrarImLb1EEcvNS1_18FlagRegistrarEmptyEEv:
  786|      4|  operator FlagRegistrarEmpty() const { return {}; }  // NOLINT
_ZN4absl12lts_2024011614flags_internal12FlagImplPeer9InvokeGetINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS1_4FlagISA_EEEET_RKT0_:
  697|      4|  static T InvokeGet(const FlagType& flag) {
  698|      4|    return flag.Get();
  699|      4|  }
_ZNK4absl12lts_2024011614flags_internal4FlagINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE3GetEv:
  657|      4|  T Get() const {
  658|       |    // See implementation notes in CommandLineFlag::Get().
  659|      4|    union U {
  660|      4|      T value;
  661|      4|      U() {}
  662|      4|      ~U() { value.~T(); }
  663|      4|    };
  664|      4|    U u;
  665|       |
  666|       |#if !defined(NDEBUG)
  667|       |    impl_.AssertValidType(base_internal::FastTypeId<T>(), &GenRuntimeTypeId<T>);
  668|       |#endif
  669|       |
  670|      4|    if (ABSL_PREDICT_FALSE(!value_.Get(impl_.seq_lock_, u.value))) {
  ------------------
  |  |  178|      4|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 4, False: 0]
  |  |  |  Branch (178:49): [Folded, False: 4]
  |  |  |  Branch (178:58): [True: 4, False: 0]
  |  |  ------------------
  ------------------
  671|      4|      impl_.Read(&u.value);
  672|      4|    }
  673|      4|    return std::move(u.value);
  674|      4|  }
_ZZNK4absl12lts_2024011614flags_internal4FlagINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE3GetEvEN1UC2Ev:
  661|      4|      U() {}
_ZNK4absl12lts_2024011614flags_internal9FlagValueINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEELNS1_20FlagValueStorageKindE3EE3GetERKNS1_12SequenceLockERS9_:
  397|      4|  bool Get(const SequenceLock&, T&) const { return false; }
_ZZNK4absl12lts_2024011614flags_internal4FlagINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE3GetEvEN1UD2Ev:
  662|      4|      ~U() { value.~T(); }
_ZNK4absl12lts_2024011614flags_internal8FlagImpl16ValueStorageKindEv:
  537|     54|  FlagValueStorageKind ValueStorageKind() const {
  538|     54|    return static_cast<FlagValueStorageKind>(value_storage_kind_);
  539|     54|  }
_ZNK4absl12lts_2024011614flags_internal8FlagImpl11DefaultKindEv:
  541|      2|      ABSL_EXCLUSIVE_LOCKS_REQUIRED(*DataGuard()) {
  542|      2|    return static_cast<FlagDefaultKind>(def_kind_);
  543|      2|  }
_ZN4absl12lts_2024011614flags_internal5AllocEPFPvNS1_6FlagOpEPKvS2_S2_E:
   97|      2|inline void* Alloc(FlagOpFn op) {
   98|      2|  return op(FlagOp::kAlloc, nullptr, nullptr, nullptr);
   99|      2|}
_ZN4absl12lts_2024011614flags_internal6DeleteEPFPvNS1_6FlagOpEPKvS2_S2_ES2_:
  101|      2|inline void Delete(FlagOpFn op, void* obj) {
  102|      2|  op(FlagOp::kDelete, nullptr, obj, nullptr);
  103|      2|}
_ZN4absl12lts_2024011614flags_internal4CopyEPFPvNS1_6FlagOpEPKvS2_S2_ES5_S2_:
  105|      2|inline void Copy(FlagOpFn op, const void* src, void* dst) {
  106|      2|  op(FlagOp::kCopy, src, dst, nullptr);
  107|      2|}
_ZN4absl12lts_2024011614flags_internal13CopyConstructEPFPvNS1_6FlagOpEPKvS2_S2_ES5_S2_:
  110|     14|inline void CopyConstruct(FlagOpFn op, const void* src, void* dst) {
  111|     14|  op(FlagOp::kCopyConstruct, src, dst, nullptr);
  112|     14|}
_ZN4absl12lts_2024011614flags_internal5ParseEPFPvNS1_6FlagOpEPKvS2_S2_ENSt3__117basic_string_viewIcNS8_11char_traitsIcEEEES2_PNS8_12basic_stringIcSB_NS8_9allocatorIcEEEE:
  121|      2|                  std::string* error) {
  122|      2|  return op(FlagOp::kParse, &text, dst, error) != nullptr;
  123|      2|}
_ZN4absl12lts_2024011614flags_internal6SizeofEPFPvNS1_6FlagOpEPKvS2_S2_E:
  131|     20|inline size_t Sizeof(FlagOpFn op) {
  132|       |  // This sequence of casts reverses the sequence from
  133|       |  // `flags_internal::FlagOps()`
  134|     20|  return static_cast<size_t>(reinterpret_cast<intptr_t>(
  135|     20|      op(FlagOp::kSizeof, nullptr, nullptr, nullptr)));
  136|     20|}
_ZN4absl12lts_2024011614flags_internal10FastTypeIdEPFPvNS1_6FlagOpEPKvS2_S2_E:
  138|      2|inline FlagFastTypeId FastTypeId(FlagOpFn op) {
  139|      2|  return reinterpret_cast<FlagFastTypeId>(
  140|      2|      op(FlagOp::kFastTypeId, nullptr, nullptr, nullptr));
  141|      2|}
_ZN4absl12lts_2024011614flags_internal11ValueOffsetEPFPvNS1_6FlagOpEPKvS2_S2_E:
  151|     52|inline ptrdiff_t ValueOffset(FlagOpFn op) {
  152|       |  // This sequence of casts reverses the sequence from
  153|       |  // `flags_internal::FlagOps()`
  154|     52|  return static_cast<ptrdiff_t>(reinterpret_cast<intptr_t>(
  155|     52|      op(FlagOp::kValueOffset, nullptr, nullptr, nullptr)));
  156|     52|}
_ZN4absl12lts_2024011614flags_internal16InitDefaultValueINSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEEEET_NS1_11EmptyBracesE:
  282|      6|constexpr T InitDefaultValue(EmptyBraces) {
  283|      6|  return T{};
  284|      6|}
_ZN4absl12lts_2024011614flags_internal7FlagOpsINSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEEEEPvNS1_6FlagOpEPKvSD_SD_:
  713|     26|void* FlagOps(FlagOp op, const void* v1, void* v2, void* v3) {
  714|     26|  switch (op) {
  ------------------
  |  Branch (714:11): [True: 26, False: 0]
  ------------------
  715|      0|    case FlagOp::kAlloc: {
  ------------------
  |  Branch (715:5): [True: 0, False: 26]
  ------------------
  716|      0|      std::allocator<T> alloc;
  717|      0|      return std::allocator_traits<std::allocator<T>>::allocate(alloc, 1);
  718|      0|    }
  719|      0|    case FlagOp::kDelete: {
  ------------------
  |  Branch (719:5): [True: 0, False: 26]
  ------------------
  720|      0|      T* p = static_cast<T*>(v2);
  721|      0|      p->~T();
  722|      0|      std::allocator<T> alloc;
  723|      0|      std::allocator_traits<std::allocator<T>>::deallocate(alloc, p, 1);
  724|      0|      return nullptr;
  725|      0|    }
  726|      0|    case FlagOp::kCopy:
  ------------------
  |  Branch (726:5): [True: 0, False: 26]
  ------------------
  727|      0|      *static_cast<T*>(v2) = *static_cast<const T*>(v1);
  728|      0|      return nullptr;
  729|     10|    case FlagOp::kCopyConstruct:
  ------------------
  |  Branch (729:5): [True: 10, False: 16]
  ------------------
  730|     10|      new (v2) T(*static_cast<const T*>(v1));
  731|     10|      return nullptr;
  732|      0|    case FlagOp::kSizeof:
  ------------------
  |  Branch (732:5): [True: 0, False: 26]
  ------------------
  733|      0|      return reinterpret_cast<void*>(static_cast<uintptr_t>(sizeof(T)));
  734|      0|    case FlagOp::kFastTypeId:
  ------------------
  |  Branch (734:5): [True: 0, False: 26]
  ------------------
  735|      0|      return const_cast<void*>(base_internal::FastTypeId<T>());
  736|      0|    case FlagOp::kRuntimeTypeId:
  ------------------
  |  Branch (736:5): [True: 0, False: 26]
  ------------------
  737|      0|      return const_cast<std::type_info*>(GenRuntimeTypeId<T>());
  738|      0|    case FlagOp::kParse: {
  ------------------
  |  Branch (738:5): [True: 0, False: 26]
  ------------------
  739|       |      // Initialize the temporary instance of type T based on current value in
  740|       |      // destination (which is going to be flag's default value).
  741|      0|      T temp(*static_cast<T*>(v2));
  742|      0|      if (!absl::ParseFlag<T>(*static_cast<const absl::string_view*>(v1), &temp,
  ------------------
  |  Branch (742:11): [True: 0, False: 0]
  ------------------
  743|      0|                              static_cast<std::string*>(v3))) {
  744|      0|        return nullptr;
  745|      0|      }
  746|      0|      *static_cast<T*>(v2) = std::move(temp);
  747|      0|      return v2;
  748|      0|    }
  749|      0|    case FlagOp::kUnparse:
  ------------------
  |  Branch (749:5): [True: 0, False: 26]
  ------------------
  750|      0|      *static_cast<std::string*>(v2) =
  751|      0|          absl::UnparseFlag<T>(*static_cast<const T*>(v1));
  752|      0|      return nullptr;
  753|     16|    case FlagOp::kValueOffset: {
  ------------------
  |  Branch (753:5): [True: 16, False: 10]
  ------------------
  754|       |      // Round sizeof(FlagImp) to a multiple of alignof(FlagValue<T>) to get the
  755|       |      // offset of the data.
  756|     16|      size_t round_to = alignof(FlagValue<T>);
  757|     16|      size_t offset =
  758|     16|          (sizeof(FlagImpl) + round_to - 1) / round_to * round_to;
  759|     16|      return reinterpret_cast<void*>(offset);
  760|      0|    }
  761|     26|  }
  762|      0|  return nullptr;
  763|     26|}
_ZN4absl12lts_2024011614flags_internal13FlagRegistrarINSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEELb1EEC2ERNS1_4FlagISC_EEPKc:
  773|      8|  explicit FlagRegistrar(Flag<T>& flag, const char* filename) : flag_(flag) {
  774|      8|    if (do_register)
  ------------------
  |  Branch (774:9): [True: 8, Folded]
  ------------------
  775|      8|      flags_internal::RegisterCommandLineFlag(flag_.impl_, filename);
  776|      8|  }
_ZNO4absl12lts_2024011614flags_internal13FlagRegistrarINSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEELb1EE8OnUpdateEPFvvE:
  778|      6|  FlagRegistrar OnUpdate(FlagCallbackFunc cb) && {
  779|      6|    flag_.impl_.SetCallback(cb);
  780|      6|    return *this;
  781|      6|  }
_ZN4absl12lts_2024011614flags_internal12FlagImplPeer9InvokeGetINSt3__16vectorINS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS9_ISB_EEEENS1_4FlagISD_EEEET_RKT0_:
  697|     10|  static T InvokeGet(const FlagType& flag) {
  698|     10|    return flag.Get();
  699|     10|  }
_ZNK4absl12lts_2024011614flags_internal4FlagINSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEEE3GetEv:
  657|     10|  T Get() const {
  658|       |    // See implementation notes in CommandLineFlag::Get().
  659|     10|    union U {
  660|     10|      T value;
  661|     10|      U() {}
  662|     10|      ~U() { value.~T(); }
  663|     10|    };
  664|     10|    U u;
  665|       |
  666|       |#if !defined(NDEBUG)
  667|       |    impl_.AssertValidType(base_internal::FastTypeId<T>(), &GenRuntimeTypeId<T>);
  668|       |#endif
  669|       |
  670|     10|    if (ABSL_PREDICT_FALSE(!value_.Get(impl_.seq_lock_, u.value))) {
  ------------------
  |  |  178|     10|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 10, False: 0]
  |  |  |  Branch (178:49): [Folded, False: 10]
  |  |  |  Branch (178:58): [True: 10, False: 0]
  |  |  ------------------
  ------------------
  671|     10|      impl_.Read(&u.value);
  672|     10|    }
  673|     10|    return std::move(u.value);
  674|     10|  }
_ZZNK4absl12lts_2024011614flags_internal4FlagINSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEEE3GetEvEN1UC2Ev:
  661|     10|      U() {}
_ZNK4absl12lts_2024011614flags_internal9FlagValueINSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEELNS1_20FlagValueStorageKindE3EE3GetERKNS1_12SequenceLockERSC_:
  397|     10|  bool Get(const SequenceLock&, T&) const { return false; }
_ZZNK4absl12lts_2024011614flags_internal4FlagINSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEEE3GetEvEN1UD2Ev:
  662|     10|      ~U() { value.~T(); }
_ZNK4absl12lts_2024011614flags_internal13FlagRegistrarINSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEELb1EEcvNS1_18FlagRegistrarEmptyEEv:
  786|      8|  operator FlagRegistrarEmpty() const { return {}; }  // NOLINT

_ZN4absl12lts_2024011614flags_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_2024011614flags_internal21ProgramInvocationNameEv:
   36|      2|std::string ProgramInvocationName() {
   37|      2|  absl::MutexLock l(&program_name_guard);
   38|       |
   39|      2|  return program_name ? *program_name : "UNKNOWN";
  ------------------
  |  Branch (39:10): [True: 0, False: 2]
  ------------------
   40|      2|}
_ZN4absl12lts_2024011614flags_internal24SetProgramInvocationNameENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
   49|      2|void SetProgramInvocationName(absl::string_view prog_name_str) {
   50|      2|  absl::MutexLock l(&program_name_guard);
   51|       |
   52|      2|  if (!program_name)
  ------------------
  |  Branch (52:7): [True: 2, False: 0]
  ------------------
   53|      2|    program_name = new std::string(prog_name_str);
   54|      0|  else
   55|      0|    program_name->assign(prog_name_str.data(), prog_name_str.size());
   56|      2|}

_ZNK4absl12lts_2024011614flags_internal12SequenceLock7TryReadEPvPKNSt3__16atomicImEEm:
   80|      8|  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|      8|    int64_t seq_before = lock_.load(std::memory_order_acquire);
   84|      8|    if (ABSL_PREDICT_FALSE(seq_before & 1) == 1) return false;
  ------------------
  |  |  178|      8|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:49): [Folded, False: 8]
  |  |  |  Branch (178:58): [True: 4, False: 4]
  |  |  ------------------
  ------------------
  |  Branch (84:9): [True: 4, False: 4]
  ------------------
   85|      4|    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|      4|    std::atomic_thread_fence(std::memory_order_acquire);
   89|      4|    int64_t seq_after = lock_.load(std::memory_order_relaxed);
   90|      4|    return ABSL_PREDICT_TRUE(seq_before == seq_after);
  ------------------
  |  |  179|      4|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (179:48): [Folded, False: 4]
  |  |  |  Branch (179:57): [True: 4, False: 0]
  |  |  ------------------
  ------------------
   91|      8|  }
_ZN4absl12lts_2024011614flags_internal12SequenceLock21RelaxedCopyFromAtomicEPvPKNSt3__16atomicImEEm:
  144|      4|                                    size_t size) {
  145|      4|    char* dst_byte = static_cast<char*>(dst);
  146|      8|    while (size >= sizeof(uint64_t)) {
  ------------------
  |  Branch (146:12): [True: 4, False: 4]
  ------------------
  147|      4|      uint64_t word = src->load(std::memory_order_relaxed);
  148|      4|      std::memcpy(dst_byte, &word, sizeof(word));
  149|      4|      dst_byte += sizeof(word);
  150|      4|      src++;
  151|      4|      size -= sizeof(word);
  152|      4|    }
  153|      4|    if (size > 0) {
  ------------------
  |  Branch (153:9): [True: 4, False: 0]
  ------------------
  154|      4|      uint64_t word = src->load(std::memory_order_relaxed);
  155|      4|      std::memcpy(dst_byte, &word, size);
  156|      4|    }
  157|      4|  }
_ZN4absl12lts_2024011614flags_internal12SequenceLock15MarkInitializedEv:
   63|     24|  void MarkInitialized() {
   64|       |    assert(lock_.load(std::memory_order_relaxed) == kUninitialized);
   65|     24|    lock_.store(0, std::memory_order_release);
   66|     24|  }
_ZN4absl12lts_2024011614flags_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_2024011614flags_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_2024011614flags_internal16GetFlagsHelpModeEv:
  459|      4|HelpMode GetFlagsHelpMode() {
  460|      4|  absl::MutexLock l(&help_attributes_guard);
  461|      4|  return help_mode;
  462|      4|}
_ZN4absl12lts_2024011614flags_internal9MaybeExitENS1_8HelpModeE:
  539|      2|void MaybeExit(HelpMode mode) {
  540|      2|  switch (mode) {
  541|      2|    case flags_internal::HelpMode::kNone:
  ------------------
  |  Branch (541:5): [True: 2, False: 0]
  ------------------
  542|      2|      return;
  543|      0|    case flags_internal::HelpMode::kOnlyCheckArgs:
  ------------------
  |  Branch (543:5): [True: 0, False: 2]
  ------------------
  544|      0|    case flags_internal::HelpMode::kVersion:
  ------------------
  |  Branch (544:5): [True: 0, False: 2]
  ------------------
  545|      0|      std::exit(0);
  546|      0|    default:  // For all the other modes we exit with 1
  ------------------
  |  Branch (546:5): [True: 0, False: 2]
  ------------------
  547|      0|      std::exit(1);
  548|      2|  }
  549|      2|}

_ZN4absl12lts_2024011614flags_internal13AbslParseFlagENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPNS2_12basic_stringIcS5_NS2_9allocatorIcEEEESB_:
  172|      2|bool AbslParseFlag(absl::string_view text, std::string* dst, std::string*) {
  173|      2|  dst->assign(text.data(), text.size());
  174|      2|  return true;
  175|      2|}

_ZN4absl12lts_202401169ParseFlagINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEbNS2_17basic_string_viewIcS5_EEPT_PS8_:
  333|      2|inline bool ParseFlag(absl::string_view input, T* dst, std::string* error) {
  334|      2|  return flags_internal::InvokeParseFlag(input, dst, error);
  335|      2|}
_ZN4absl12lts_2024011614flags_internal15InvokeParseFlagINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEbNS3_17basic_string_viewIcS6_EEPT_PS9_:
  275|      2|bool InvokeParseFlag(absl::string_view input, T* dst, std::string* err) {
  276|       |  // Comment on next line provides a good compiler error message if T
  277|       |  // does not have AbslParseFlag(absl::string_view, T*, std::string*).
  278|      2|  return AbslParseFlag(input, dst, err);  // Is T missing AbslParseFlag?
  279|      2|}

_ZN4absl12lts_2024011614flags_internal24ParseAbseilFlagsOnlyImplEiPPcRNSt3__16vectorIS2_NS4_9allocatorIS2_EEEERNS5_INS0_16UnrecognizedFlagENS6_ISA_EEEENS1_16UsageFlagsActionE:
  744|      2|    UsageFlagsAction usage_flag_action) {
  745|      2|  ABSL_INTERNAL_CHECK(argc > 0, "Missing argv[0]");
  ------------------
  |  |   85|      2|  do {                                                             \
  |  |   86|      2|    if (ABSL_PREDICT_FALSE(!(condition))) {                        \
  |  |  ------------------
  |  |  |  |  178|      2|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (178:31): [True: 0, False: 2]
  |  |  |  |  |  Branch (178:49): [Folded, False: 2]
  |  |  |  |  |  Branch (178: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()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  225|      0|  do {                                           \
  |  |  |  |  |  |  |  |  226|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  227|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  228|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  203|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  229|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (229: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]
  |  |  ------------------
  ------------------
  746|       |
  747|      2|  using flags_internal::ArgsList;
  748|      2|  using flags_internal::specified_flags;
  749|       |
  750|      2|  std::vector<std::string> flagfile_value;
  751|      2|  std::vector<ArgsList> input_args;
  752|       |
  753|       |  // Once parsing has started we will not allow more flag registrations.
  754|      2|  flags_internal::FinalizeRegistry();
  755|       |
  756|       |  // This routine does not return anything since we abort on failure.
  757|      2|  flags_internal::CheckDefaultValuesParsingRoundtrip();
  758|       |
  759|      2|  input_args.push_back(ArgsList(argc, argv));
  760|       |
  761|       |  // Set program invocation name if it is not set before.
  762|      2|  if (flags_internal::ProgramInvocationName() == "UNKNOWN") {
  ------------------
  |  Branch (762:7): [True: 2, False: 0]
  ------------------
  763|      2|    flags_internal::SetProgramInvocationName(argv[0]);
  764|      2|  }
  765|      2|  positional_args.push_back(argv[0]);
  766|       |
  767|      2|  absl::MutexLock l(&flags_internal::specified_flags_guard);
  768|      2|  if (specified_flags == nullptr) {
  ------------------
  |  Branch (768:7): [True: 2, False: 0]
  ------------------
  769|      2|    specified_flags = new std::vector<const CommandLineFlag*>;
  770|      2|  } else {
  771|      0|    specified_flags->clear();
  772|      0|  }
  773|       |
  774|       |  // Iterate through the list of the input arguments. First level are
  775|       |  // arguments originated from argc/argv. Following levels are arguments
  776|       |  // originated from recursive parsing of flagfile(s).
  777|      2|  bool success = true;
  778|      4|  while (!input_args.empty()) {
  ------------------
  |  Branch (778:10): [True: 4, False: 0]
  ------------------
  779|       |    // First we process the built-in generator flags.
  780|      4|    success &= flags_internal::HandleGeneratorFlags(input_args, flagfile_value);
  781|       |
  782|       |    // Select top-most (most recent) arguments list. If it is empty drop it
  783|       |    // and re-try.
  784|      4|    ArgsList& curr_list = input_args.back();
  785|       |
  786|       |    // Every ArgsList starts with real or fake program name, so we can always
  787|       |    // start by skipping it.
  788|      4|    curr_list.PopFront();
  789|       |
  790|      4|    if (curr_list.Size() == 0) {
  ------------------
  |  Branch (790:9): [True: 0, False: 4]
  ------------------
  791|      0|      input_args.pop_back();
  792|      0|      continue;
  793|      0|    }
  794|       |
  795|       |    // Handle the next argument in the current list. If the stack of argument
  796|       |    // lists contains only one element - we are processing an argument from
  797|       |    // the original argv.
  798|      4|    absl::string_view arg(curr_list.Front());
  799|      4|    bool arg_from_argv = input_args.size() == 1;
  800|       |
  801|       |    // If argument does not start with '-' or is just "-" - this is
  802|       |    // positional argument.
  803|      4|    if (!absl::ConsumePrefix(&arg, "-") || arg.empty()) {
  ------------------
  |  Branch (803:9): [True: 0, False: 4]
  |  Branch (803:44): [True: 0, False: 4]
  ------------------
  804|      0|      ABSL_INTERNAL_CHECK(arg_from_argv,
  ------------------
  |  |   85|      0|  do {                                                             \
  |  |   86|      0|    if (ABSL_PREDICT_FALSE(!(condition))) {                        \
  |  |  ------------------
  |  |  |  |  178|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (178:31): [True: 0, False: 0]
  |  |  |  |  |  Branch (178:49): [Folded, False: 0]
  |  |  |  |  |  Branch (178: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()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  225|      0|  do {                                           \
  |  |  |  |  |  |  |  |  226|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  227|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  228|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  203|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  229|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (229: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]
  |  |  ------------------
  ------------------
  805|      0|                          "Flagfile cannot contain positional argument");
  806|       |
  807|      0|      positional_args.push_back(argv[curr_list.FrontIndex()]);
  808|      0|      continue;
  809|      0|    }
  810|       |
  811|       |    // Split the current argument on '=' to deduce the argument flag name and
  812|       |    // value. If flag name is empty it means we've got an "--" argument. Value
  813|       |    // can be empty either if there were no '=' in argument string at all or
  814|       |    // an argument looked like "--foo=". In a latter case is_empty_value is
  815|       |    // true.
  816|      4|    absl::string_view flag_name;
  817|      4|    absl::string_view value;
  818|      4|    bool is_empty_value = false;
  819|       |
  820|      4|    std::tie(flag_name, value, is_empty_value) =
  821|      4|        flags_internal::SplitNameAndValue(arg);
  822|       |
  823|       |    // Standalone "--" argument indicates that the rest of the arguments are
  824|       |    // positional. We do not support positional arguments in flagfiles.
  825|      4|    if (flag_name.empty()) {
  ------------------
  |  Branch (825:9): [True: 2, False: 2]
  ------------------
  826|      2|      ABSL_INTERNAL_CHECK(arg_from_argv,
  ------------------
  |  |   85|      2|  do {                                                             \
  |  |   86|      2|    if (ABSL_PREDICT_FALSE(!(condition))) {                        \
  |  |  ------------------
  |  |  |  |  178|      2|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (178:31): [True: 0, False: 2]
  |  |  |  |  |  Branch (178:49): [Folded, False: 2]
  |  |  |  |  |  Branch (178: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()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  225|      0|  do {                                           \
  |  |  |  |  |  |  |  |  226|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  227|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  228|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  203|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  229|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (229: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]
  |  |  ------------------
  ------------------
  827|      2|                          "Flagfile cannot contain positional argument");
  828|       |
  829|      2|      curr_list.PopFront();
  830|      2|      break;
  831|      2|    }
  832|       |
  833|       |    // Locate the flag based on flag name. Handle both --foo and --nofoo.
  834|      2|    CommandLineFlag* flag = nullptr;
  835|      2|    bool is_negative = false;
  836|      2|    std::tie(flag, is_negative) = flags_internal::LocateFlag(flag_name);
  837|       |
  838|      2|    if (flag == nullptr) {
  ------------------
  |  Branch (838:9): [True: 0, False: 2]
  ------------------
  839|       |      // Usage flags are not modeled as Abseil flags. Locate them separately.
  840|      0|      if (flags_internal::DeduceUsageFlags(flag_name, value)) {
  ------------------
  |  Branch (840:11): [True: 0, False: 0]
  ------------------
  841|      0|        continue;
  842|      0|      }
  843|      0|      unrecognized_flags.emplace_back(arg_from_argv
  ------------------
  |  Branch (843:39): [True: 0, False: 0]
  ------------------
  844|      0|                                          ? UnrecognizedFlag::kFromArgv
  845|      0|                                          : UnrecognizedFlag::kFromFlagfile,
  846|      0|                                      flag_name);
  847|      0|      continue;
  848|      0|    }
  849|       |
  850|       |    // Deduce flag's value (from this or next argument).
  851|      2|    bool value_success = true;
  852|      2|    std::tie(value_success, value) = flags_internal::DeduceFlagValue(
  853|      2|        *flag, value, is_negative, is_empty_value, &curr_list);
  854|      2|    success &= value_success;
  855|       |
  856|       |    // Set the located flag to a new value, unless it is retired. Setting
  857|       |    // retired flag fails, but we ignoring it here while also reporting access
  858|       |    // to retired flag.
  859|      2|    std::string error;
  860|      2|    if (!flags_internal::PrivateHandleAccessor::ParseFrom(
  ------------------
  |  Branch (860:9): [True: 0, False: 2]
  ------------------
  861|      2|            *flag, value, flags_internal::SET_FLAGS_VALUE,
  862|      2|            flags_internal::kCommandLine, error)) {
  863|      0|      if (flag->IsRetired()) continue;
  ------------------
  |  Branch (863:11): [True: 0, False: 0]
  ------------------
  864|       |
  865|      0|      flags_internal::ReportUsageError(error, true);
  866|      0|      success = false;
  867|      2|    } else {
  868|      2|      specified_flags->push_back(flag);
  869|      2|    }
  870|      2|  }
  871|       |
  872|      2|  flags_internal::ResetGeneratorFlags(flagfile_value);
  873|       |
  874|       |  // All the remaining arguments are positional.
  875|      2|  if (!input_args.empty()) {
  ------------------
  |  Branch (875:7): [True: 2, False: 0]
  ------------------
  876|      2|    for (size_t arg_index = input_args.back().FrontIndex();
  877|     11|         arg_index < static_cast<size_t>(argc); ++arg_index) {
  ------------------
  |  Branch (877:10): [True: 9, False: 2]
  ------------------
  878|      9|      positional_args.push_back(argv[arg_index]);
  879|      9|    }
  880|      2|  }
  881|       |
  882|       |  // Trim and sort the vector.
  883|      2|  specified_flags->shrink_to_fit();
  884|      2|  std::sort(specified_flags->begin(), specified_flags->end(),
  885|      2|            flags_internal::SpecifiedFlagsCompare{});
  886|       |
  887|       |  // Filter out unrecognized flags, which are ok to ignore.
  888|      2|  std::vector<UnrecognizedFlag> filtered;
  889|      2|  filtered.reserve(unrecognized_flags.size());
  890|      2|  for (const auto& unrecognized : unrecognized_flags) {
  ------------------
  |  Branch (890:33): [True: 0, False: 2]
  ------------------
  891|      0|    if (flags_internal::CanIgnoreUndefinedFlag(unrecognized.flag_name))
  ------------------
  |  Branch (891:9): [True: 0, False: 0]
  ------------------
  892|      0|      continue;
  893|      0|    filtered.push_back(unrecognized);
  894|      0|  }
  895|       |
  896|      2|  std::swap(unrecognized_flags, filtered);
  897|       |
  898|      2|  if (!success) {
  ------------------
  |  Branch (898:7): [True: 0, False: 2]
  ------------------
  899|       |#if ABSL_FLAGS_STRIP_NAMES
  900|       |    flags_internal::ReportUsageError(
  901|       |        "NOTE: command line flags are disabled in this build", true);
  902|       |#else
  903|      0|    flags_internal::HandleUsageFlags(std::cerr, ProgramUsageMessage());
  904|      0|#endif
  905|      0|    return HelpMode::kFull;  // We just need to make sure the exit with
  906|       |                             // code 1.
  907|      0|  }
  908|       |
  909|      2|  return usage_flag_action == UsageFlagsAction::kHandleUsage
  ------------------
  |  Branch (909:10): [True: 2, False: 0]
  ------------------
  910|      2|             ? flags_internal::HandleUsageFlags(std::cout,
  911|      2|                                                ProgramUsageMessage())
  912|      2|             : HelpMode::kNone;
  913|      2|}
_ZN4absl12lts_2024011620ParseAbseilFlagsOnlyEiPPcRNSt3__16vectorIS1_NS3_9allocatorIS1_EEEERNS4_INS0_16UnrecognizedFlagENS5_IS9_EEEE:
  919|      2|                          std::vector<UnrecognizedFlag>& unrecognized_flags) {
  920|      2|  auto help_mode = flags_internal::ParseAbseilFlagsOnlyImpl(
  921|      2|      argc, argv, positional_args, unrecognized_flags,
  922|      2|      flags_internal::UsageFlagsAction::kHandleUsage);
  923|       |
  924|      2|  flags_internal::MaybeExit(help_mode);
  925|      2|}
parse.cc:_ZNK3$_0clEv:
  106|      2|    .OnUpdate([]() {
  107|      2|      if (absl::GetFlag(FLAGS_flagfile).empty()) return;
  ------------------
  |  Branch (107:11): [True: 2, False: 0]
  ------------------
  108|       |
  109|      0|      absl::MutexLock l(&absl::flags_internal::processing_checks_guard);
  110|       |
  111|       |      // Setting this flag twice before it is handled most likely an internal
  112|       |      // error and should be reviewed by developers.
  113|      0|      if (absl::flags_internal::flagfile_needs_processing) {
  ------------------
  |  Branch (113:11): [True: 0, False: 0]
  ------------------
  114|      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]
  |  |  ------------------
  ------------------
  115|      0|      }
  116|       |
  117|      0|      absl::flags_internal::flagfile_needs_processing = true;
  118|      0|    });
parse.cc:_ZNK3$_1clEv:
  122|      2|    .OnUpdate([]() {
  123|      2|      if (absl::GetFlag(FLAGS_fromenv).empty()) return;
  ------------------
  |  Branch (123:11): [True: 2, False: 0]
  ------------------
  124|       |
  125|      0|      absl::MutexLock l(&absl::flags_internal::processing_checks_guard);
  126|       |
  127|       |      // Setting this flag twice before it is handled most likely an internal
  128|       |      // error and should be reviewed by developers.
  129|      0|      if (absl::flags_internal::fromenv_needs_processing) {
  ------------------
  |  Branch (129:11): [True: 0, False: 0]
  ------------------
  130|      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]
  |  |  ------------------
  ------------------
  131|      0|      }
  132|       |
  133|      0|      absl::flags_internal::fromenv_needs_processing = true;
  134|      0|    });
parse.cc:_ZNK3$_2clEv:
  138|      2|    .OnUpdate([]() {
  139|      2|      if (absl::GetFlag(FLAGS_tryfromenv).empty()) return;
  ------------------
  |  Branch (139:11): [True: 2, False: 0]
  ------------------
  140|       |
  141|      0|      absl::MutexLock l(&absl::flags_internal::processing_checks_guard);
  142|       |
  143|       |      // Setting this flag twice before it is handled most likely an internal
  144|       |      // error and should be reviewed by developers.
  145|      0|      if (absl::flags_internal::tryfromenv_needs_processing) {
  ------------------
  |  Branch (145:11): [True: 0, False: 0]
  ------------------
  146|      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]
  |  |  ------------------
  ------------------
  147|      0|                          "tryfromenv set twice before it is handled.");
  148|      0|      }
  149|       |
  150|      0|      absl::flags_internal::tryfromenv_needs_processing = true;
  151|      0|    });
parse.cc:_ZN4absl12lts_2024011614flags_internal12_GLOBAL__N_134CheckDefaultValuesParsingRoundtripEv:
  322|      2|void CheckDefaultValuesParsingRoundtrip() {
  323|       |#ifndef NDEBUG
  324|       |  flags_internal::ForEachFlag([&](CommandLineFlag& flag) {
  325|       |    if (flag.IsRetired()) return;
  326|       |
  327|       |#define ABSL_FLAGS_INTERNAL_IGNORE_TYPE(T, _) \
  328|       |  if (flag.IsOfType<T>()) return;
  329|       |
  330|       |    ABSL_FLAGS_INTERNAL_SUPPORTED_TYPES(ABSL_FLAGS_INTERNAL_IGNORE_TYPE)
  331|       |#undef ABSL_FLAGS_INTERNAL_IGNORE_TYPE
  332|       |
  333|       |    flags_internal::PrivateHandleAccessor::CheckDefaultValueParsingRoundtrip(
  334|       |        flag);
  335|       |  });
  336|       |#endif
  337|      2|}
parse.cc:_ZN4absl12lts_2024011614flags_internal12_GLOBAL__N_18ArgsListC2EiPPc:
  169|      2|  ArgsList(int argc, char* argv[]) : args_(argv, argv + argc), next_arg_(0) {}
parse.cc:_ZN4absl12lts_2024011614flags_internal12_GLOBAL__N_120HandleGeneratorFlagsERNSt3__16vectorINS2_8ArgsListENS3_9allocatorIS5_EEEERNS4_INS3_12basic_stringIcNS3_11char_traitsIcEENS6_IcEEEENS6_ISE_EEEE:
  415|      4|                          std::vector<std::string>& flagfile_value) {
  416|      4|  bool success = true;
  417|       |
  418|      4|  absl::MutexLock l(&flags_internal::processing_checks_guard);
  419|       |
  420|       |  // flagfile could have been set either on a command line or
  421|       |  // programmatically before invoking ParseCommandLine. Note that we do not
  422|       |  // actually process arguments specified in the flagfile, but instead
  423|       |  // create a secondary arguments list to be processed along with the rest
  424|       |  // of the command line arguments. Since we always the process most recently
  425|       |  // created list of arguments first, this will result in flagfile argument
  426|       |  // being processed before any other argument in the command line. If
  427|       |  // FLAGS_flagfile contains more than one file name we create multiple new
  428|       |  // levels of arguments in a reverse order of file names. Thus we always
  429|       |  // process arguments from first file before arguments containing in a
  430|       |  // second file, etc. If flagfile contains another
  431|       |  // --flagfile inside of it, it will produce new level of arguments and
  432|       |  // processed before the rest of the flagfile. We are also collecting all
  433|       |  // flagfiles set on original command line. Unlike the rest of the flags,
  434|       |  // this flag can be set multiple times and is expected to be handled
  435|       |  // multiple times. We are collecting them all into a single list and set
  436|       |  // the value of FLAGS_flagfile to that value at the end of the parsing.
  437|      4|  if (flags_internal::flagfile_needs_processing) {
  ------------------
  |  Branch (437:7): [True: 0, False: 4]
  ------------------
  438|      0|    auto flagfiles = absl::GetFlag(FLAGS_flagfile);
  439|       |
  440|      0|    if (input_args.size() == 1) {
  ------------------
  |  Branch (440:9): [True: 0, False: 0]
  ------------------
  441|      0|      flagfile_value.insert(flagfile_value.end(), flagfiles.begin(),
  442|      0|                            flagfiles.end());
  443|      0|    }
  444|       |
  445|      0|    success &= ReadFlagfiles(flagfiles, input_args);
  446|       |
  447|      0|    flags_internal::flagfile_needs_processing = false;
  448|      0|  }
  449|       |
  450|       |  // Similar to flagfile fromenv/tryfromemv can be set both
  451|       |  // programmatically and at runtime on a command line. Unlike flagfile these
  452|       |  // can't be recursive.
  453|      4|  if (flags_internal::fromenv_needs_processing) {
  ------------------
  |  Branch (453:7): [True: 0, False: 4]
  ------------------
  454|      0|    auto flags_list = absl::GetFlag(FLAGS_fromenv);
  455|       |
  456|      0|    success &= ReadFlagsFromEnv(flags_list, input_args, true);
  457|       |
  458|      0|    flags_internal::fromenv_needs_processing = false;
  459|      0|  }
  460|       |
  461|      4|  if (flags_internal::tryfromenv_needs_processing) {
  ------------------
  |  Branch (461:7): [True: 0, False: 4]
  ------------------
  462|      0|    auto flags_list = absl::GetFlag(FLAGS_tryfromenv);
  463|       |
  464|      0|    success &= ReadFlagsFromEnv(flags_list, input_args, false);
  465|       |
  466|      0|    flags_internal::tryfromenv_needs_processing = false;
  467|      0|  }
  468|       |
  469|      4|  return success;
  470|      4|}
parse.cc:_ZN4absl12lts_2024011614flags_internal12_GLOBAL__N_18ArgsList8PopFrontEv:
  179|      6|  void PopFront() { next_arg_++; }
parse.cc:_ZNK4absl12lts_2024011614flags_internal12_GLOBAL__N_18ArgsList4SizeEv:
  176|      4|  size_t Size() const { return args_.size() - next_arg_; }
parse.cc:_ZNK4absl12lts_2024011614flags_internal12_GLOBAL__N_18ArgsList5FrontEv:
  178|      4|  absl::string_view Front() const { return args_[next_arg_]; }
parse.cc:_ZNK4absl12lts_2024011614flags_internal12_GLOBAL__N_18ArgsList10FrontIndexEv:
  177|      2|  size_t FrontIndex() const { return next_arg_; }
parse.cc:_ZN4absl12lts_2024011614flags_internal12_GLOBAL__N_117SplitNameAndValueENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
  278|      4|    absl::string_view arg) {
  279|       |  // Allow -foo and --foo
  280|      4|  absl::ConsumePrefix(&arg, "-");
  281|       |
  282|      4|  if (arg.empty()) {
  ------------------
  |  Branch (282:7): [True: 2, False: 2]
  ------------------
  283|      2|    return std::make_tuple("", "", false);
  284|      2|  }
  285|       |
  286|      2|  auto equal_sign_pos = arg.find('=');
  287|       |
  288|      2|  absl::string_view flag_name = arg.substr(0, equal_sign_pos);
  289|       |
  290|      2|  absl::string_view value;
  291|      2|  bool is_empty_value = false;
  292|       |
  293|      2|  if (equal_sign_pos != absl::string_view::npos) {
  ------------------
  |  Branch (293:7): [True: 2, False: 0]
  ------------------
  294|      2|    value = arg.substr(equal_sign_pos + 1);
  295|      2|    is_empty_value = value.empty();
  296|      2|  }
  297|       |
  298|      2|  return std::make_tuple(flag_name, value, is_empty_value);
  299|      4|}
parse.cc:_ZN4absl12lts_2024011614flags_internal12_GLOBAL__N_110LocateFlagENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
  306|      2|std::tuple<CommandLineFlag*, bool> LocateFlag(absl::string_view flag_name) {
  307|      2|  CommandLineFlag* flag = absl::FindCommandLineFlag(flag_name);
  308|      2|  bool is_negative = false;
  309|       |
  310|      2|  if (!flag && absl::ConsumePrefix(&flag_name, "no")) {
  ------------------
  |  Branch (310:7): [True: 0, False: 2]
  |  Branch (310:16): [True: 0, False: 0]
  ------------------
  311|      0|    flag = absl::FindCommandLineFlag(flag_name);
  312|      0|    is_negative = true;
  313|      0|  }
  314|       |
  315|      2|  return std::make_tuple(flag, is_negative);
  316|      2|}
parse.cc:_ZN4absl12lts_2024011614flags_internal12_GLOBAL__N_115DeduceFlagValueERKNS0_15CommandLineFlagENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEbbPNS2_8ArgsListE:
  509|      2|                                                    ArgsList* curr_list) {
  510|       |  // Value is either an argument suffix after `=` in "--foo=<value>"
  511|       |  // or separate argument in case of "--foo" "<value>".
  512|       |
  513|       |  // boolean flags have these forms:
  514|       |  //   --foo
  515|       |  //   --nofoo
  516|       |  //   --foo=true
  517|       |  //   --foo=false
  518|       |  //   --nofoo=<value> is not supported
  519|       |  //   --foo <value> is not supported
  520|       |
  521|       |  // non boolean flags have these forms:
  522|       |  // --foo=<value>
  523|       |  // --foo <value>
  524|       |  // --nofoo is not supported
  525|       |
  526|      2|  if (flag.IsOfType<bool>()) {
  ------------------
  |  Branch (526:7): [True: 0, False: 2]
  ------------------
  527|      0|    if (value.empty()) {
  ------------------
  |  Branch (527:9): [True: 0, False: 0]
  ------------------
  528|      0|      if (is_empty_value) {
  ------------------
  |  Branch (528:11): [True: 0, False: 0]
  ------------------
  529|       |        // "--bool_flag=" case
  530|      0|        flags_internal::ReportUsageError(
  531|      0|            absl::StrCat(
  532|      0|                "Missing the value after assignment for the boolean flag '",
  533|      0|                flag.Name(), "'"),
  534|      0|            true);
  535|      0|        return std::make_tuple(false, "");
  536|      0|      }
  537|       |
  538|       |      // "--bool_flag" case
  539|      0|      value = is_negative ? "0" : "1";
  ------------------
  |  Branch (539:15): [True: 0, False: 0]
  ------------------
  540|      0|    } else if (is_negative) {
  ------------------
  |  Branch (540:16): [True: 0, False: 0]
  ------------------
  541|       |      // "--nobool_flag=Y" case
  542|      0|      flags_internal::ReportUsageError(
  543|      0|          absl::StrCat("Negative form with assignment is not valid for the "
  544|      0|                       "boolean flag '",
  545|      0|                       flag.Name(), "'"),
  546|      0|          true);
  547|      0|      return std::make_tuple(false, "");
  548|      0|    }
  549|      2|  } else if (is_negative) {
  ------------------
  |  Branch (549:14): [True: 0, False: 2]
  ------------------
  550|       |    // "--noint_flag=1" case
  551|      0|    flags_internal::ReportUsageError(
  552|      0|        absl::StrCat("Negative form is not valid for the flag '", flag.Name(),
  553|      0|                     "'"),
  554|      0|        true);
  555|      0|    return std::make_tuple(false, "");
  556|      2|  } else if (value.empty() && (!is_empty_value)) {
  ------------------
  |  Branch (556:14): [True: 0, False: 2]
  |  Branch (556:31): [True: 0, False: 0]
  ------------------
  557|      0|    if (curr_list->Size() == 1) {
  ------------------
  |  Branch (557:9): [True: 0, False: 0]
  ------------------
  558|       |      // "--int_flag" case
  559|      0|      flags_internal::ReportUsageError(
  560|      0|          absl::StrCat("Missing the value for the flag '", flag.Name(), "'"),
  561|      0|          true);
  562|      0|      return std::make_tuple(false, "");
  563|      0|    }
  564|       |
  565|       |    // "--int_flag" "10" case
  566|      0|    curr_list->PopFront();
  567|      0|    value = curr_list->Front();
  568|       |
  569|       |    // Heuristic to detect the case where someone treats a string arg
  570|       |    // like a bool or just forgets to pass a value:
  571|       |    // --my_string_var --foo=bar
  572|       |    // We look for a flag of string type, whose value begins with a
  573|       |    // dash and corresponds to known flag or standalone --.
  574|      0|    if (!value.empty() && value[0] == '-' && flag.IsOfType<std::string>()) {
  ------------------
  |  Branch (574:9): [True: 0, False: 0]
  |  Branch (574:27): [True: 0, False: 0]
  |  Branch (574:46): [True: 0, False: 0]
  ------------------
  575|      0|      auto maybe_flag_name = std::get<0>(SplitNameAndValue(value.substr(1)));
  576|       |
  577|      0|      if (maybe_flag_name.empty() ||
  ------------------
  |  Branch (577:11): [True: 0, False: 0]
  |  Branch (577:11): [True: 0, False: 0]
  ------------------
  578|      0|          std::get<0>(LocateFlag(maybe_flag_name)) != nullptr) {
  ------------------
  |  Branch (578:11): [True: 0, False: 0]
  ------------------
  579|       |        // "--string_flag" "--known_flag" case
  580|      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]
  |  |  ------------------
  ------------------
  581|      0|            WARNING,
  582|      0|            absl::StrCat("Did you really mean to set flag '", flag.Name(),
  583|      0|                         "' to the value '", value, "'?"));
  584|      0|      }
  585|      0|    }
  586|      0|  }
  587|       |
  588|      2|  return std::make_tuple(true, value);
  589|      2|}
parse.cc:_ZN4absl12lts_2024011614flags_internal12_GLOBAL__N_119ResetGeneratorFlagsERKNSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEE:
  474|      2|void ResetGeneratorFlags(const std::vector<std::string>& flagfile_value) {
  475|       |  // Setting flagfile to the value which collates all the values set on a
  476|       |  // command line and programmatically. So if command line looked like
  477|       |  // --flagfile=f1 --flagfile=f2 the final value of the FLAGS_flagfile flag is
  478|       |  // going to be {"f1", "f2"}
  479|      2|  if (!flagfile_value.empty()) {
  ------------------
  |  Branch (479:7): [True: 0, False: 2]
  ------------------
  480|      0|    absl::SetFlag(&FLAGS_flagfile, flagfile_value);
  481|      0|    absl::MutexLock l(&flags_internal::processing_checks_guard);
  482|      0|    flags_internal::flagfile_needs_processing = false;
  483|      0|  }
  484|       |
  485|       |  // fromenv/tryfromenv are set to <undefined> value.
  486|      2|  if (!absl::GetFlag(FLAGS_fromenv).empty()) {
  ------------------
  |  Branch (486:7): [True: 0, False: 2]
  ------------------
  487|      0|    absl::SetFlag(&FLAGS_fromenv, {});
  488|      0|  }
  489|      2|  if (!absl::GetFlag(FLAGS_tryfromenv).empty()) {
  ------------------
  |  Branch (489:7): [True: 0, False: 2]
  ------------------
  490|      0|    absl::SetFlag(&FLAGS_tryfromenv, {});
  491|      0|  }
  492|       |
  493|      2|  absl::MutexLock l(&flags_internal::processing_checks_guard);
  494|      2|  flags_internal::fromenv_needs_processing = false;
  495|      2|  flags_internal::tryfromenv_needs_processing = false;
  496|      2|}

_ZN4absl12lts_2024011614flags_internal12FlagRegistry8FindFlagENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   99|      2|CommandLineFlag* FlagRegistry::FindFlag(absl::string_view name) {
  100|      2|  if (finalized_flags_.load(std::memory_order_acquire)) {
  ------------------
  |  Branch (100:7): [True: 2, False: 0]
  ------------------
  101|       |    // We could save some gcus here if we make `Name()` be non-virtual.
  102|       |    // We could move the `const char*` name to the base class.
  103|      2|    auto it = std::partition_point(
  104|      2|        flat_flags_.begin(), flat_flags_.end(),
  105|      2|        [=](CommandLineFlag* f) { return f->Name() < name; });
  106|      2|    if (it != flat_flags_.end() && (*it)->Name() == name) return *it;
  ------------------
  |  Branch (106:9): [True: 2, False: 0]
  |  Branch (106:9): [True: 2, False: 0]
  |  Branch (106:36): [True: 2, False: 0]
  ------------------
  107|      2|  }
  108|       |
  109|      0|  FlagRegistryLock frl(*this);
  110|      0|  auto it = flags_.find(name);
  111|      0|  return it != flags_.end() ? it->second : nullptr;
  ------------------
  |  Branch (111:10): [True: 0, False: 0]
  ------------------
  112|      2|}
_ZN4absl12lts_2024011614flags_internal12FlagRegistry12RegisterFlagERNS0_15CommandLineFlagEPKc:
  114|     26|void FlagRegistry::RegisterFlag(CommandLineFlag& flag, const char* filename) {
  115|     26|  if (filename != nullptr &&
  ------------------
  |  Branch (115:7): [True: 26, False: 0]
  |  Branch (115:7): [True: 0, False: 26]
  ------------------
  116|     26|      flag.Filename() != GetUsageConfig().normalize_filename(filename)) {
  ------------------
  |  Branch (116:7): [True: 0, False: 26]
  ------------------
  117|      0|    flags_internal::ReportUsageError(
  118|      0|        absl::StrCat(
  119|      0|            "Inconsistency between flag object and registration for flag '",
  120|      0|            flag.Name(),
  121|      0|            "', likely due to duplicate flags or an ODR violation. Relevant "
  122|      0|            "files: ",
  123|      0|            flag.Filename(), " and ", filename),
  124|      0|        true);
  125|      0|    std::exit(1);
  126|      0|  }
  127|       |
  128|     26|  FlagRegistryLock registry_lock(*this);
  129|       |
  130|     26|  std::pair<FlagIterator, bool> ins =
  131|     26|      flags_.insert(FlagMap::value_type(flag.Name(), &flag));
  132|     26|  if (ins.second == false) {  // means the name was already in the map
  ------------------
  |  Branch (132:7): [True: 0, False: 26]
  ------------------
  133|      0|    CommandLineFlag& old_flag = *ins.first->second;
  134|      0|    if (flag.IsRetired() != old_flag.IsRetired()) {
  ------------------
  |  Branch (134:9): [True: 0, False: 0]
  ------------------
  135|       |      // All registrations must agree on the 'retired' flag.
  136|      0|      flags_internal::ReportUsageError(
  137|      0|          absl::StrCat(
  138|      0|              "Retired flag '", flag.Name(), "' was defined normally in file '",
  139|      0|              (flag.IsRetired() ? old_flag.Filename() : flag.Filename()), "'."),
  ------------------
  |  Branch (139:16): [True: 0, False: 0]
  ------------------
  140|      0|          true);
  141|      0|    } else if (flags_internal::PrivateHandleAccessor::TypeId(flag) !=
  ------------------
  |  Branch (141:16): [True: 0, False: 0]
  ------------------
  142|      0|               flags_internal::PrivateHandleAccessor::TypeId(old_flag)) {
  143|      0|      flags_internal::ReportUsageError(
  144|      0|          absl::StrCat("Flag '", flag.Name(),
  145|      0|                       "' was defined more than once but with "
  146|      0|                       "differing types. Defined in files '",
  147|      0|                       old_flag.Filename(), "' and '", flag.Filename(), "'."),
  148|      0|          true);
  149|      0|    } else if (old_flag.IsRetired()) {
  ------------------
  |  Branch (149:16): [True: 0, False: 0]
  ------------------
  150|      0|      return;
  151|      0|    } else if (old_flag.Filename() != flag.Filename()) {
  ------------------
  |  Branch (151:16): [True: 0, False: 0]
  ------------------
  152|      0|      flags_internal::ReportUsageError(
  153|      0|          absl::StrCat("Flag '", flag.Name(),
  154|      0|                       "' was defined more than once (in files '",
  155|      0|                       old_flag.Filename(), "' and '", flag.Filename(), "')."),
  156|      0|          true);
  157|      0|    } else {
  158|      0|      flags_internal::ReportUsageError(
  159|      0|          absl::StrCat(
  160|      0|              "Something is wrong with flag '", flag.Name(), "' in file '",
  161|      0|              flag.Filename(), "'. One possibility: file '", flag.Filename(),
  162|      0|              "' is being linked both statically and dynamically into this "
  163|      0|              "executable. e.g. some files listed as srcs to a test and also "
  164|      0|              "listed as srcs of some shared lib deps of the same test."),
  165|      0|          true);
  166|      0|    }
  167|       |    // All cases above are fatal, except for the retired flags.
  168|      0|    std::exit(1);
  169|      0|  }
  170|     26|}
_ZN4absl12lts_2024011614flags_internal12FlagRegistry14GlobalRegistryEv:
  172|     30|FlagRegistry& FlagRegistry::GlobalRegistry() {
  173|     30|  static absl::NoDestructor<FlagRegistry> global_registry;
  174|     30|  return *global_registry;
  175|     30|}
_ZN4absl12lts_2024011614flags_internal23RegisterCommandLineFlagERNS0_15CommandLineFlagEPKc:
  192|     26|bool RegisterCommandLineFlag(CommandLineFlag& flag, const char* filename) {
  193|     26|  FlagRegistry::GlobalRegistry().RegisterFlag(flag, filename);
  194|     26|  return true;
  195|     26|}
_ZN4absl12lts_2024011614flags_internal16FinalizeRegistryEv:
  197|      2|void FinalizeRegistry() {
  198|      2|  auto& registry = FlagRegistry::GlobalRegistry();
  199|      2|  FlagRegistryLock frl(registry);
  200|      2|  if (registry.finalized_flags_.load(std::memory_order_relaxed)) {
  ------------------
  |  Branch (200:7): [True: 0, False: 2]
  ------------------
  201|       |    // Was already finalized. Ignore the second time.
  202|      0|    return;
  203|      0|  }
  204|      2|  registry.flat_flags_.reserve(registry.flags_.size());
  205|     26|  for (const auto& f : registry.flags_) {
  ------------------
  |  Branch (205:22): [True: 26, False: 2]
  ------------------
  206|     26|    registry.flat_flags_.push_back(f.second);
  207|     26|  }
  208|      2|  std::sort(std::begin(registry.flat_flags_), std::end(registry.flat_flags_),
  209|      2|            [](const CommandLineFlag* lhs, const CommandLineFlag* rhs) {
  210|      2|              return lhs->Name() < rhs->Name();
  211|      2|            });
  212|      2|  registry.flags_.clear();
  213|      2|  registry.finalized_flags_.store(true, std::memory_order_release);
  214|      2|}
_ZN4absl12lts_2024011619FindCommandLineFlagENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  337|      2|CommandLineFlag* FindCommandLineFlag(absl::string_view name) {
  338|      2|  if (name.empty()) return nullptr;
  ------------------
  |  Branch (338:7): [True: 0, False: 2]
  ------------------
  339|      2|  flags_internal::FlagRegistry& registry =
  340|      2|      flags_internal::FlagRegistry::GlobalRegistry();
  341|      2|  return registry.FindFlag(name);
  342|      2|}
reflection.cc:_ZN4absl12lts_2024011614flags_internal12_GLOBAL__N_116FlagRegistryLockC2ERNS1_12FlagRegistryE:
   90|     28|  explicit FlagRegistryLock(FlagRegistry& fr) : fr_(fr) { fr_.Lock(); }
_ZN4absl12lts_2024011614flags_internal12FlagRegistry4LockEv:
   56|     28|  void Lock() ABSL_EXCLUSIVE_LOCK_FUNCTION(lock_) { lock_.Lock(); }
reflection.cc:_ZN4absl12lts_2024011614flags_internal12_GLOBAL__N_116FlagRegistryLockD2Ev:
   91|     28|  ~FlagRegistryLock() { fr_.Unlock(); }
_ZN4absl12lts_2024011614flags_internal12FlagRegistry6UnlockEv:
   57|     28|  void Unlock() ABSL_UNLOCK_FUNCTION(lock_) { lock_.Unlock(); }
_ZN4absl12lts_2024011614flags_internal12FlagRegistryC2Ev:
   50|      2|  FlagRegistry() = default;
reflection.cc:_ZZN4absl12lts_2024011614flags_internal12FlagRegistry8FindFlagENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEENK3$_0clEPNS0_15CommandLineFlagE:
  105|      8|        [=](CommandLineFlag* f) { return f->Name() < name; });
reflection.cc:_ZZN4absl12lts_2024011614flags_internal16FinalizeRegistryEvENK3$_0clEPKNS0_15CommandLineFlagES5_:
  209|     93|            [](const CommandLineFlag* lhs, const CommandLineFlag* rhs) {
  210|     93|              return lhs->Name() < rhs->Name();
  211|     93|            });

_ZN4absl12lts_2024011619ProgramUsageMessageEv:
   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_2024011614flags_internal14GetUsageConfigEv:
  113|     52|FlagsUsageConfig GetUsageConfig() {
  114|     52|  absl::MutexLock l(&custom_usage_config_guard);
  115|       |
  116|     52|  if (custom_usage_config) return *custom_usage_config;
  ------------------
  |  Branch (116:7): [True: 0, False: 52]
  ------------------
  117|       |
  118|     52|  FlagsUsageConfig default_config;
  119|     52|  default_config.contains_helpshort_flags = &ContainsHelpshortFlags;
  120|     52|  default_config.contains_help_flags = &ContainsHelppackageFlags;
  121|     52|  default_config.contains_helppackage_flags = &ContainsHelppackageFlags;
  122|     52|  default_config.version_string = &VersionString;
  123|     52|  default_config.normalize_filename = &NormalizeFilename;
  124|       |
  125|     52|  return default_config;
  126|     52|}
usage_config.cc:_ZN4absl12lts_2024011614flags_internal12_GLOBAL__N_117NormalizeFilenameENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   96|     52|std::string NormalizeFilename(absl::string_view filename) {
   97|       |  // Skip any leading slashes
   98|     52|  auto pos = filename.find_first_not_of("\\/");
   99|     52|  if (pos == absl::string_view::npos) return "";
  ------------------
  |  Branch (99:7): [True: 0, False: 52]
  ------------------
  100|       |
  101|     52|  filename.remove_prefix(pos);
  102|     52|  return std::string(filename);
  103|     52|}

_ZN4absl12lts_2024011612AnyInvocableIKFNSt3__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_:
  186|      2|      : Impl(internal_any_invocable::ConversionConstruct(),
  187|      2|             std::forward<F>(f)) {}
_ZN4absl12lts_2024011612AnyInvocableIKFNSt3__110unique_ptrIN8fuzztest8internal14FuzzTestFuzzerENS2_14default_deleteIS6_EEEERKNS5_8FuzzTestEEEC2EOSE_:
  176|      4|  AnyInvocable(AnyInvocable&& /*f*/) noexcept = default;

init_fuzztest.cc:_ZN4absl12lts_2024011611FunctionRefIFvRN8fuzztest8internal8FuzzTestEEEC2IZNS2_19ListRegisteredTestsEvE3$_0vEERKT_:
  105|      4|      : invoker_(&absl::functional_internal::InvokeObject<F, R, Args...>) {
  106|      4|    absl::functional_internal::AssertNonNull(f);
  107|      4|    ptr_.obj = &f;
  108|      4|  }
googletest_adaptor.cc:_ZN4absl12lts_2024011611FunctionRefIFvRN8fuzztest8internal8FuzzTestEEEC2IZNS3_30RegisterFuzzTestsAsGoogleTestsEPiPPPcRKNS3_13ConfigurationEE3$_0vEERKT_:
  105|      2|      : invoker_(&absl::functional_internal::InvokeObject<F, R, Args...>) {
  106|      2|    absl::functional_internal::AssertNonNull(f);
  107|      2|    ptr_.obj = &f;
  108|      2|  }
_ZNK4absl12lts_2024011611FunctionRefIFvRN8fuzztest8internal8FuzzTestEEEclES5_:
  131|      6|  R operator()(Args... args) const {
  132|      6|    return invoker_(ptr_, std::forward<Args>(args)...);
  133|      6|  }

_ZN4absl12lts_2024011622internal_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_:
  813|      2|        : Core(TypedConversionConstruct<                                       \
  814|      2|                   typename std::decay<F>::type inv_quals>(),                  \
  815|      2|               std::forward<F>(f)) {}                                          \
_ZN4absl12lts_2024011622internal_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_:
  454|      2|  explicit CoreImpl(TypedConversionConstruct<QualDecayedTRef>, F&& f) {
  455|      2|    using DecayedT = RemoveCVRef<QualDecayedTRef>;
  456|       |
  457|      2|    constexpr TargetType kTargetType =
  458|      2|        (std::is_pointer<DecayedT>::value ||
  ------------------
  |  Branch (458:10): [Folded, False: 0]
  ------------------
  459|      0|         std::is_member_pointer<DecayedT>::value)
  ------------------
  |  Branch (459:10): [Folded, False: 0]
  ------------------
  460|      2|            ? TargetType::kPointer
  461|      2|        : IsCompatibleAnyInvocable<DecayedT>::value
  ------------------
  |  Branch (461:11): [Folded, False: 2]
  ------------------
  462|      2|            ? TargetType::kCompatibleAnyInvocable
  463|      2|        : IsAnyInvocable<DecayedT>::value
  ------------------
  |  Branch (463:11): [Folded, False: 2]
  ------------------
  464|      2|            ? TargetType::kIncompatibleAnyInvocable
  465|      2|            : TargetType::kOther;
  466|       |    // NOTE: We only use integers instead of enums as template parameters in
  467|       |    // order to work around a bug on C++14 under MSVC 2017.
  468|       |    // See b/236131881.
  469|      2|    Initialize<kTargetType, QualDecayedTRef>(std::forward<F>(f));
  470|      2|  }
_ZN4absl12lts_2024011622internal_any_invocable8CoreImplILb0ENSt3__110unique_ptrIN8fuzztest8internal14FuzzTestFuzzerENS3_14default_deleteIS7_EEEEJRKNS6_8FuzzTestEEE10InitializeILNSE_10TargetTypeE3ERKZNS6_17RegistrationToken24GetFuzzTestFuzzerFactoryINS6_27RegistrationWithDomainsBaseIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEENS6_9NoFixtureEPFvNS3_17basic_string_viewIcSM_EEEPvEENS0_12AnyInvocableIKFSA_SD_EEEONS6_12RegistrationIT0_T1_T_T2_EEEUlSD_E_S17_vEEvOS12_:
  572|      2|  void Initialize(F&& f) {
  573|      2|    InitializeStorage<QualDecayedTRef>(std::forward<F>(f));
  574|      2|  }
_ZN4absl12lts_2024011622internal_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_ETnNS3_9enable_ifIXntsr15IsStoredLocallyINS3_9remove_cvINS3_16remove_referenceIS12_E4typeEE4typeEEE5valueEiE4typeELi0EEEvDpOT0_:
  594|      2|  void InitializeStorage(Args&&... args) {
  595|      2|    InitializeRemoteManager<RemoveCVRef<QualTRef>>(std::forward<Args>(args)...);
  596|       |    // This is set after everything else in case an exception is thrown in an
  597|       |    // earlier step of the initialization.
  598|      2|    invoker_ = RemoteInvoker<SigIsNoexcept, ReturnType, QualTRef, P...>;
  599|      2|  }
_ZN4absl12lts_2024011622internal_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_ETnNS3_9enable_ifIXntsr23HasTrivialRemoteStorageIS12_EE5valueEiE4typeELi0EEEvDpOT0_:
  633|      2|  void InitializeRemoteManager(Args&&... args) {
  634|      2|    state_.remote.target = ::new T(std::forward<Args>(args)...);
  635|      2|    manager_ = RemoteManagerNontrivial<T>;
  636|      2|  }
_ZN4absl12lts_2024011622internal_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_:
  340|      4|                             TypeErasedState* const to) noexcept {
  341|      4|  static_assert(!IsStoredLocally<T>::value,
  342|      4|                "Remote storage must only be used for types that do not "
  343|      4|                "qualify for local storage.");
  344|       |
  345|      4|  switch (operation) {
  ------------------
  |  Branch (345:11): [True: 4, False: 0]
  ------------------
  346|      4|    case FunctionToCall::relocate_from_to:
  ------------------
  |  Branch (346:5): [True: 4, False: 0]
  ------------------
  347|       |      // NOTE: Requires that the left-hand operand is already empty.
  348|      4|      to->remote.target = from->remote.target;
  349|      4|      return;
  350|      0|    case FunctionToCall::dispose:
  ------------------
  |  Branch (350:5): [True: 0, False: 4]
  ------------------
  351|      0|      ::delete static_cast<T*>(from->remote.target);  // Must not throw.
  352|      0|      return;
  353|      4|  }
  354|      0|  ABSL_UNREACHABLE();
  ------------------
  |  |  225|      0|  do {                                           \
  |  |  226|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  227|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  228|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  ------------------
  |  |  |  |  203|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  ------------------
  |  |  229|      0|  } while (false)
  |  |  ------------------
  |  |  |  Branch (229:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  355|      0|}
_ZN4absl12lts_2024011622internal_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:
  361|      2|    ForwardedParameterType<P>... args) noexcept(SigIsNoexcept) {
  362|      2|  using RawT = RemoveCVRef<QualTRef>;
  363|      2|  static_assert(!IsStoredLocally<RawT>::value,
  364|      2|                "Target object must be in remote storage in order to be "
  365|      2|                "invoked from it.");
  366|       |
  367|      2|  auto& f = *static_cast<RawT*>(state->remote.target);
  368|      2|  return (InvokeR<ReturnType>)(static_cast<QualTRef>(f),
  369|      2|                               static_cast<ForwardedParameterType<P>>(args)...);
  370|      2|}
_ZN4absl12lts_2024011622internal_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_ETnNS3_9enable_ifIXntsr3std7is_voidIS10_EE5valueEiE4typeELi0EEES10_OSY_DpOT1_:
  137|      2|ReturnType InvokeR(F&& f, P&&... args) {
  138|       |  // GCC 12 has a false-positive -Wmaybe-uninitialized warning here.
  139|       |#if ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(12, 0)
  140|       |#pragma GCC diagnostic push
  141|       |#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
  142|       |#endif
  143|      2|  return absl::base_internal::invoke(std::forward<F>(f),
  144|      2|                                     std::forward<P>(args)...);
  145|       |#if ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(12, 0)
  146|       |#pragma GCC diagnostic pop
  147|       |#endif
  148|      2|}
_ZN4absl12lts_2024011622internal_any_invocable8CoreImplILb0ENSt3__110unique_ptrIN8fuzztest8internal14FuzzTestFuzzerENS3_14default_deleteIS7_EEEEJRKNS6_8FuzzTestEEED2Ev:
  508|      4|  ~CoreImpl() { manager_(FunctionToCall::dispose, &state_, &state_); }
_ZN4absl12lts_2024011622internal_any_invocable12EmptyManagerENS1_14FunctionToCallEPNS1_15TypeErasedStateES4_:
  246|      4|                         TypeErasedState* /*to*/) noexcept {}
_ZNK4absl12lts_2024011622internal_any_invocable4ImplIKFNSt3__110unique_ptrIN8fuzztest8internal14FuzzTestFuzzerENS3_14default_deleteIS7_EEEERKNS6_8FuzzTestEEE14ExtractInvokerEv:
  831|      2|    InvokerType<noex, ReturnType, P...>* ExtractInvoker() cv {                 \
  832|      2|      using QualifiedTestType = int cv ref;                                    \
  833|      2|      auto* invoker = this->invoker_;                                          \
  834|      2|      if (!std::is_const<QualifiedTestType>::value &&                          \
  ------------------
  |  Branch (834:11): [Folded, False: 2]
  ------------------
  835|      2|          std::is_rvalue_reference<QualifiedTestType>::value) {                \
  ------------------
  |  Branch (835:11): [Folded, False: 0]
  ------------------
  836|      0|        ABSL_ASSERT([this]() {                                                 \
  ------------------
  |  |   95|      0|  (false ? static_cast<void>(expr) : static_cast<void>(0))
  |  |  ------------------
  |  |  |  Branch (95:4): [Folded, False: 0]
  |  |  ------------------
  ------------------
  837|      0|          /* We checked that this isn't const above, so const_cast is safe */  \
  838|      0|          const_cast<Impl*>(this)->invoker_ = InvokedAfterMove;                \
  839|      0|          return this->HasValue();                                             \
  840|      0|        }());                                                                  \
  841|      0|      }                                                                        \
  842|      2|      return invoker;                                                          \
  843|      2|    }                                                                          \
_ZN4absl12lts_2024011622internal_any_invocable8CoreImplILb0ENSt3__110unique_ptrIN8fuzztest8internal14FuzzTestFuzzerENS3_14default_deleteIS7_EEEEJRKNS6_8FuzzTestEEEC2EOSE_:
  480|      4|  CoreImpl(CoreImpl&& other) noexcept {
  481|      4|    other.manager_(FunctionToCall::relocate_from_to, &other.state_, &state_);
  482|      4|    manager_ = other.manager_;
  483|      4|    invoker_ = other.invoker_;
  484|      4|    other.manager_ = EmptyManager;
  485|      4|    other.invoker_ = nullptr;
  486|      4|  }

init_fuzztest.cc:_ZN4absl12lts_2024011619functional_internal12InvokeObjectIZN8fuzztest19ListRegisteredTestsEvE3$_0vJRNS3_8internal8FuzzTestEEEET0_NS1_7VoidPtrEDpNS1_8ForwardTIT1_E4typeE:
   75|      4|R InvokeObject(VoidPtr ptr, typename ForwardT<Args>::type... args) {
   76|      4|  auto o = static_cast<const Obj*>(ptr.obj);
   77|      4|  return static_cast<R>(
   78|      4|      absl::base_internal::invoke(*o, std::forward<Args>(args)...));
   79|      4|}
init_fuzztest.cc:_ZN4absl12lts_2024011619functional_internal13AssertNonNullIZN8fuzztest19ListRegisteredTestsEvE3$_0EEvRKT_:
  101|      4|void AssertNonNull(const F&) {}
googletest_adaptor.cc:_ZN4absl12lts_2024011619functional_internal12InvokeObjectIZN8fuzztest8internal30RegisterFuzzTestsAsGoogleTestsEPiPPPcRKNS4_13ConfigurationEE3$_0vJRNS4_8FuzzTestEEEET0_NS1_7VoidPtrEDpNS1_8ForwardTIT1_E4typeE:
   75|      2|R InvokeObject(VoidPtr ptr, typename ForwardT<Args>::type... args) {
   76|      2|  auto o = static_cast<const Obj*>(ptr.obj);
   77|      2|  return static_cast<R>(
   78|      2|      absl::base_internal::invoke(*o, std::forward<Args>(args)...));
   79|      2|}
googletest_adaptor.cc:_ZN4absl12lts_2024011619functional_internal13AssertNonNullIZN8fuzztest8internal30RegisterFuzzTestsAsGoogleTestsEPiPPPcRKNS4_13ConfigurationEE3$_0EEvRKT_:
  101|      2|void AssertNonNull(const F&) {}

_ZN4absl12lts_2024011613hash_internal15MixingHashState16LowLevelHashImplEPKhm:
   63|      6|                                           size_t len) {
   64|      6|  return LowLevelHash(data, len, Seed(), kHashSalt);
   65|      6|}

_ZN4absl12lts_2024011613hash_internal13HashStateBaseINS1_15MixingHashStateEE7combineES3_:
  234|     52|  static H combine(H state) { return state; }
_ZN4absl12lts_2024011613hash_internal13AbslHashValueINS1_15MixingHashStateEEET_S4_NSt3__117basic_string_viewIcNS5_11char_traitsIcEEEE:
  557|     26|H AbslHashValue(H hash_state, absl::string_view str) {
  558|     26|  return H::combine(
  559|     26|      H::combine_contiguous(std::move(hash_state), str.data(), str.size()),
  560|     26|      str.size());
  561|     26|}
_ZN4absl12lts_2024011613hash_internal13HashStateBaseINS1_15MixingHashStateEE7combineImJEEES3_S3_RKT_DpRKT0_:
 1310|     26|H HashStateBase<H>::combine(H state, const T& value, const Ts&... values) {
 1311|     26|  return H::combine(hash_internal::HashSelect::template Apply<T>::Invoke(
 1312|     26|                        std::move(state), value),
 1313|     26|                    values...);
 1314|     26|}
_ZN4absl12lts_2024011613hash_internal10HashSelect24UniquelyRepresentedProbe6InvokeINS1_15MixingHashStateEmEENSt3__19enable_ifIXsr23is_uniquely_representedIT0_EE5valueET_E4typeES9_RKS8_:
  927|     26|        -> absl::enable_if_t<is_uniquely_represented<T>::value, H> {
  928|     26|      return hash_internal::hash_bytes(std::move(state), value);
  929|     26|    }
_ZN4absl12lts_2024011613hash_internal10hash_bytesINS1_15MixingHashStateEmEET_S4_RKT0_:
  340|     26|H hash_bytes(H hash_state, const T& value) {
  341|     26|  const unsigned char* start = reinterpret_cast<const unsigned char*>(&value);
  342|     26|  return H::combine_contiguous(std::move(hash_state), start, sizeof(value));
  343|     26|}
_ZN4absl12lts_2024011613hash_internal15MixingHashState18combine_contiguousES2_PKhm:
 1023|     52|                                            size_t size) {
 1024|     52|    return MixingHashState(
 1025|     52|        CombineContiguousImpl(hash_state.state_, first, size,
 1026|     52|                              std::integral_constant<int, sizeof(size_t)>{}));
 1027|     52|  }
_ZN4absl12lts_2024011613hash_internal15MixingHashState21CombineContiguousImplEmPKhmNSt3__117integral_constantIiLi8EEE:
 1247|     52|    std::integral_constant<int, 8> /* sizeof_size_t */) {
 1248|       |  // For large values we use LowLevelHash or CityHash depending on the platform,
 1249|       |  // for small ones we just use a multiplicative hash.
 1250|     52|  uint64_t v;
 1251|     52|  if (len > 16) {
  ------------------
  |  Branch (1251:7): [True: 6, False: 46]
  ------------------
 1252|      6|    if (ABSL_PREDICT_FALSE(len > PiecewiseChunkSize())) {
  ------------------
  |  |  178|      6|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 6]
  |  |  |  Branch (178:49): [Folded, False: 6]
  |  |  |  Branch (178:58): [True: 0, False: 6]
  |  |  ------------------
  ------------------
 1253|      0|      return CombineLargeContiguousImpl64(state, first, len);
 1254|      0|    }
 1255|      6|    v = Hash64(first, len);
 1256|     46|  } else if (len > 8) {
  ------------------
  |  Branch (1256:14): [True: 10, False: 36]
  ------------------
 1257|       |    // This hash function was constructed by the ML-driven algorithm discovery
 1258|       |    // using reinforcement learning. We fed the agent lots of inputs from
 1259|       |    // microbenchmarks, SMHasher, low hamming distance from generated inputs and
 1260|       |    // picked up the one that was good on micro and macrobenchmarks.
 1261|     10|    auto p = Read9To16(first, len);
 1262|     10|    uint64_t lo = p.first;
 1263|     10|    uint64_t hi = p.second;
 1264|       |    // Rotation by 53 was found to be most often useful when discovering these
 1265|       |    // hashing algorithms with ML techniques.
 1266|     10|    lo = absl::rotr(lo, 53);
 1267|     10|    state += kMul;
 1268|     10|    lo += state;
 1269|     10|    state ^= hi;
 1270|     10|    uint128 m = state;
 1271|     10|    m *= lo;
 1272|     10|    return static_cast<uint64_t>(m ^ (m >> 64));
 1273|     36|  } else if (len >= 4) {
  ------------------
  |  Branch (1273:14): [True: 36, False: 0]
  ------------------
 1274|     36|    v = Read4To8(first, len);
 1275|     36|  } else if (len > 0) {
  ------------------
  |  Branch (1275:14): [True: 0, False: 0]
  ------------------
 1276|      0|    v = Read1To3(first, len);
 1277|      0|  } else {
 1278|       |    // Empty ranges have no effect.
 1279|      0|    return state;
 1280|      0|  }
 1281|     42|  return Mix(state, v);
 1282|     52|}
_ZN4absl12lts_2024011613hash_internal18PiecewiseChunkSizeEv:
   82|      6|constexpr size_t PiecewiseChunkSize() { return 1024; }
_ZN4absl12lts_2024011613hash_internal15MixingHashState6Hash64EPKhm:
 1181|      6|                                                      size_t len) {
 1182|      6|#ifdef ABSL_HAVE_INTRINSIC_INT128
 1183|      6|    return LowLevelHashImpl(data, len);
 1184|       |#else
 1185|       |    return hash_internal::CityHash64(reinterpret_cast<const char*>(data), len);
 1186|       |#endif
 1187|      6|  }
_ZN4absl12lts_2024011613hash_internal15MixingHashState9Read9To16EPKhm:
 1114|     10|                                                 size_t len) {
 1115|     10|    uint64_t low_mem = absl::base_internal::UnalignedLoad64(p);
 1116|     10|    uint64_t high_mem = absl::base_internal::UnalignedLoad64(p + len - 8);
 1117|     10|#ifdef ABSL_IS_LITTLE_ENDIAN
 1118|     10|    uint64_t most_significant = high_mem;
 1119|     10|    uint64_t least_significant = low_mem;
 1120|       |#else
 1121|       |    uint64_t most_significant = low_mem;
 1122|       |    uint64_t least_significant = high_mem;
 1123|       |#endif
 1124|     10|    return {least_significant, most_significant};
 1125|     10|  }
_ZN4absl12lts_2024011613hash_internal15MixingHashState8Read4To8EPKhm:
 1128|     36|  static uint64_t Read4To8(const unsigned char* p, size_t len) {
 1129|     36|    uint32_t low_mem = absl::base_internal::UnalignedLoad32(p);
 1130|     36|    uint32_t high_mem = absl::base_internal::UnalignedLoad32(p + len - 4);
 1131|     36|#ifdef ABSL_IS_LITTLE_ENDIAN
 1132|     36|    uint32_t most_significant = high_mem;
 1133|     36|    uint32_t least_significant = low_mem;
 1134|       |#else
 1135|       |    uint32_t most_significant = low_mem;
 1136|       |    uint32_t least_significant = high_mem;
 1137|       |#endif
 1138|     36|    return (static_cast<uint64_t>(most_significant) << (len - 4) * 8) |
 1139|     36|           least_significant;
 1140|     36|  }
_ZN4absl12lts_2024011613hash_internal15MixingHashState3MixEmm:
 1162|     42|  ABSL_ATTRIBUTE_ALWAYS_INLINE static uint64_t Mix(uint64_t state, uint64_t v) {
 1163|       |    // Though the 128-bit product on AArch64 needs two instructions, it is
 1164|       |    // still a good balance between speed and hash quality.
 1165|     42|    using MultType =
 1166|     42|        absl::conditional_t<sizeof(size_t) == 4, uint64_t, uint128>;
 1167|       |    // We do the addition in 64-bit space to make sure the 128-bit
 1168|       |    // multiplication is fast. If we were to do it as MultType the compiler has
 1169|       |    // to assume that the high word is non-zero and needs to perform 2
 1170|       |    // multiplications instead of one.
 1171|     42|    MultType m = state + v;
 1172|     42|    m *= kMul;
 1173|     42|    return static_cast<uint64_t>(m ^ (m >> (sizeof(m) * 8 / 2)));
 1174|     42|  }
_ZN4absl12lts_2024011613hash_internal15MixingHashStateC2Em:
 1085|     52|  explicit MixingHashState(uint64_t state) : state_(state) {}
_ZN4absl12lts_2024011613hash_internal13HashStateBaseINS1_15MixingHashStateEE18combine_contiguousIcEES3_S3_PKT_m:
 1319|     26|H HashStateBase<H>::combine_contiguous(H state, const T* data, size_t size) {
 1320|     26|  return hash_internal::hash_range_or_bytes(std::move(state), data, size);
 1321|     26|}
_ZN4absl12lts_2024011613hash_internal19hash_range_or_bytesINS1_15MixingHashStateEcEENSt3__19enable_ifIXsr23is_uniquely_representedIT0_EE5valueET_E4typeES7_PKS6_m:
  885|     26|hash_range_or_bytes(H hash_state, const T* data, size_t size) {
  886|     26|  const auto* bytes = reinterpret_cast<const unsigned char*>(data);
  887|     26|  return H::combine_contiguous(std::move(hash_state), bytes, sizeof(T) * size);
  888|     26|}
_ZN4absl12lts_2024011613hash_internal15MixingHashStateC2Ev:
 1052|     26|  MixingHashState() : state_(Seed()) {}
_ZN4absl12lts_2024011613hash_internal15MixingHashState4SeedEv:
 1205|     32|  ABSL_ATTRIBUTE_ALWAYS_INLINE static uint64_t Seed() {
 1206|     32|#if (!defined(__clang__) || __clang_major__ > 11) && \
 1207|     32|    (!defined(__apple_build_version__) ||            \
 1208|     32|     __apple_build_version__ >= 19558921)  // Xcode 12
 1209|     32|    return static_cast<uint64_t>(reinterpret_cast<uintptr_t>(&kSeed));
 1210|       |#else
 1211|       |    // Workaround the absence of
 1212|       |    // https://github.com/llvm/llvm-project/commit/bc15bf66dcca76cc06fe71fca35b74dc4d521021.
 1213|       |    return static_cast<uint64_t>(reinterpret_cast<uintptr_t>(kSeed));
 1214|       |#endif
 1215|     32|  }
_ZNK4absl12lts_2024011613hash_internal8HashImplINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEEclERKS7_:
 1299|     26|  size_t operator()(const T& value) const {
 1300|     26|    return MixingHashState::hash(value);
 1301|     26|  }
_ZN4absl12lts_2024011613hash_internal15MixingHashState4hashINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEETnNS4_9enable_ifIXntsr16IntegralFastPathIT_EE5valueEiE4typeELi0EEEmRKSA_:
 1045|     26|  static size_t hash(const T& value) {
 1046|     26|    return static_cast<size_t>(combine(MixingHashState{}, value).state_);
 1047|     26|  }
_ZN4absl12lts_2024011613hash_internal13HashStateBaseINS1_15MixingHashStateEE7combineINSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEJEEES3_S3_RKT_DpRKT0_:
 1310|     26|H HashStateBase<H>::combine(H state, const T& value, const Ts&... values) {
 1311|     26|  return H::combine(hash_internal::HashSelect::template Apply<T>::Invoke(
 1312|     26|                        std::move(state), value),
 1313|     26|                    values...);
 1314|     26|}
_ZN4absl12lts_2024011613hash_internal10HashSelect14HashValueProbe6InvokeINS1_15MixingHashStateENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEEENS6_9enable_ifIXsr3std7is_sameIT_DTcl13AbslHashValueclsr3stdE4movefp_Efp0_EEEE5valueESC_E4typeESC_RKT0_:
  937|     26|        H> {
  938|     26|      return AbslHashValue(std::move(state), value);
  939|     26|    }

_ZN4absl12lts_2024011613hash_internal12LowLevelHashEPKvmmPKm:
   32|      6|                      const uint64_t salt[5]) {
   33|       |  // Prefetch the cacheline that data resides in.
   34|      6|  PrefetchToLocalCache(data);
   35|      6|  const uint8_t* ptr = static_cast<const uint8_t*>(data);
   36|      6|  uint64_t starting_length = static_cast<uint64_t>(len);
   37|      6|  uint64_t current_state = seed ^ salt[0];
   38|       |
   39|      6|  if (len > 64) {
  ------------------
  |  Branch (39:7): [True: 0, False: 6]
  ------------------
   40|       |    // If we have more than 64 bytes, we're going to handle chunks of 64
   41|       |    // bytes at a time. We're going to build up two separate hash states
   42|       |    // which we will then hash together.
   43|      0|    uint64_t duplicated_state = current_state;
   44|       |
   45|      0|    do {
   46|       |      // Always prefetch the next cacheline.
   47|      0|      PrefetchToLocalCache(ptr + ABSL_CACHELINE_SIZE);
  ------------------
  |  |   77|      0|#define ABSL_CACHELINE_SIZE 64
  ------------------
   48|       |
   49|      0|      uint64_t a = absl::base_internal::UnalignedLoad64(ptr);
   50|      0|      uint64_t b = absl::base_internal::UnalignedLoad64(ptr + 8);
   51|      0|      uint64_t c = absl::base_internal::UnalignedLoad64(ptr + 16);
   52|      0|      uint64_t d = absl::base_internal::UnalignedLoad64(ptr + 24);
   53|      0|      uint64_t e = absl::base_internal::UnalignedLoad64(ptr + 32);
   54|      0|      uint64_t f = absl::base_internal::UnalignedLoad64(ptr + 40);
   55|      0|      uint64_t g = absl::base_internal::UnalignedLoad64(ptr + 48);
   56|      0|      uint64_t h = absl::base_internal::UnalignedLoad64(ptr + 56);
   57|       |
   58|      0|      uint64_t cs0 = Mix(a ^ salt[1], b ^ current_state);
   59|      0|      uint64_t cs1 = Mix(c ^ salt[2], d ^ current_state);
   60|      0|      current_state = (cs0 ^ cs1);
   61|       |
   62|      0|      uint64_t ds0 = Mix(e ^ salt[3], f ^ duplicated_state);
   63|      0|      uint64_t ds1 = Mix(g ^ salt[4], h ^ duplicated_state);
   64|      0|      duplicated_state = (ds0 ^ ds1);
   65|       |
   66|      0|      ptr += 64;
   67|      0|      len -= 64;
   68|      0|    } while (len > 64);
  ------------------
  |  Branch (68:14): [True: 0, False: 0]
  ------------------
   69|       |
   70|      0|    current_state = current_state ^ duplicated_state;
   71|      0|  }
   72|       |
   73|       |  // We now have a data `ptr` with at most 64 bytes and the current state
   74|       |  // of the hashing state machine stored in current_state.
   75|     14|  while (len > 16) {
  ------------------
  |  Branch (75:10): [True: 8, False: 6]
  ------------------
   76|      8|    uint64_t a = absl::base_internal::UnalignedLoad64(ptr);
   77|      8|    uint64_t b = absl::base_internal::UnalignedLoad64(ptr + 8);
   78|       |
   79|      8|    current_state = Mix(a ^ salt[1], b ^ current_state);
   80|       |
   81|      8|    ptr += 16;
   82|      8|    len -= 16;
   83|      8|  }
   84|       |
   85|       |  // We now have a data `ptr` with at most 16 bytes.
   86|      6|  uint64_t a = 0;
   87|      6|  uint64_t b = 0;
   88|      6|  if (len > 8) {
  ------------------
  |  Branch (88:7): [True: 0, False: 6]
  ------------------
   89|       |    // When we have at least 9 and at most 16 bytes, set A to the first 64
   90|       |    // bits of the input and B to the last 64 bits of the input. Yes, they will
   91|       |    // overlap in the middle if we are working with less than the full 16
   92|       |    // bytes.
   93|      0|    a = absl::base_internal::UnalignedLoad64(ptr);
   94|      0|    b = absl::base_internal::UnalignedLoad64(ptr + len - 8);
   95|      6|  } else if (len > 3) {
  ------------------
  |  Branch (95:14): [True: 6, False: 0]
  ------------------
   96|       |    // If we have at least 4 and at most 8 bytes, set A to the first 32
   97|       |    // bits and B to the last 32 bits.
   98|      6|    a = absl::base_internal::UnalignedLoad32(ptr);
   99|      6|    b = absl::base_internal::UnalignedLoad32(ptr + len - 4);
  100|      6|  } else if (len > 0) {
  ------------------
  |  Branch (100:14): [True: 0, False: 0]
  ------------------
  101|       |    // If we have at least 1 and at most 3 bytes, read all of the provided
  102|       |    // bits into A, with some adjustments.
  103|      0|    a = static_cast<uint64_t>((ptr[0] << 16) | (ptr[len >> 1] << 8) |
  104|      0|                              ptr[len - 1]);
  105|      0|    b = 0;
  106|      0|  } else {
  107|      0|    a = 0;
  108|      0|    b = 0;
  109|      0|  }
  110|       |
  111|      6|  uint64_t w = Mix(a ^ salt[1], b ^ current_state);
  112|      6|  uint64_t z = salt[1] ^ starting_length;
  113|      6|  return Mix(w, z);
  114|      6|}
low_level_hash.cc:_ZN4absl12lts_2024011613hash_internalL3MixEmm:
   25|     20|static uint64_t Mix(uint64_t v0, uint64_t v1) {
   26|     20|  absl::uint128 p = v0;
   27|     20|  p *= v1;
   28|     20|  return absl::Uint128Low64(p) ^ absl::Uint128High64(p);
   29|     20|}

_ZN4absl12lts_2024011611countl_zeroImEENSt3__19enable_ifIXsr3std11is_unsignedIT_EE5valueEiE4typeES4_:
  103|  23.7k|    countl_zero(T x) noexcept {
  104|  23.7k|  return numeric_internal::CountLeadingZeroes(x);
  105|  23.7k|}
_ZN4absl12lts_202401164rotrImEENSt3__19enable_ifIXsr3std11is_unsignedIT_EE5valueES4_E4typeES4_i:
   75|     10|    rotr(T x, int s) noexcept {
   76|     10|  return numeric_internal::RotateRight(x, s);
   77|     10|}
_ZN4absl12lts_2024011611countr_zeroItEENSt3__19enable_ifIXsr3std11is_unsignedIT_EE5valueEiE4typeES4_:
  118|     27|    countr_zero(T x) noexcept {
  119|     27|  return numeric_internal::CountTrailingZeroes(x);
  120|     27|}
_ZN4absl12lts_2024011611countr_zeroIjEENSt3__19enable_ifIXsr3std11is_unsignedIT_EE5valueEiE4typeES4_:
  118|      2|    countr_zero(T x) noexcept {
  119|      2|  return numeric_internal::CountTrailingZeroes(x);
  120|      2|}
_ZN4absl12lts_202401169bit_widthImEENSt3__19enable_ifIXsr3std11is_unsignedIT_EE5valueEiE4typeES4_:
  160|  4.88k|    bit_width(T x) noexcept {
  161|  4.88k|  return std::numeric_limits<T>::digits - countl_zero(x);
  162|  4.88k|}

_ZN4absl12lts_20240116mlENS0_7uint128ES1_:
  982|  21.3k|inline uint128 operator*(uint128 lhs, uint128 rhs) {
  983|  21.3k|#if defined(ABSL_HAVE_INTRINSIC_INT128)
  984|       |  // TODO(strel) Remove once alignment issues are resolved and unsigned __int128
  985|       |  // can be used for uint128 storage.
  986|  21.3k|  return static_cast<unsigned __int128>(lhs) *
  987|  21.3k|         static_cast<unsigned __int128>(rhs);
  988|       |#elif defined(_MSC_VER) && defined(_M_X64) && !defined(_M_ARM64EC)
  989|       |  uint64_t carry;
  990|       |  uint64_t low = _umul128(Uint128Low64(lhs), Uint128Low64(rhs), &carry);
  991|       |  return MakeUint128(Uint128Low64(lhs) * Uint128High64(rhs) +
  992|       |                         Uint128High64(lhs) * Uint128Low64(rhs) + carry,
  993|       |                     low);
  994|       |#else   // ABSL_HAVE_INTRINSIC128
  995|       |  uint64_t a32 = Uint128Low64(lhs) >> 32;
  996|       |  uint64_t a00 = Uint128Low64(lhs) & 0xffffffff;
  997|       |  uint64_t b32 = Uint128Low64(rhs) >> 32;
  998|       |  uint64_t b00 = Uint128Low64(rhs) & 0xffffffff;
  999|       |  uint128 result =
 1000|       |      MakeUint128(Uint128High64(lhs) * Uint128Low64(rhs) +
 1001|       |                      Uint128Low64(lhs) * Uint128High64(rhs) + a32 * b32,
 1002|       |                  a00 * b00);
 1003|       |  result += uint128(a32 * b00) << 32;
 1004|       |  result += uint128(a00 * b32) << 32;
 1005|       |  return result;
 1006|       |#endif  // ABSL_HAVE_INTRINSIC128
 1007|  21.3k|}
_ZNK4absl12lts_202401167uint128cvoEv:
  776|   262k|constexpr uint128::operator unsigned __int128() const {
  777|   262k|  return (static_cast<unsigned __int128>(hi_) << 64) + lo_;
  778|   262k|}
_ZN4absl12lts_202401167uint128C2Eo:
  674|   120k|    : lo_{static_cast<uint64_t>(v & ~uint64_t{0})},
  675|   120k|      hi_{static_cast<uint64_t>(v >> 64)} {}
_ZN4absl12lts_202401167uint128C2Em:
  665|  48.2k|constexpr uint128::uint128(unsigned long v) : lo_{v}, hi_{0} {}
_ZNK4absl12lts_202401167uint128cvmEv:
  759|  15.8k|constexpr uint128::operator unsigned long() const {  // NOLINT(runtime/int)
  760|  15.8k|  return static_cast<unsigned long>(lo_);            // NOLINT(runtime/int)
  761|  15.8k|}
_ZN4absl12lts_20240116rsENS0_7uint128Ei:
  922|  25.4k|constexpr uint128 operator>>(uint128 lhs, int amount) {
  923|  25.4k|#ifdef ABSL_HAVE_INTRINSIC_INT128
  924|  25.4k|  return static_cast<unsigned __int128>(lhs) >> amount;
  925|       |#else
  926|       |  // uint64_t shifts of >= 64 are undefined, so we will need some
  927|       |  // special-casing.
  928|       |  return amount >= 64  ? MakeUint128(0, Uint128High64(lhs) >> (amount - 64))
  929|       |         : amount == 0 ? lhs
  930|       |                       : MakeUint128(Uint128High64(lhs) >> amount,
  931|       |                                     (Uint128Low64(lhs) >> amount) |
  932|       |                                         (Uint128High64(lhs) << (64 - amount)));
  933|       |#endif
  934|  25.4k|}
_ZN4absl12lts_202401167uint128rSEi:
  613|  25.4k|inline uint128& uint128::operator>>=(int amount) {
  614|  25.4k|  *this = *this >> amount;
  615|  25.4k|  return *this;
  616|  25.4k|}
_ZN4absl12lts_202401167uint128pLES1_:
  618|  2.26k|inline uint128& uint128::operator+=(uint128 other) {
  619|  2.26k|  *this = *this + other;
  620|  2.26k|  return *this;
  621|  2.26k|}
_ZN4absl12lts_202401167uint128mLES1_:
  628|  12.0k|inline uint128& uint128::operator*=(uint128 other) {
  629|  12.0k|  *this = *this * other;
  630|  12.0k|  return *this;
  631|  12.0k|}
_ZN4absl12lts_2024011612Uint128Low64ENS0_7uint128E:
  643|  11.9k|constexpr uint64_t Uint128Low64(uint128 v) { return v.lo_; }
_ZN4absl12lts_2024011613Uint128High64ENS0_7uint128E:
  645|  52.4k|constexpr uint64_t Uint128High64(uint128 v) { return v.hi_; }
_ZN4absl12lts_20240116eqENS0_7uint128ES1_:
  798|  24.3k|constexpr bool operator==(uint128 lhs, uint128 rhs) {
  799|  24.3k|#if defined(ABSL_HAVE_INTRINSIC_INT128)
  800|  24.3k|  return static_cast<unsigned __int128>(lhs) ==
  801|  24.3k|         static_cast<unsigned __int128>(rhs);
  802|       |#else
  803|       |  return (Uint128Low64(lhs) == Uint128Low64(rhs) &&
  804|       |          Uint128High64(lhs) == Uint128High64(rhs));
  805|       |#endif
  806|  24.3k|}
_ZN4absl12lts_20240116ltENS0_7uint128ES1_:
  810|  14.0k|constexpr bool operator<(uint128 lhs, uint128 rhs) {
  811|  14.0k|#ifdef ABSL_HAVE_INTRINSIC_INT128
  812|  14.0k|  return static_cast<unsigned __int128>(lhs) <
  813|  14.0k|         static_cast<unsigned __int128>(rhs);
  814|       |#else
  815|       |  return (Uint128High64(lhs) == Uint128High64(rhs))
  816|       |             ? (Uint128Low64(lhs) < Uint128Low64(rhs))
  817|       |             : (Uint128High64(lhs) < Uint128High64(rhs));
  818|       |#endif
  819|  14.0k|}
_ZN4absl12lts_20240116gtENS0_7uint128ES1_:
  821|  14.0k|constexpr bool operator>(uint128 lhs, uint128 rhs) { return rhs < lhs; }
_ZN4absl12lts_20240116anENS0_7uint128ES1_:
  871|  15.6k|constexpr inline uint128 operator&(uint128 lhs, uint128 rhs) {
  872|  15.6k|#if defined(ABSL_HAVE_INTRINSIC_INT128)
  873|  15.6k|  return static_cast<unsigned __int128>(lhs) &
  874|  15.6k|         static_cast<unsigned __int128>(rhs);
  875|       |#else
  876|       |  return MakeUint128(Uint128High64(lhs) & Uint128High64(rhs),
  877|       |                     Uint128Low64(lhs) & Uint128Low64(rhs));
  878|       |#endif
  879|  15.6k|}
_ZN4absl12lts_20240116lsENS0_7uint128Ei:
  908|  29.8k|constexpr uint128 operator<<(uint128 lhs, int amount) {
  909|  29.8k|#ifdef ABSL_HAVE_INTRINSIC_INT128
  910|  29.8k|  return static_cast<unsigned __int128>(lhs) << amount;
  911|       |#else
  912|       |  // uint64_t shifts of >= 64 are undefined, so we will need some
  913|       |  // special-casing.
  914|       |  return amount >= 64  ? MakeUint128(Uint128Low64(lhs) << (amount - 64), 0)
  915|       |         : amount == 0 ? lhs
  916|       |                       : MakeUint128((Uint128High64(lhs) << amount) |
  917|       |                                         (Uint128Low64(lhs) >> (64 - amount)),
  918|       |                                     Uint128Low64(lhs) << amount);
  919|       |#endif
  920|  29.8k|}
_ZN4absl12lts_20240116plENS0_7uint128ES1_:
  947|  3.75k|constexpr uint128 operator+(uint128 lhs, uint128 rhs) {
  948|  3.75k|#if defined(ABSL_HAVE_INTRINSIC_INT128)
  949|  3.75k|  return static_cast<unsigned __int128>(lhs) +
  950|  3.75k|         static_cast<unsigned __int128>(rhs);
  951|       |#else
  952|       |  return int128_internal::AddResult(
  953|       |      MakeUint128(Uint128High64(lhs) + Uint128High64(rhs),
  954|       |                  Uint128Low64(lhs) + Uint128Low64(rhs)),
  955|       |      lhs);
  956|       |#endif
  957|  3.75k|}
_ZN4absl12lts_20240116miENS0_7uint128ES1_:
  970|  24.3k|constexpr uint128 operator-(uint128 lhs, uint128 rhs) {
  971|  24.3k|#if defined(ABSL_HAVE_INTRINSIC_INT128)
  972|  24.3k|  return static_cast<unsigned __int128>(lhs) -
  973|  24.3k|         static_cast<unsigned __int128>(rhs);
  974|       |#else
  975|       |  return int128_internal::SubstructResult(
  976|       |      MakeUint128(Uint128High64(lhs) - Uint128High64(rhs),
  977|       |                  Uint128Low64(lhs) - Uint128Low64(rhs)),
  978|       |      lhs, rhs);
  979|       |#endif
  980|  24.3k|}
_ZN4absl12lts_202401167uint128ppEv:
 1035|    652|inline uint128& uint128::operator++() {
 1036|    652|  *this += 1;
 1037|    652|  return *this;
 1038|    652|}
_ZN4absl12lts_202401167uint128C2Ei:
  654|  57.7k|    : lo_{static_cast<uint64_t>(v)},
  655|  57.7k|      hi_{v < 0 ? (std::numeric_limits<uint64_t>::max)() : 0} {}
  ------------------
  |  Branch (655:11): [True: 0, False: 57.7k]
  ------------------

_ZN4absl12lts_2024011616numeric_internal18CountLeadingZeroesImEEiT_:
  234|  23.7k|CountLeadingZeroes(T x) {
  235|  23.7k|  static_assert(std::is_unsigned<T>::value, "T must be unsigned");
  236|  23.7k|  static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
  237|  23.7k|                "T must have a power-of-2 size");
  238|  23.7k|  static_assert(sizeof(T) <= sizeof(uint64_t), "T too large");
  239|  23.7k|  return sizeof(T) <= sizeof(uint16_t)
  ------------------
  |  Branch (239:10): [Folded, False: 23.7k]
  ------------------
  240|  23.7k|             ? CountLeadingZeroes16(static_cast<uint16_t>(x)) -
  241|      0|                   (std::numeric_limits<uint16_t>::digits -
  242|      0|                    std::numeric_limits<T>::digits)
  243|  23.7k|             : (sizeof(T) <= sizeof(uint32_t)
  ------------------
  |  Branch (243:17): [Folded, False: 23.7k]
  ------------------
  244|  23.7k|                    ? CountLeadingZeroes32(static_cast<uint32_t>(x)) -
  245|      0|                          (std::numeric_limits<uint32_t>::digits -
  246|      0|                           std::numeric_limits<T>::digits)
  247|  23.7k|                    : CountLeadingZeroes64(x));
  248|  23.7k|}
_ZN4absl12lts_2024011616numeric_internal20CountLeadingZeroes64Em:
  180|  23.7k|CountLeadingZeroes64(uint64_t x) {
  181|  23.7k|#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_clzll)
  182|       |  // Use __builtin_clzll, which uses the following instructions:
  183|       |  //  x86: bsr, lzcnt
  184|       |  //  ARM64: clz
  185|       |  //  PPC: cntlzd
  186|  23.7k|  static_assert(sizeof(unsigned long long) == sizeof(x),  // NOLINT(runtime/int)
  187|  23.7k|                "__builtin_clzll does not take 64-bit arg");
  188|       |
  189|       |  // Handle 0 as a special case because __builtin_clzll(0) is undefined.
  190|  23.7k|  return x == 0 ? 64 : __builtin_clzll(x);
  ------------------
  |  Branch (190:10): [True: 0, False: 23.7k]
  ------------------
  191|       |#elif defined(_MSC_VER) && !defined(__clang__) && \
  192|       |    (defined(_M_X64) || defined(_M_ARM64))
  193|       |  // MSVC does not have __buitin_clzll. Use _BitScanReverse64.
  194|       |  unsigned long result = 0;  // NOLINT(runtime/int)
  195|       |  if (_BitScanReverse64(&result, x)) {
  196|       |    return 63 - result;
  197|       |  }
  198|       |  return 64;
  199|       |#elif defined(_MSC_VER) && !defined(__clang__)
  200|       |  // MSVC does not have __buitin_clzll. Compose two calls to _BitScanReverse
  201|       |  unsigned long result = 0;  // NOLINT(runtime/int)
  202|       |  if ((x >> 32) &&
  203|       |      _BitScanReverse(&result, static_cast<unsigned long>(x >> 32))) {
  204|       |    return 31 - result;
  205|       |  }
  206|       |  if (_BitScanReverse(&result, static_cast<unsigned long>(x))) {
  207|       |    return 63 - result;
  208|       |  }
  209|       |  return 64;
  210|       |#else
  211|       |  int zeroes = 60;
  212|       |  if (x >> 32) {
  213|       |    zeroes -= 32;
  214|       |    x >>= 32;
  215|       |  }
  216|       |  if (x >> 16) {
  217|       |    zeroes -= 16;
  218|       |    x >>= 16;
  219|       |  }
  220|       |  if (x >> 8) {
  221|       |    zeroes -= 8;
  222|       |    x >>= 8;
  223|       |  }
  224|       |  if (x >> 4) {
  225|       |    zeroes -= 4;
  226|       |    x >>= 4;
  227|       |  }
  228|       |  return "\4\3\2\2\1\1\1\1\0\0\0\0\0\0\0"[x] + zeroes;
  229|       |#endif
  230|  23.7k|}
_ZN4absl12lts_2024011616numeric_internal11RotateRightImEET_S3_i:
   75|     10|    T x, int s) noexcept {
   76|     10|  static_assert(std::is_unsigned<T>::value, "T must be unsigned");
   77|     10|  static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
   78|     10|                "T must have a power-of-2 size");
   79|       |
   80|     10|  return static_cast<T>(x >> (s & (std::numeric_limits<T>::digits - 1))) |
   81|     10|         static_cast<T>(x << ((-s) & (std::numeric_limits<T>::digits - 1)));
   82|     10|}
_ZN4absl12lts_2024011616numeric_internal19CountTrailingZeroesItEEiT_:
  317|     27|CountTrailingZeroes(T x) noexcept {
  318|     27|  static_assert(std::is_unsigned<T>::value, "T must be unsigned");
  319|     27|  static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
  320|     27|                "T must have a power-of-2 size");
  321|     27|  static_assert(sizeof(T) <= sizeof(uint64_t), "T too large");
  322|     27|  return x == 0 ? std::numeric_limits<T>::digits
  ------------------
  |  Branch (322:10): [True: 0, False: 27]
  ------------------
  323|     27|                : (sizeof(T) <= sizeof(uint16_t)
  ------------------
  |  Branch (323:20): [True: 27, Folded]
  ------------------
  324|     27|                       ? CountTrailingZeroesNonzero16(static_cast<uint16_t>(x))
  325|     27|                       : (sizeof(T) <= sizeof(uint32_t)
  ------------------
  |  Branch (325:27): [True: 0, Folded]
  ------------------
  326|      0|                              ? CountTrailingZeroesNonzero32(
  327|      0|                                    static_cast<uint32_t>(x))
  328|      0|                              : CountTrailingZeroesNonzero64(x)));
  329|     27|}
_ZN4absl12lts_2024011616numeric_internal28CountTrailingZeroesNonzero16Et:
  305|     27|CountTrailingZeroesNonzero16(uint16_t x) {
  306|     27|#if ABSL_HAVE_BUILTIN(__builtin_ctzs)
  307|     27|  static_assert(sizeof(unsigned short) == sizeof(x),  // NOLINT(runtime/int)
  308|     27|                "__builtin_ctzs does not take 16-bit arg");
  309|     27|  return __builtin_ctzs(x);
  310|       |#else
  311|       |  return CountTrailingZeroesNonzero32(x);
  312|       |#endif
  313|     27|}
_ZN4absl12lts_2024011616numeric_internal19CountTrailingZeroesIjEEiT_:
  317|      2|CountTrailingZeroes(T x) noexcept {
  318|      2|  static_assert(std::is_unsigned<T>::value, "T must be unsigned");
  319|      2|  static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
  320|      2|                "T must have a power-of-2 size");
  321|      2|  static_assert(sizeof(T) <= sizeof(uint64_t), "T too large");
  322|      2|  return x == 0 ? std::numeric_limits<T>::digits
  ------------------
  |  Branch (322:10): [True: 0, False: 2]
  ------------------
  323|      2|                : (sizeof(T) <= sizeof(uint16_t)
  ------------------
  |  Branch (323:20): [Folded, False: 2]
  ------------------
  324|      2|                       ? CountTrailingZeroesNonzero16(static_cast<uint16_t>(x))
  325|      2|                       : (sizeof(T) <= sizeof(uint32_t)
  ------------------
  |  Branch (325:27): [True: 2, Folded]
  ------------------
  326|      2|                              ? CountTrailingZeroesNonzero32(
  327|      2|                                    static_cast<uint32_t>(x))
  328|      2|                              : CountTrailingZeroesNonzero64(x)));
  329|      2|}
_ZN4absl12lts_2024011616numeric_internal28CountTrailingZeroesNonzero32Ej:
  251|      2|CountTrailingZeroesNonzero32(uint32_t x) {
  252|      2|#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_ctz)
  253|      2|  static_assert(sizeof(unsigned int) == sizeof(x),
  254|      2|                "__builtin_ctz does not take 32-bit arg");
  255|      2|  return __builtin_ctz(x);
  256|       |#elif defined(_MSC_VER) && !defined(__clang__)
  257|       |  unsigned long result = 0;  // NOLINT(runtime/int)
  258|       |  _BitScanForward(&result, x);
  259|       |  return result;
  260|       |#else
  261|       |  int c = 31;
  262|       |  x &= ~x + 1;
  263|       |  if (x & 0x0000FFFF) c -= 16;
  264|       |  if (x & 0x00FF00FF) c -= 8;
  265|       |  if (x & 0x0F0F0F0F) c -= 4;
  266|       |  if (x & 0x33333333) c -= 2;
  267|       |  if (x & 0x55555555) c -= 1;
  268|       |  return c;
  269|       |#endif
  270|      2|}

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

_ZN4absl12lts_2024011621discrete_distributionIiEC2Ev:
  111|      2|  discrete_distribution() : param_() {}
_ZN4absl12lts_2024011621discrete_distributionIiE10param_typeC2Ev:
   60|      2|    param_type() { init(); }
_ZN4absl12lts_2024011621discrete_distributionIiE10param_type4initEv:
  183|      4|void discrete_distribution<IntType>::param_type::init() {
  184|      4|  if (p_.empty()) {
  ------------------
  |  Branch (184:7): [True: 2, False: 2]
  ------------------
  185|      2|    p_.push_back(1.0);
  186|      2|    q_.emplace_back(1.0, 0);
  187|      2|  } else {
  188|       |    assert(n() <= (std::numeric_limits<IntType>::max)());
  189|      2|    q_ = random_internal::InitDiscreteDistribution(&p_);
  190|      2|  }
  191|      4|}
_ZN4absl12lts_2024011621discrete_distributionIiEC2INSt3__111__wrap_iterIPdEEEET_S8_:
  117|      2|      : param_(begin, end) {}
_ZN4absl12lts_2024011621discrete_distributionIiE10param_typeC2INSt3__111__wrap_iterIPdEEEET_S9_:
   64|      2|        : p_(begin, end) {
   65|      2|      init();
   66|      2|    }

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

_ZN4absl12lts_2024011615random_internal18DistributionCallerINS1_17NonsecureURBGBaseINS1_13randen_engineImEENS1_17RandenPoolSeedSeqEEEE4CallINS1_26UniformDistributionWrapperIjEEJEEENT_11result_typeEPS7_DpOT0_:
   85|     16|  static typename DistrT::result_type Call(URBG* urbg, Args&&... args) {
   86|     16|    return Impl<DistrT, Args...>(HasInvokeMock{}, urbg,
   87|     16|                                 std::forward<Args>(args)...);
   88|     16|  }
_ZN4absl12lts_2024011615random_internal18DistributionCallerINS1_17NonsecureURBGBaseINS1_13randen_engineImEENS1_17RandenPoolSeedSeqEEEE4ImplINS1_26UniformDistributionWrapperIjEEJEEENT_11result_typeENSt3__117integral_constantIbLb0EEEPS7_DpOT0_:
   59|     16|                                           Args&&... args) {
   60|     16|    DistrT dist(std::forward<Args>(args)...);
   61|     16|    return dist(*urbg);
   62|     16|  }

_ZN4absl12lts_2024011615random_internal15FastUniformBitsIjEclINS1_17NonsecureURBGBaseINS1_13randen_engineImEENS1_17RandenPoolSeedSeqEEEEEjRT_:
  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 = absl::conditional_t<IsPowerOfTwoOrZero(RangeSize<URBG>()),
  130|     16|                                  SimplifiedLoopTag, RejectionLoopTag>;
  131|     16|  return Generate(g, tag{});
  132|     16|}
_ZN4absl12lts_2024011615random_internal15FastUniformBitsIjE8GenerateINS1_17NonsecureURBGBaseINS1_13randen_engineImEENS1_17RandenPoolSeedSeqEEEEEjRT_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_2024011615random_internal17RandenPoolSeedSeq4sizeEv:
   67|      2|  size_t size() { return 0; }
_ZN4absl12lts_2024011615random_internal17NonsecureURBGBaseINS1_13randen_engineImEENS1_17RandenPoolSeedSeqEEC2Ev:
  101|      2|  NonsecureURBGBase() : urbg_(ConstructURBG()) {}
_ZN4absl12lts_2024011615random_internal17NonsecureURBGBaseINS1_13randen_engineImEENS1_17RandenPoolSeedSeqEE13ConstructURBGEv:
  142|      2|  static URBG ConstructURBG() {
  143|      2|    Seeder seeder;
  144|      2|    return URBG(seeder);
  145|      2|  }
_ZN4absl12lts_2024011615random_internal17RandenPoolSeedSeq8generateIPjEEvT_S5_:
   73|      2|  void generate(RandomAccessIterator begin, RandomAccessIterator end) {
   74|       |    // RandomAccessIterator must be assignable from uint32_t
   75|      2|    if (begin != end) {
  ------------------
  |  Branch (75:9): [True: 2, False: 0]
  ------------------
   76|      2|      using U = typename std::iterator_traits<RandomAccessIterator>::value_type;
   77|       |      // ContiguousTag indicates the common case of a known contiguous buffer,
   78|       |      // which allows directly filling the buffer. In C++20,
   79|       |      // std::contiguous_iterator_tag provides a mechanism for testing this
   80|       |      // capability, however until Abseil's support requirements allow us to
   81|       |      // assume C++20, limit checks to a few common cases.
   82|      2|      using TagType = absl::conditional_t<
   83|      2|          (std::is_pointer<RandomAccessIterator>::value ||
   84|      2|           std::is_same<RandomAccessIterator,
   85|      2|                        typename std::vector<U>::iterator>::value),
   86|      2|          ContiguousTag, BufferTag>;
   87|       |
   88|      2|      generate_impl(TagType{}, begin, end);
   89|      2|    }
   90|      2|  }
_ZN4absl12lts_2024011615random_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|    RandenPool<uint8_t>::Fill(
   50|      2|        absl::MakeSpan(reinterpret_cast<uint8_t*>(a), sizeof(*a) * n));
   51|      2|  }
_ZN4absl12lts_2024011615random_internal17NonsecureURBGBaseINS1_13randen_engineImEENS1_17RandenPoolSeedSeqEEclEv:
  126|     16|  result_type operator()() { return urbg_(); }

_ZN4absl12lts_2024011615random_internal10RandenPoolIhE4FillENS0_4SpanIhEE:
  240|      2|void RandenPool<T>::Fill(absl::Span<result_type> data) {
  241|      2|  auto* pool = GetPoolForCurrentThread();
  242|      2|  pool->Fill(reinterpret_cast<uint8_t*>(data.data()),
  243|      2|             data.size() * sizeof(result_type));
  244|      2|}
pool_urbg.cc:_ZN4absl12lts_2024011615random_internal12_GLOBAL__N_115RandenPoolEntry11MaybeRefillEv:
   69|      2|  inline void MaybeRefill() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
   70|      2|    if (next_ >= kState) {
  ------------------
  |  Branch (70:9): [True: 2, False: 0]
  ------------------
   71|      2|      next_ = kCapacity;
   72|      2|      impl_.Generate(state_);
   73|      2|    }
   74|      2|  }
pool_urbg.cc:_ZN4absl12lts_2024011615random_internal12_GLOBAL__N_115RandenPoolEntry4FillEPhm:
  120|      2|void RandenPoolEntry::Fill(uint8_t* out, size_t bytes) {
  121|      2|  SpinLockHolder l(&mu_);
  122|      4|  while (bytes > 0) {
  ------------------
  |  Branch (122:10): [True: 2, False: 2]
  ------------------
  123|      2|    MaybeRefill();
  124|      2|    size_t remaining = (kState - next_) * sizeof(state_[0]);
  125|      2|    size_t to_copy = std::min(bytes, remaining);
  126|      2|    std::memcpy(out, &state_[next_], to_copy);
  127|      2|    out += to_copy;
  128|      2|    bytes -= to_copy;
  129|      2|    next_ += (to_copy + sizeof(state_[0]) - 1) / sizeof(state_[0]);
  130|      2|  }
  131|      2|}
pool_urbg.cc:_ZN4absl12lts_2024011615random_internal12_GLOBAL__N_123GetPoolForCurrentThreadEv:
  226|      2|RandenPoolEntry* GetPoolForCurrentThread() {
  227|      2|  absl::call_once(pool_once, InitPoolURBG);
  228|      2|  return shared_pools[GetPoolID()];
  229|      2|}
pool_urbg.cc:_ZN4absl12lts_2024011615random_internal12_GLOBAL__N_112InitPoolURBGEv:
  209|      2|void InitPoolURBG() {
  210|      2|  static constexpr size_t kSeedSize =
  211|      2|      RandenTraits::kStateBytes / sizeof(uint32_t);
  212|       |  // Read the seed data from OS entropy once.
  213|      2|  uint32_t seed_material[kPoolSize * kSeedSize];
  214|      2|  if (!random_internal::ReadSeedMaterialFromOSEntropy(
  ------------------
  |  Branch (214:7): [True: 0, False: 2]
  ------------------
  215|      2|          absl::MakeSpan(seed_material))) {
  216|      0|    random_internal::ThrowSeedGenException();
  217|      0|  }
  218|     18|  for (size_t i = 0; i < kPoolSize; i++) {
  ------------------
  |  Branch (218:22): [True: 16, False: 2]
  ------------------
  219|     16|    shared_pools[i] = PoolAlignedAlloc();
  220|     16|    shared_pools[i]->Init(
  221|     16|        absl::MakeSpan(&seed_material[i * kSeedSize], kSeedSize));
  222|     16|  }
  223|      2|}
pool_urbg.cc:_ZN4absl12lts_2024011615random_internal12_GLOBAL__N_116PoolAlignedAllocEv:
  190|     16|RandenPoolEntry* PoolAlignedAlloc() {
  191|     16|  constexpr size_t kAlignment =
  192|     16|      ABSL_CACHELINE_SIZE > 32 ? ABSL_CACHELINE_SIZE : 32;
  ------------------
  |  |   77|     16|#define ABSL_CACHELINE_SIZE 64
  ------------------
                    ABSL_CACHELINE_SIZE > 32 ? ABSL_CACHELINE_SIZE : 32;
  ------------------
  |  |   77|      0|#define ABSL_CACHELINE_SIZE 64
  ------------------
  |  Branch (192:7): [True: 0, Folded]
  ------------------
  193|       |
  194|       |  // Not all the platforms that we build for have std::aligned_alloc, however
  195|       |  // since we never free these objects, we can over allocate and munge the
  196|       |  // pointers to the correct alignment.
  197|     16|  uintptr_t x = reinterpret_cast<uintptr_t>(
  198|     16|      new char[sizeof(RandenPoolEntry) + kAlignment]);
  199|     16|  auto y = x % kAlignment;
  200|     16|  void* aligned = reinterpret_cast<void*>(y == 0 ? x : (x + kAlignment - y));
  ------------------
  |  Branch (200:43): [True: 4, False: 12]
  ------------------
  201|     16|  return new (aligned) RandenPoolEntry();
  202|     16|}
pool_urbg.cc:_ZN4absl12lts_2024011615random_internal12_GLOBAL__N_115RandenPoolEntry4InitENS0_4SpanIKjEE:
   56|     16|  void Init(absl::Span<const uint32_t> data) {
   57|     16|    SpinLockHolder l(&mu_);  // Always uncontested.
   58|     16|    std::copy(data.begin(), data.end(), std::begin(state_));
   59|     16|    next_ = kState;
   60|     16|  }
pool_urbg.cc:_ZN4absl12lts_2024011615random_internal12_GLOBAL__N_19GetPoolIDEv:
  150|      2|size_t GetPoolID() {
  151|      2|  static_assert(kPoolSize >= 1,
  152|      2|                "At least one urbg instance is required for PoolURBG");
  153|       |
  154|      2|  ABSL_CONST_INIT static std::atomic<uint64_t> sequence{0};
  ------------------
  |  |  745|      2|#define ABSL_CONST_INIT [[clang::require_constant_initialization]]
  ------------------
  155|       |
  156|      2|#ifdef ABSL_HAVE_THREAD_LOCAL
  157|      2|  static thread_local size_t my_pool_id = kPoolSize;
  158|      2|  if (ABSL_PREDICT_FALSE(my_pool_id == kPoolSize)) {
  ------------------
  |  |  178|      2|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 2, False: 0]
  |  |  |  Branch (178:49): [Folded, False: 2]
  |  |  |  Branch (178:58): [True: 2, False: 0]
  |  |  ------------------
  ------------------
  159|      2|    my_pool_id = (sequence++ % kPoolSize);
  160|      2|  }
  161|      2|  return my_pool_id;
  162|       |#else
  163|       |  static pthread_key_t tid_key = [] {
  164|       |    pthread_key_t tmp_key;
  165|       |    int err = pthread_key_create(&tmp_key, nullptr);
  166|       |    if (err) {
  167|       |      ABSL_RAW_LOG(FATAL, "pthread_key_create failed with %d", err);
  168|       |    }
  169|       |    return tmp_key;
  170|       |  }();
  171|       |
  172|       |  // Store the value in the pthread_{get/set}specific. However an uninitialized
  173|       |  // value is 0, so add +1 to distinguish from the null value.
  174|       |  uintptr_t my_pool_id =
  175|       |      reinterpret_cast<uintptr_t>(pthread_getspecific(tid_key));
  176|       |  if (ABSL_PREDICT_FALSE(my_pool_id == 0)) {
  177|       |    // No allocated ID, allocate the next value, cache it, and return.
  178|       |    my_pool_id = (sequence++ % kPoolSize) + 1;
  179|       |    int err = pthread_setspecific(tid_key, reinterpret_cast<void*>(my_pool_id));
  180|       |    if (err) {
  181|       |      ABSL_RAW_LOG(FATAL, "pthread_setspecific failed with %d", err);
  182|       |    }
  183|       |  }
  184|       |  return my_pool_id - 1;
  185|       |#endif
  186|      2|}

_ZN4absl12lts_2024011615random_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_2024011615random_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_2024011615random_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: 2, False: 0]
  |  Branch (58:43): [True: 2, False: 0]
  ------------------
   59|      2|      tmp.has_crypto = true;
   60|      2|      tmp.keys = RandenHwAes::GetKeys();
   61|      2|    } else {
   62|      0|      tmp.has_crypto = false;
   63|      0|      tmp.keys = RandenSlow::GetKeys();
   64|      0|    }
   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_2024011615random_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: 4, False: 0]
  ------------------
   51|      4|      RandenHwAes::Generate(keys_, state);
   52|      4|    } else {
   53|      0|      RandenSlow::Generate(keys_, state);
   54|      0|    }
   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_2024011615random_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: 2, False: 0]
  ------------------
   72|      2|      RandenHwAes::Absorb(seed, state);
   73|      2|    } else {
   74|      0|      RandenSlow::Absorb(seed, state);
   75|      0|    }
   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_2024011615random_internal22CPUSupportsRandenHwAesEv:
  135|      2|bool CPUSupportsRandenHwAes() {
  136|      2|#if defined(ABSL_INTERNAL_USE_X86_CPUID)
  137|       |  // 1. For x86: Use CPUID to detect the required AES instruction set.
  138|      2|  int regs[4];
  139|      2|  __cpuid(reinterpret_cast<int*>(regs), 1);
  140|      2|  return regs[2] & (1 << 25);  // AES
  141|       |
  142|       |#elif defined(ABSL_INTERNAL_USE_GETAUXVAL)
  143|       |  // 2. Use getauxval() to read the hardware bits and determine
  144|       |  // cpu capabilities.
  145|       |
  146|       |#define AT_HWCAP 16
  147|       |#define AT_HWCAP2 26
  148|       |#if defined(ABSL_ARCH_PPC)
  149|       |  // For Power / PPC: Expect that the cpu supports VCRYPTO
  150|       |  // See https://members.openpowerfoundation.org/document/dl/576
  151|       |  // VCRYPTO should be present in POWER8 >= 2.07.
  152|       |  // Uses Linux kernel constants from arch/powerpc/include/uapi/asm/cputable.h
  153|       |  static const uint32_t kVCRYPTO = 0x02000000;
  154|       |  const uint32_t hwcap = GetAuxval(AT_HWCAP2);
  155|       |  return (hwcap & kVCRYPTO) != 0;
  156|       |
  157|       |#elif defined(ABSL_ARCH_ARM)
  158|       |  // For ARM: Require crypto+neon
  159|       |  // http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.ddi0500f/CIHBIBBA.html
  160|       |  // Uses Linux kernel constants from arch/arm64/include/asm/hwcap.h
  161|       |  static const uint32_t kNEON = 1 << 12;
  162|       |  uint32_t hwcap = GetAuxval(AT_HWCAP);
  163|       |  if ((hwcap & kNEON) == 0) {
  164|       |    return false;
  165|       |  }
  166|       |
  167|       |  // And use it again to detect AES.
  168|       |  static const uint32_t kAES = 1 << 0;
  169|       |  const uint32_t hwcap2 = GetAuxval(AT_HWCAP2);
  170|       |  return (hwcap2 & kAES) != 0;
  171|       |
  172|       |#elif defined(ABSL_ARCH_AARCH64)
  173|       |  // For AARCH64: Require crypto+neon
  174|       |  // http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.ddi0500f/CIHBIBBA.html
  175|       |  static const uint32_t kNEON = 1 << 1;
  176|       |  static const uint32_t kAES = 1 << 3;
  177|       |  const uint32_t hwcap = GetAuxval(AT_HWCAP);
  178|       |  return ((hwcap & kNEON) != 0) && ((hwcap & kAES) != 0);
  179|       |#endif
  180|       |
  181|       |#else  // ABSL_INTERNAL_USE_GETAUXVAL
  182|       |  // 3. By default, assume that the compiler default.
  183|       |  return ABSL_HAVE_ACCELERATED_AES ? true : false;
  184|       |
  185|       |#endif
  186|       |  // NOTE: There are some other techniques that may be worth trying:
  187|       |  //
  188|       |  // * Use an environment variable: ABSL_RANDOM_USE_HWAES
  189|       |  //
  190|       |  // * Rely on compiler-generated target-based dispatch.
  191|       |  // Using x86/gcc it might look something like this:
  192|       |  //
  193|       |  // int __attribute__((target("aes"))) HasAes() { return 1; }
  194|       |  // int __attribute__((target("default"))) HasAes() { return 0; }
  195|       |  //
  196|       |  // This does not work on all architecture/compiler combinations.
  197|       |  //
  198|       |  // * On Linux consider reading /proc/cpuinfo and/or /proc/self/auxv.
  199|       |  // These files have lines which are easy to parse; for ARM/AARCH64 it is quite
  200|       |  // easy to find the Features: line and extract aes / neon. Likewise for
  201|       |  // PPC.
  202|       |  //
  203|       |  // * Fork a process and test for SIGILL:
  204|       |  //
  205|       |  // * Many architectures have instructions to read the ISA. Unfortunately
  206|       |  //   most of those require that the code is running in ring 0 /
  207|       |  //   protected-mode.
  208|       |  //
  209|       |  //   There are several examples. e.g. Valgrind detects PPC ISA 2.07:
  210|       |  //   https://github.com/lu-zero/valgrind/blob/master/none/tests/ppc64/test_isa_2_07_part1.c
  211|       |  //
  212|       |  //   MRS <Xt>, ID_AA64ISAR0_EL1 ; Read ID_AA64ISAR0_EL1 into Xt
  213|       |  //
  214|       |  //   uint64_t val;
  215|       |  //   __asm __volatile("mrs %0, id_aa64isar0_el1" :"=&r" (val));
  216|       |  //
  217|       |  // * Use a CPUID-style heuristic database.
  218|       |  //
  219|       |  // * On Apple (__APPLE__), AES is available on Arm v8.
  220|       |  //   https://stackoverflow.com/questions/45637888/how-to-determine-armv8-features-at-runtime-on-ios
  221|      2|}
randen_detect.cc:_ZL7__cpuidPii:
   54|      2|static void __cpuid(int cpu_info[4], int info_type) {
   55|      2|  __asm__ volatile("cpuid \n\t"
   56|      2|                   : "=a"(cpu_info[0]), "=b"(cpu_info[1]), "=c"(cpu_info[2]),
   57|      2|                     "=d"(cpu_info[3])
   58|      2|                   : "a"(info_type), "c"(0));
   59|      2|}

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

_ZN4absl12lts_2024011615random_internal28HasRandenHwAesImplementationEv:
  408|      2|bool HasRandenHwAesImplementation() { return true; }
_ZN4absl12lts_2024011615random_internal11RandenHwAes7GetKeysEv:
  410|      2|const void* ABSL_TARGET_CRYPTO RandenHwAes::GetKeys() {
  411|       |  // Round keys for one AES per Feistel round and branch.
  412|       |  // The canonical implementation uses first digits of Pi.
  413|       |#if defined(ABSL_ARCH_PPC)
  414|       |  return kRandenRoundKeysBE;
  415|       |#else
  416|      2|  return kRandenRoundKeys;
  417|      2|#endif
  418|      2|}
_ZN4absl12lts_2024011615random_internal11RandenHwAes6AbsorbEPKvPv:
  422|      2|                                            void* state_void) {
  423|      2|  static_assert(RandenTraits::kCapacityBytes / sizeof(Vector128) == 1,
  424|      2|                "Unexpected Randen kCapacityBlocks");
  425|      2|  static_assert(RandenTraits::kStateBytes / sizeof(Vector128) == 16,
  426|      2|                "Unexpected Randen kStateBlocks");
  427|       |
  428|      2|  auto* state = reinterpret_cast<absl::uint128 * ABSL_RANDOM_INTERNAL_RESTRICT>(
  429|      2|      state_void);
  430|      2|  const auto* seed =
  431|      2|      reinterpret_cast<const absl::uint128 * ABSL_RANDOM_INTERNAL_RESTRICT>(
  432|      2|          seed_void);
  433|       |
  434|      2|  Vector128 b1 = Vector128Load(state + 1);
  435|      2|  b1 ^= Vector128Load(seed + 0);
  436|      2|  Vector128Store(b1, state + 1);
  437|       |
  438|      2|  Vector128 b2 = Vector128Load(state + 2);
  439|      2|  b2 ^= Vector128Load(seed + 1);
  440|      2|  Vector128Store(b2, state + 2);
  441|       |
  442|      2|  Vector128 b3 = Vector128Load(state + 3);
  443|      2|  b3 ^= Vector128Load(seed + 2);
  444|      2|  Vector128Store(b3, state + 3);
  445|       |
  446|      2|  Vector128 b4 = Vector128Load(state + 4);
  447|      2|  b4 ^= Vector128Load(seed + 3);
  448|      2|  Vector128Store(b4, state + 4);
  449|       |
  450|      2|  Vector128 b5 = Vector128Load(state + 5);
  451|      2|  b5 ^= Vector128Load(seed + 4);
  452|      2|  Vector128Store(b5, state + 5);
  453|       |
  454|      2|  Vector128 b6 = Vector128Load(state + 6);
  455|      2|  b6 ^= Vector128Load(seed + 5);
  456|      2|  Vector128Store(b6, state + 6);
  457|       |
  458|      2|  Vector128 b7 = Vector128Load(state + 7);
  459|      2|  b7 ^= Vector128Load(seed + 6);
  460|      2|  Vector128Store(b7, state + 7);
  461|       |
  462|      2|  Vector128 b8 = Vector128Load(state + 8);
  463|      2|  b8 ^= Vector128Load(seed + 7);
  464|      2|  Vector128Store(b8, state + 8);
  465|       |
  466|      2|  Vector128 b9 = Vector128Load(state + 9);
  467|      2|  b9 ^= Vector128Load(seed + 8);
  468|      2|  Vector128Store(b9, state + 9);
  469|       |
  470|      2|  Vector128 b10 = Vector128Load(state + 10);
  471|      2|  b10 ^= Vector128Load(seed + 9);
  472|      2|  Vector128Store(b10, state + 10);
  473|       |
  474|      2|  Vector128 b11 = Vector128Load(state + 11);
  475|      2|  b11 ^= Vector128Load(seed + 10);
  476|      2|  Vector128Store(b11, state + 11);
  477|       |
  478|      2|  Vector128 b12 = Vector128Load(state + 12);
  479|      2|  b12 ^= Vector128Load(seed + 11);
  480|      2|  Vector128Store(b12, state + 12);
  481|       |
  482|      2|  Vector128 b13 = Vector128Load(state + 13);
  483|      2|  b13 ^= Vector128Load(seed + 12);
  484|      2|  Vector128Store(b13, state + 13);
  485|       |
  486|      2|  Vector128 b14 = Vector128Load(state + 14);
  487|      2|  b14 ^= Vector128Load(seed + 13);
  488|      2|  Vector128Store(b14, state + 14);
  489|       |
  490|      2|  Vector128 b15 = Vector128Load(state + 15);
  491|      2|  b15 ^= Vector128Load(seed + 14);
  492|      2|  Vector128Store(b15, state + 15);
  493|      2|}
_ZN4absl12lts_2024011615random_internal11RandenHwAes8GenerateEPKvPv:
  497|      4|                                              void* state_void) {
  498|      4|  static_assert(RandenTraits::kCapacityBytes == sizeof(Vector128),
  499|      4|                "Capacity mismatch");
  500|       |
  501|      4|  auto* state = reinterpret_cast<absl::uint128*>(state_void);
  502|      4|  const auto* keys = reinterpret_cast<const absl::uint128*>(keys_void);
  503|       |
  504|      4|  const Vector128 prev_inner = Vector128Load(state);
  505|       |
  506|      4|  SwapEndian(state);
  507|       |
  508|      4|  Permute(state, keys);
  509|       |
  510|      4|  SwapEndian(state);
  511|       |
  512|       |  // Ensure backtracking resistance.
  513|      4|  Vector128 inner = Vector128Load(state);
  514|      4|  inner ^= prev_inner;
  515|      4|  Vector128Store(inner, state);
  516|      4|}
randen_hwaes.cc:_ZN12_GLOBAL__N_113Vector128LoadEPKv:
  236|  2.78k|inline ABSL_TARGET_CRYPTO Vector128 Vector128Load(const void* from) {
  237|  2.78k|  return Vector128(_mm_load_si128(reinterpret_cast<const __m128i*>(from)));
  238|  2.78k|}
randen_hwaes.cc:_ZN12_GLOBAL__N_19Vector128C2ERKDv2_x:
  223|  3.87k|  inline explicit Vector128(const __m128i& v) : data_(v) {}
randen_hwaes.cc:_ZN12_GLOBAL__N_19Vector128eOERKS0_:
  227|     34|  inline Vector128& operator^=(const Vector128& other) {
  228|     34|    data_ = _mm_xor_si128(data_, other.data());
  229|     34|    return *this;
  230|     34|  }
randen_hwaes.cc:_ZNK12_GLOBAL__N_19Vector1284dataEv:
  225|  3.87k|  inline __m128i data() const { return data_; }
randen_hwaes.cc:_ZN12_GLOBAL__N_114Vector128StoreERKNS_9Vector128EPv:
  240|  1.66k|inline ABSL_TARGET_CRYPTO void Vector128Store(const Vector128& v, void* to) {
  241|  1.66k|  _mm_store_si128(reinterpret_cast<__m128i*>(to), v.data());
  242|  1.66k|}
randen_hwaes.cc:_ZN12_GLOBAL__N_110SwapEndianEPv:
  254|      8|inline ABSL_TARGET_CRYPTO void SwapEndian(void*) {}
randen_hwaes.cc:_ZN12_GLOBAL__N_17PermuteEPN4absl12lts_202401167uint128EPKS2_:
  391|      4|    const absl::uint128* ABSL_RANDOM_INTERNAL_RESTRICT keys) {
  392|       |  // (Successfully unrolled; the first iteration jumps into the second half)
  393|      4|#ifdef __clang__
  394|      4|#pragma clang loop unroll_count(2)
  395|      4|#endif
  396|     72|  for (size_t round = 0; round < RandenTraits::kFeistelRounds; ++round) {
  ------------------
  |  Branch (396:26): [True: 68, False: 4]
  ------------------
  397|     68|    keys = FeistelRound(state, keys);
  398|     68|    BlockShuffle(state);
  399|     68|  }
  400|      4|}
randen_hwaes.cc:_ZN12_GLOBAL__N_112FeistelRoundEPN4absl12lts_202401167uint128EPKS2_:
  329|     68|    const absl::uint128* ABSL_RANDOM_INTERNAL_RESTRICT keys) {
  330|     68|  static_assert(RandenTraits::kFeistelBlocks == 16,
  331|     68|                "Expecting 16 FeistelBlocks.");
  332|       |
  333|       |  // MSVC does a horrible job at unrolling loops.
  334|       |  // So we unroll the loop by hand to improve the performance.
  335|     68|  const Vector128 s0 = Vector128Load(state + 0);
  336|     68|  const Vector128 s1 = Vector128Load(state + 1);
  337|     68|  const Vector128 s2 = Vector128Load(state + 2);
  338|     68|  const Vector128 s3 = Vector128Load(state + 3);
  339|     68|  const Vector128 s4 = Vector128Load(state + 4);
  340|     68|  const Vector128 s5 = Vector128Load(state + 5);
  341|     68|  const Vector128 s6 = Vector128Load(state + 6);
  342|     68|  const Vector128 s7 = Vector128Load(state + 7);
  343|     68|  const Vector128 s8 = Vector128Load(state + 8);
  344|     68|  const Vector128 s9 = Vector128Load(state + 9);
  345|     68|  const Vector128 s10 = Vector128Load(state + 10);
  346|     68|  const Vector128 s11 = Vector128Load(state + 11);
  347|     68|  const Vector128 s12 = Vector128Load(state + 12);
  348|     68|  const Vector128 s13 = Vector128Load(state + 13);
  349|     68|  const Vector128 s14 = Vector128Load(state + 14);
  350|     68|  const Vector128 s15 = Vector128Load(state + 15);
  351|       |
  352|       |  // Encode even blocks with keys.
  353|     68|  const Vector128 e0 = AesRound(s0, Vector128Load(keys + 0));
  354|     68|  const Vector128 e2 = AesRound(s2, Vector128Load(keys + 1));
  355|     68|  const Vector128 e4 = AesRound(s4, Vector128Load(keys + 2));
  356|     68|  const Vector128 e6 = AesRound(s6, Vector128Load(keys + 3));
  357|     68|  const Vector128 e8 = AesRound(s8, Vector128Load(keys + 4));
  358|     68|  const Vector128 e10 = AesRound(s10, Vector128Load(keys + 5));
  359|     68|  const Vector128 e12 = AesRound(s12, Vector128Load(keys + 6));
  360|     68|  const Vector128 e14 = AesRound(s14, Vector128Load(keys + 7));
  361|       |
  362|       |  // Encode odd blocks with even output from above.
  363|     68|  const Vector128 o1 = AesRound(e0, s1);
  364|     68|  const Vector128 o3 = AesRound(e2, s3);
  365|     68|  const Vector128 o5 = AesRound(e4, s5);
  366|     68|  const Vector128 o7 = AesRound(e6, s7);
  367|     68|  const Vector128 o9 = AesRound(e8, s9);
  368|     68|  const Vector128 o11 = AesRound(e10, s11);
  369|     68|  const Vector128 o13 = AesRound(e12, s13);
  370|     68|  const Vector128 o15 = AesRound(e14, s15);
  371|       |
  372|       |  // Store odd blocks. (These will be shuffled later).
  373|     68|  Vector128Store(o1, state + 1);
  374|     68|  Vector128Store(o3, state + 3);
  375|     68|  Vector128Store(o5, state + 5);
  376|     68|  Vector128Store(o7, state + 7);
  377|     68|  Vector128Store(o9, state + 9);
  378|     68|  Vector128Store(o11, state + 11);
  379|     68|  Vector128Store(o13, state + 13);
  380|     68|  Vector128Store(o15, state + 15);
  381|       |
  382|     68|  return keys + 8;
  383|     68|}
randen_hwaes.cc:_ZN12_GLOBAL__N_18AesRoundERKNS_9Vector128ES2_:
  247|  1.08k|                                             const Vector128& round_key) {
  248|       |  // It is important to always use the full round function - omitting the
  249|       |  // final MixColumns reduces security [https://eprint.iacr.org/2010/041.pdf]
  250|       |  // and does not help because we never decrypt.
  251|  1.08k|  return Vector128(_mm_aesenc_si128(state.data(), round_key.data()));
  252|  1.08k|}
randen_hwaes.cc:_ZN12_GLOBAL__N_112BlockShuffleEPN4absl12lts_202401167uint128E:
  280|     68|inline ABSL_TARGET_CRYPTO void BlockShuffle(absl::uint128* state) {
  281|     68|  static_assert(RandenTraits::kFeistelBlocks == 16,
  282|     68|                "Expecting 16 FeistelBlocks.");
  283|       |
  284|     68|  constexpr size_t shuffle[RandenTraits::kFeistelBlocks] = {
  285|     68|      7, 2, 13, 4, 11, 8, 3, 6, 15, 0, 9, 10, 1, 14, 5, 12};
  286|       |
  287|     68|  const Vector128 v0 = Vector128Load(state + shuffle[0]);
  288|     68|  const Vector128 v1 = Vector128Load(state + shuffle[1]);
  289|     68|  const Vector128 v2 = Vector128Load(state + shuffle[2]);
  290|     68|  const Vector128 v3 = Vector128Load(state + shuffle[3]);
  291|     68|  const Vector128 v4 = Vector128Load(state + shuffle[4]);
  292|     68|  const Vector128 v5 = Vector128Load(state + shuffle[5]);
  293|     68|  const Vector128 v6 = Vector128Load(state + shuffle[6]);
  294|     68|  const Vector128 v7 = Vector128Load(state + shuffle[7]);
  295|     68|  const Vector128 w0 = Vector128Load(state + shuffle[8]);
  296|     68|  const Vector128 w1 = Vector128Load(state + shuffle[9]);
  297|     68|  const Vector128 w2 = Vector128Load(state + shuffle[10]);
  298|     68|  const Vector128 w3 = Vector128Load(state + shuffle[11]);
  299|     68|  const Vector128 w4 = Vector128Load(state + shuffle[12]);
  300|     68|  const Vector128 w5 = Vector128Load(state + shuffle[13]);
  301|     68|  const Vector128 w6 = Vector128Load(state + shuffle[14]);
  302|     68|  const Vector128 w7 = Vector128Load(state + shuffle[15]);
  303|       |
  304|     68|  Vector128Store(v0, state + 0);
  305|     68|  Vector128Store(v1, state + 1);
  306|     68|  Vector128Store(v2, state + 2);
  307|     68|  Vector128Store(v3, state + 3);
  308|     68|  Vector128Store(v4, state + 4);
  309|     68|  Vector128Store(v5, state + 5);
  310|     68|  Vector128Store(v6, state + 6);
  311|     68|  Vector128Store(v7, state + 7);
  312|     68|  Vector128Store(w0, state + 8);
  313|     68|  Vector128Store(w1, state + 9);
  314|     68|  Vector128Store(w2, state + 10);
  315|     68|  Vector128Store(w3, state + 11);
  316|     68|  Vector128Store(w4, state + 12);
  317|     68|  Vector128Store(w5, state + 13);
  318|     68|  Vector128Store(w6, state + 14);
  319|     68|  Vector128Store(w7, state + 15);
  320|     68|}

_ZN4absl12lts_2024011615random_internal29ReadSeedMaterialFromOSEntropyENS0_4SpanIjEE:
  205|      2|bool ReadSeedMaterialFromOSEntropy(absl::Span<uint32_t> values) {
  206|      2|  assert(values.data() != nullptr);
  207|      2|  if (values.data() == nullptr) {
  ------------------
  |  Branch (207:7): [True: 0, False: 2]
  ------------------
  208|      0|    return false;
  209|      0|  }
  210|      2|  if (values.empty()) {
  ------------------
  |  Branch (210:7): [True: 0, False: 2]
  ------------------
  211|      0|    return true;
  212|      0|  }
  213|      2|  return ReadSeedMaterialFromOSEntropyImpl(values);
  214|      2|}
seed_material.cc:_ZN4absl12lts_2024011615random_internal12_GLOBAL__N_133ReadSeedMaterialFromOSEntropyImplENS0_4SpanIjEE:
  190|      2|bool ReadSeedMaterialFromOSEntropyImpl(absl::Span<uint32_t> values) {
  191|      2|#if defined(ABSL_RANDOM_USE_GET_ENTROPY)
  192|      2|  if (ReadSeedMaterialFromGetEntropy(values)) {
  ------------------
  |  Branch (192:7): [True: 2, False: 0]
  ------------------
  193|      2|    return true;
  194|      2|  }
  195|      0|#endif
  196|       |  // Libc may support getentropy, but the kernel may not, so we still have
  197|       |  // to fallback to ReadSeedMaterialFromDevURandom().
  198|      0|  return ReadSeedMaterialFromDevURandom(values);
  199|      2|}
seed_material.cc:_ZN4absl12lts_2024011615random_internal12_GLOBAL__N_130ReadSeedMaterialFromGetEntropyENS0_4SpanIjEE:
  142|      2|bool ReadSeedMaterialFromGetEntropy(absl::Span<uint32_t> values) {
  143|      2|  auto buffer = reinterpret_cast<uint8_t*>(values.data());
  144|      2|  size_t buffer_size = sizeof(uint32_t) * values.size();
  145|     18|  while (buffer_size > 0) {
  ------------------
  |  Branch (145:10): [True: 16, False: 2]
  ------------------
  146|       |    // getentropy() has a maximum permitted length of 256.
  147|     16|    size_t to_read = std::min<size_t>(buffer_size, 256);
  148|     16|    int result = getentropy(buffer, to_read);
  149|     16|    if (result < 0) {
  ------------------
  |  Branch (149:9): [True: 0, False: 16]
  ------------------
  150|      0|      return false;
  151|      0|    }
  152|       |    // https://github.com/google/sanitizers/issues/1173
  153|       |    // MemorySanitizer can't see through getentropy().
  154|     16|    ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(buffer, to_read);
  155|     16|    buffer += to_read;
  156|     16|    buffer_size -= to_read;
  157|     16|  }
  158|      2|  return true;
  159|      2|}

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

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

_ZN4absl12lts_202401166StatusD2Ev:
  814|  23.0M|inline Status::~Status() { Unref(rep_); }
_ZN4absl12lts_202401166Status5UnrefEm:
  920|  23.0M|inline void Status::Unref(uintptr_t rep) {
  921|  23.0M|  if (!IsInlined(rep)) RepToPointer(rep)->Unref();
  ------------------
  |  Branch (921:7): [True: 0, False: 23.0M]
  ------------------
  922|  23.0M|}
_ZN4absl12lts_202401166Status9IsInlinedEm:
  888|  23.0M|constexpr bool Status::IsInlined(uintptr_t rep) { return (rep & 1) != 0; }
_ZN4absl12lts_202401168OkStatusEv:
  924|  23.0M|inline Status OkStatus() { return Status(); }
_ZN4absl12lts_202401166StatusC2Ev:
  772|  23.0M|inline Status::Status() : Status(absl::StatusCode::kOk) {}
_ZN4absl12lts_202401166StatusC2ENS0_10StatusCodeE:
  774|  23.0M|inline Status::Status(absl::StatusCode code) : Status(CodeToInlinedRep(code)) {}
_ZN4absl12lts_202401166Status16CodeToInlinedRepENS0_10StatusCodeE:
  892|  46.0M|constexpr uintptr_t Status::CodeToInlinedRep(absl::StatusCode code) {
  893|  46.0M|  return (static_cast<uintptr_t>(code) << 2) + 1;
  894|  46.0M|}
_ZN4absl12lts_202401166StatusC2Em:
  619|  23.0M|  explicit Status(uintptr_t rep) : rep_(rep) {}
_ZN4absl12lts_202401166StatusaSEOS1_:
  792|  5.53k|inline Status& Status::operator=(Status&& x) {
  793|  5.53k|  uintptr_t old_rep = rep_;
  794|  5.53k|  if (x.rep_ != old_rep) {
  ------------------
  |  Branch (794:7): [True: 0, False: 5.53k]
  ------------------
  795|      0|    rep_ = x.rep_;
  796|      0|    x.rep_ = MovedFromRep();
  797|      0|    Unref(old_rep);
  798|      0|  }
  799|  5.53k|  return *this;
  800|  5.53k|}
_ZNK4absl12lts_202401166Status2okEv:
  816|  23.0M|inline bool Status::ok() const {
  817|  23.0M|  return rep_ == CodeToInlinedRep(absl::StatusCode::kOk);
  818|  23.0M|}
_ZN4absl12lts_202401166Status3RefEm:
  916|  5.53k|inline void Status::Ref(uintptr_t rep) {
  917|  5.53k|  if (!IsInlined(rep)) RepToPointer(rep)->Ref();
  ------------------
  |  Branch (917:7): [True: 0, False: 5.53k]
  ------------------
  918|  5.53k|}
_ZN4absl12lts_202401166StatusC2ERKS1_:
  776|  5.53k|inline Status::Status(const Status& x) : Status(x.rep_) { Ref(rep_); }

_ZN4absl12lts_2024011613ascii_isspaceEh:
   97|   355k|inline bool ascii_isspace(unsigned char c) {
   98|   355k|  return (ascii_internal::kPropertyBits[c] & 0x08) != 0;
   99|   355k|}
_ZN4absl12lts_2024011627StripLeadingAsciiWhitespaceENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  200|  25.7k|    absl::string_view str) {
  201|  25.7k|  auto it = std::find_if_not(str.begin(), str.end(), absl::ascii_isspace);
  202|  25.7k|  return str.substr(static_cast<size_t>(it - str.begin()));
  203|  25.7k|}
_ZN4absl12lts_2024011628StripTrailingAsciiWhitespaceENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  214|  25.7k|    absl::string_view str) {
  215|  25.7k|  auto it = std::find_if_not(str.rbegin(), str.rend(), absl::ascii_isspace);
  216|  25.7k|  return str.substr(0, static_cast<size_t>(str.rend() - it));
  217|  25.7k|}
_ZN4absl12lts_2024011620StripAsciiWhitespaceENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  228|  25.7k|    absl::string_view str) {
  229|  25.7k|  return StripTrailingAsciiWhitespace(StripLeadingAsciiWhitespace(str));
  230|  25.7k|}

_ZN4absl12lts_2024011610from_charsEPKcS2_RdNS0_12chars_formatE:
  953|  25.7k|                             chars_format fmt) {
  954|  25.7k|  return FromCharsImpl(first, last, value, fmt);
  955|  25.7k|}
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_113FromCharsImplIdEENS0_17from_chars_resultEPKcS5_RT_NS0_12chars_formatE:
  866|  25.7k|                                FloatType& value, chars_format fmt_flags) {
  867|  25.7k|  from_chars_result result;
  868|  25.7k|  result.ptr = first;  // overwritten on successful parse
  869|  25.7k|  result.ec = std::errc();
  870|       |
  871|  25.7k|  bool negative = false;
  872|  25.7k|  if (first != last && *first == '-') {
  ------------------
  |  Branch (872:7): [True: 25.6k, False: 17]
  |  Branch (872:24): [True: 3.55k, False: 22.1k]
  ------------------
  873|  3.55k|    ++first;
  874|  3.55k|    negative = true;
  875|  3.55k|  }
  876|       |  // If the `hex` flag is *not* set, then we will accept a 0x prefix and try
  877|       |  // to parse a hexadecimal float.
  878|  25.7k|  if ((fmt_flags & chars_format::hex) == chars_format{} && last - first >= 2 &&
  ------------------
  |  Branch (878:7): [True: 25.7k, False: 0]
  |  Branch (878:60): [True: 23.8k, False: 1.84k]
  ------------------
  879|  23.8k|      *first == '0' && (first[1] == 'x' || first[1] == 'X')) {
  ------------------
  |  Branch (879:7): [True: 6.10k, False: 17.7k]
  |  Branch (879:25): [True: 2.90k, False: 3.20k]
  |  Branch (879:44): [True: 2.16k, False: 1.04k]
  ------------------
  880|  5.06k|    const char* hex_first = first + 2;
  881|  5.06k|    strings_internal::ParsedFloat hex_parse =
  882|  5.06k|        strings_internal::ParseFloat<16>(hex_first, last, fmt_flags);
  883|  5.06k|    if (hex_parse.end == nullptr ||
  ------------------
  |  Branch (883:9): [True: 27, False: 5.03k]
  ------------------
  884|  5.03k|        hex_parse.type != strings_internal::FloatType::kNumber) {
  ------------------
  |  Branch (884:9): [True: 2, False: 5.03k]
  ------------------
  885|       |      // Either we failed to parse a hex float after the "0x", or we read
  886|       |      // "0xinf" or "0xnan" which we don't want to match.
  887|       |      //
  888|       |      // However, a string that begins with "0x" also begins with "0", which
  889|       |      // is normally a valid match for the number zero.  So we want these
  890|       |      // strings to match zero unless fmt_flags is `scientific`.  (This flag
  891|       |      // means an exponent is required, which the string "0" does not have.)
  892|     29|      if (fmt_flags == chars_format::scientific) {
  ------------------
  |  Branch (892:11): [True: 0, False: 29]
  ------------------
  893|      0|        result.ec = std::errc::invalid_argument;
  894|     29|      } else {
  895|     29|        result.ptr = first + 1;
  896|     29|        value = negative ? -0.0 : 0.0;
  ------------------
  |  Branch (896:17): [True: 2, False: 27]
  ------------------
  897|     29|      }
  898|     29|      return result;
  899|     29|    }
  900|       |    // We matched a value.
  901|  5.03k|    result.ptr = hex_parse.end;
  902|  5.03k|    if (HandleEdgeCase(hex_parse, negative, &value)) {
  ------------------
  |  Branch (902:9): [True: 1.00k, False: 4.02k]
  ------------------
  903|  1.00k|      return result;
  904|  1.00k|    }
  905|  4.02k|    CalculatedFloat calculated =
  906|  4.02k|        CalculateFromParsedHexadecimal<FloatType>(hex_parse);
  907|  4.02k|    EncodeResult(calculated, negative, &result, &value);
  908|  4.02k|    return result;
  909|  5.03k|  }
  910|       |  // Otherwise, we choose the number base based on the flags.
  911|  20.6k|  if ((fmt_flags & chars_format::hex) == chars_format::hex) {
  ------------------
  |  Branch (911:7): [True: 0, False: 20.6k]
  ------------------
  912|      0|    strings_internal::ParsedFloat hex_parse =
  913|      0|        strings_internal::ParseFloat<16>(first, last, fmt_flags);
  914|      0|    if (hex_parse.end == nullptr) {
  ------------------
  |  Branch (914:9): [True: 0, False: 0]
  ------------------
  915|      0|      result.ec = std::errc::invalid_argument;
  916|      0|      return result;
  917|      0|    }
  918|      0|    result.ptr = hex_parse.end;
  919|      0|    if (HandleEdgeCase(hex_parse, negative, &value)) {
  ------------------
  |  Branch (919:9): [True: 0, False: 0]
  ------------------
  920|      0|      return result;
  921|      0|    }
  922|      0|    CalculatedFloat calculated =
  923|      0|        CalculateFromParsedHexadecimal<FloatType>(hex_parse);
  924|      0|    EncodeResult(calculated, negative, &result, &value);
  925|      0|    return result;
  926|  20.6k|  } else {
  927|  20.6k|    strings_internal::ParsedFloat decimal_parse =
  928|  20.6k|        strings_internal::ParseFloat<10>(first, last, fmt_flags);
  929|  20.6k|    if (decimal_parse.end == nullptr) {
  ------------------
  |  Branch (929:9): [True: 140, False: 20.4k]
  ------------------
  930|    140|      result.ec = std::errc::invalid_argument;
  931|    140|      return result;
  932|    140|    }
  933|  20.4k|    result.ptr = decimal_parse.end;
  934|  20.4k|    if (HandleEdgeCase(decimal_parse, negative, &value)) {
  ------------------
  |  Branch (934:9): [True: 3.03k, False: 17.4k]
  ------------------
  935|  3.03k|      return result;
  936|  3.03k|    }
  937|       |    // A nullptr subrange_begin means that the decimal_parse.mantissa is exact
  938|       |    // (not truncated), a precondition of the Eisel-Lemire algorithm.
  939|  17.4k|    if ((decimal_parse.subrange_begin == nullptr) &&
  ------------------
  |  Branch (939:9): [True: 8.44k, False: 9.01k]
  ------------------
  940|  8.44k|        EiselLemire<FloatType>(decimal_parse, negative, &value, &result.ec)) {
  ------------------
  |  Branch (940:9): [True: 4.99k, False: 3.45k]
  ------------------
  941|  4.99k|      return result;
  942|  4.99k|    }
  943|  12.4k|    CalculatedFloat calculated =
  944|  12.4k|        CalculateFromParsedDecimal<FloatType>(decimal_parse);
  945|  12.4k|    EncodeResult(calculated, negative, &result, &value);
  946|  12.4k|    return result;
  947|  17.4k|  }
  948|  20.6k|}
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_114HandleEdgeCaseIdEEbRKNS0_16strings_internal11ParsedFloatEbPT_:
  360|  25.5k|                    absl::Nonnull<FloatType*> value) {
  361|  25.5k|  if (input.type == strings_internal::FloatType::kNan) {
  ------------------
  |  Branch (361:7): [True: 665, False: 24.8k]
  ------------------
  362|       |    // A bug in both clang < 7 and gcc would cause the compiler to optimize
  363|       |    // away the buffer we are building below.  Declaring the buffer volatile
  364|       |    // avoids the issue, and has no measurable performance impact in
  365|       |    // microbenchmarks.
  366|       |    //
  367|       |    // https://bugs.llvm.org/show_bug.cgi?id=37778
  368|       |    // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=86113
  369|    665|    constexpr ptrdiff_t kNanBufferSize = 128;
  370|       |#if (defined(__GNUC__) && !defined(__clang__)) || \
  371|       |    (defined(__clang__) && __clang_major__ < 7)
  372|       |    volatile char n_char_sequence[kNanBufferSize];
  373|       |#else
  374|    665|    char n_char_sequence[kNanBufferSize];
  375|    665|#endif
  376|    665|    if (input.subrange_begin == nullptr) {
  ------------------
  |  Branch (376:9): [True: 665, False: 0]
  ------------------
  377|    665|      n_char_sequence[0] = '\0';
  378|    665|    } else {
  379|      0|      ptrdiff_t nan_size = input.subrange_end - input.subrange_begin;
  380|      0|      nan_size = std::min(nan_size, kNanBufferSize - 1);
  381|      0|      std::copy_n(input.subrange_begin, nan_size, n_char_sequence);
  382|      0|      n_char_sequence[nan_size] = '\0';
  383|      0|    }
  384|    665|    char* nan_argument = const_cast<char*>(n_char_sequence);
  385|    665|    *value = negative ? -FloatTraits<FloatType>::MakeNan(nan_argument)
  ------------------
  |  Branch (385:14): [True: 198, False: 467]
  ------------------
  386|    665|                      : FloatTraits<FloatType>::MakeNan(nan_argument);
  387|    665|    return true;
  388|    665|  }
  389|  24.8k|  if (input.type == strings_internal::FloatType::kInfinity) {
  ------------------
  |  Branch (389:7): [True: 456, False: 24.4k]
  ------------------
  390|    456|    *value = negative ? -std::numeric_limits<FloatType>::infinity()
  ------------------
  |  Branch (390:14): [True: 27, False: 429]
  ------------------
  391|    456|                      : std::numeric_limits<FloatType>::infinity();
  392|    456|    return true;
  393|    456|  }
  394|  24.4k|  if (input.mantissa == 0) {
  ------------------
  |  Branch (394:7): [True: 2.92k, False: 21.4k]
  ------------------
  395|  2.92k|    *value = negative ? -0.0 : 0.0;
  ------------------
  |  Branch (395:14): [True: 236, False: 2.68k]
  ------------------
  396|  2.92k|    return true;
  397|  2.92k|  }
  398|  21.4k|  return false;
  399|  24.4k|}
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_111FloatTraitsIdE7MakeNanEPKc:
  123|    665|  static double MakeNan(absl::Nonnull<const char*> tagp) {
  124|    665|#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|    665|    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|    665|  }
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_130CalculateFromParsedHexadecimalIdEENS1_15CalculatedFloatERKNS0_16strings_internal11ParsedFloatE:
  602|  4.02k|    const strings_internal::ParsedFloat& parsed_hex) {
  603|  4.02k|  uint64_t mantissa = parsed_hex.mantissa;
  604|  4.02k|  int exponent = parsed_hex.exponent;
  605|       |  // This static_cast is only needed when using a std::bit_width()
  606|       |  // implementation that does not have the fix for LWG 3656 applied.
  607|  4.02k|  int mantissa_width = static_cast<int>(bit_width(mantissa));
  608|  4.02k|  const int shift = NormalizedShiftSize<FloatType>(mantissa_width, exponent);
  609|  4.02k|  bool result_exact;
  610|  4.02k|  exponent += shift;
  611|  4.02k|  mantissa = ShiftRightAndRound(mantissa, shift,
  612|  4.02k|                                /* input exact= */ true, &result_exact);
  613|       |  // ParseFloat handles rounding in the hexadecimal case, so we don't have to
  614|       |  // check `result_exact` here.
  615|  4.02k|  return CalculatedFloatFromRawValues<FloatType>(mantissa, exponent);
  616|  4.02k|}
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_119NormalizedShiftSizeIdEEiii:
  335|  16.0k|int NormalizedShiftSize(int mantissa_width, int binary_exponent) {
  336|  16.0k|  const int normal_shift =
  337|  16.0k|      mantissa_width - FloatTraits<FloatType>::kTargetMantissaBits;
  338|  16.0k|  const int minimum_shift =
  339|  16.0k|      FloatTraits<FloatType>::kMinNormalExponent - binary_exponent;
  340|  16.0k|  return std::max(normal_shift, minimum_shift);
  341|  16.0k|}
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_118ShiftRightAndRoundENS0_7uint128EibPb:
  456|  16.0k|                            absl::Nonnull<bool*> output_exact) {
  457|  16.0k|  if (shift <= 0) {
  ------------------
  |  Branch (457:7): [True: 1.72k, False: 14.3k]
  ------------------
  458|  1.72k|    *output_exact = input_exact;
  459|  1.72k|    return static_cast<uint64_t>(value << -shift);
  460|  1.72k|  }
  461|  14.3k|  if (shift >= 128) {
  ------------------
  |  Branch (461:7): [True: 223, False: 14.0k]
  ------------------
  462|       |    // Exponent is so small that we are shifting away all significant bits.
  463|       |    // Answer will not be representable, even as a subnormal, so return a zero
  464|       |    // mantissa (which represents underflow).
  465|    223|    *output_exact = true;
  466|    223|    return 0;
  467|    223|  }
  468|       |
  469|  14.0k|  *output_exact = true;
  470|  14.0k|  const uint128 shift_mask = (uint128(1) << shift) - 1;
  471|  14.0k|  const uint128 halfway_point = uint128(1) << (shift - 1);
  472|       |
  473|  14.0k|  const uint128 shifted_bits = value & shift_mask;
  474|  14.0k|  value >>= shift;
  475|  14.0k|  if (shifted_bits > halfway_point) {
  ------------------
  |  Branch (475:7): [True: 1.49k, False: 12.5k]
  ------------------
  476|       |    // Shifted bits greater than 10000... require rounding up.
  477|  1.49k|    return static_cast<uint64_t>(value + 1);
  478|  1.49k|  }
  479|  12.5k|  if (shifted_bits == halfway_point) {
  ------------------
  |  Branch (479:7): [True: 1.53k, False: 11.0k]
  ------------------
  480|       |    // In exact mode, shifted bits of 10000... mean we're exactly halfway
  481|       |    // between two numbers, and we must round to even.  So only round up if
  482|       |    // the low bit of `value` is set.
  483|       |    //
  484|       |    // In inexact mode, the nonzero error means the actual value is greater
  485|       |    // than the halfway point and we must always round up.
  486|  1.53k|    if ((value & 1) == 1 || !input_exact) {
  ------------------
  |  Branch (486:9): [True: 424, False: 1.11k]
  |  Branch (486:29): [True: 228, False: 884]
  ------------------
  487|    652|      ++value;
  488|    652|    }
  489|  1.53k|    return static_cast<uint64_t>(value);
  490|  1.53k|  }
  491|  11.0k|  if (!input_exact && shifted_bits == halfway_point - 1) {
  ------------------
  |  Branch (491:7): [True: 10.2k, False: 811]
  |  Branch (491:23): [True: 9.39k, False: 856]
  ------------------
  492|       |    // Rounding direction is unclear, due to error.
  493|  9.39k|    *output_exact = false;
  494|  9.39k|  }
  495|       |  // Otherwise, round down.
  496|  11.0k|  return static_cast<uint64_t>(value);
  497|  12.5k|}
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_128CalculatedFloatFromRawValuesIdEENS1_15CalculatedFloatEmi:
  583|  16.0k|CalculatedFloat CalculatedFloatFromRawValues(uint64_t mantissa, int exponent) {
  584|  16.0k|  CalculatedFloat result;
  585|  16.0k|  if (mantissa == uint64_t{1} << FloatTraits<FloatType>::kTargetMantissaBits) {
  ------------------
  |  Branch (585:7): [True: 701, False: 15.3k]
  ------------------
  586|    701|    mantissa >>= 1;
  587|    701|    exponent += 1;
  588|    701|  }
  589|  16.0k|  if (exponent > FloatTraits<FloatType>::kMaxExponent) {
  ------------------
  |  Branch (589:7): [True: 1.93k, False: 14.1k]
  ------------------
  590|  1.93k|    result.exponent = kOverflow;
  591|  14.1k|  } else if (mantissa == 0) {
  ------------------
  |  Branch (591:14): [True: 743, False: 13.3k]
  ------------------
  592|    743|    result.exponent = kUnderflow;
  593|  13.3k|  } else {
  594|  13.3k|    result.exponent = exponent;
  595|  13.3k|    result.mantissa = mantissa;
  596|  13.3k|  }
  597|  16.0k|  return result;
  598|  16.0k|}
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_112EncodeResultIdEEvRKNS1_15CalculatedFloatEbPNS0_17from_chars_resultEPT_:
  410|  16.4k|                  absl::Nonnull<FloatType*> value) {
  411|  16.4k|  if (calculated.exponent == kOverflow) {
  ------------------
  |  Branch (411:7): [True: 2.16k, False: 14.3k]
  ------------------
  412|  2.16k|    result->ec = std::errc::result_out_of_range;
  413|  2.16k|    *value = negative ? -std::numeric_limits<FloatType>::max()
  ------------------
  |  Branch (413:14): [True: 142, False: 2.02k]
  ------------------
  414|  2.16k|                      : std::numeric_limits<FloatType>::max();
  415|  2.16k|    return;
  416|  14.3k|  } else if (calculated.mantissa == 0 || calculated.exponent == kUnderflow) {
  ------------------
  |  Branch (416:14): [True: 975, False: 13.3k]
  |  Branch (416:42): [True: 0, False: 13.3k]
  ------------------
  417|    975|    result->ec = std::errc::result_out_of_range;
  418|    975|    *value = negative ? -0.0 : 0.0;
  ------------------
  |  Branch (418:14): [True: 129, False: 846]
  ------------------
  419|    975|    return;
  420|    975|  }
  421|  13.3k|  *value = FloatTraits<FloatType>::Make(
  422|  13.3k|      static_cast<typename FloatTraits<FloatType>::mantissa_t>(
  423|  13.3k|          calculated.mantissa),
  424|  13.3k|      calculated.exponent, negative);
  425|  13.3k|}
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_111FloatTraitsIdE4MakeEmib:
  150|  13.3k|  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.3k|    constexpr uint64_t kMantissaMask =
  158|  13.3k|        (uint64_t{1} << (kTargetMantissaBits - 1)) - 1;
  159|  13.3k|    uint64_t dbl = static_cast<uint64_t>(sign) << 63;
  160|  13.3k|    if (mantissa > kMantissaMask) {
  ------------------
  |  Branch (160:9): [True: 12.6k, False: 742]
  ------------------
  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.6k|      dbl += static_cast<uint64_t>(exponent + 1023 + kTargetMantissaBits - 1)
  166|  12.6k|             << 52;
  167|  12.6k|      mantissa &= kMantissaMask;
  168|  12.6k|    } else {
  169|       |      // subnormal value
  170|       |      assert(exponent == kMinNormalExponent);
  171|    742|    }
  172|  13.3k|    dbl += mantissa;
  173|  13.3k|    return absl::bit_cast<double>(dbl);
  174|  13.3k|#endif  // ABSL_BIT_PACK_FLOATS
  175|  13.3k|  }
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_111EiselLemireIdEEbRKNS0_16strings_internal11ParsedFloatEbPT_PNSt3__14errcE:
  691|  8.44k|                 absl::Nonnull<std::errc*> ec) {
  692|  8.44k|  uint64_t man = input.mantissa;
  693|  8.44k|  int exp10 = input.exponent;
  694|  8.44k|  if (exp10 < FloatTraits<FloatType>::kEiselLemireMinInclusiveExp10) {
  ------------------
  |  Branch (694:7): [True: 324, False: 8.12k]
  ------------------
  695|    324|    *value = negative ? -0.0 : 0.0;
  ------------------
  |  Branch (695:14): [True: 6, False: 318]
  ------------------
  696|    324|    *ec = std::errc::result_out_of_range;
  697|    324|    return true;
  698|  8.12k|  } else if (exp10 >= FloatTraits<FloatType>::kEiselLemireMaxExclusiveExp10) {
  ------------------
  |  Branch (698:14): [True: 453, False: 7.67k]
  ------------------
  699|       |    // Return max (a finite value) consistent with from_chars and DR 3081. For
  700|       |    // SimpleAtod and SimpleAtof, post-processing will return infinity.
  701|    453|    *value = negative ? -std::numeric_limits<FloatType>::max()
  ------------------
  |  Branch (701:14): [True: 195, False: 258]
  ------------------
  702|    453|                      : std::numeric_limits<FloatType>::max();
  703|    453|    *ec = std::errc::result_out_of_range;
  704|    453|    return true;
  705|    453|  }
  706|       |
  707|       |  // Assert kPower10TableMinInclusive <= exp10 < kPower10TableMaxExclusive.
  708|       |  // Equivalently, !Power10Underflow(exp10) and !Power10Overflow(exp10).
  709|  7.67k|  static_assert(
  710|  7.67k|      FloatTraits<FloatType>::kEiselLemireMinInclusiveExp10 >=
  711|  7.67k|          kPower10TableMinInclusive,
  712|  7.67k|      "(exp10-kPower10TableMinInclusive) in kPower10MantissaHighTable bounds");
  713|  7.67k|  static_assert(
  714|  7.67k|      FloatTraits<FloatType>::kEiselLemireMaxExclusiveExp10 <=
  715|  7.67k|          kPower10TableMaxExclusive,
  716|  7.67k|      "(exp10-kPower10TableMinInclusive) in kPower10MantissaHighTable bounds");
  717|       |
  718|       |  // The terse (+) comments in this function body refer to sections of the
  719|       |  // https://nigeltao.github.io/blog/2020/eisel-lemire.html blog post.
  720|       |  //
  721|       |  // That blog post discusses double precision (11 exponent bits with a -1023
  722|       |  // bias, 52 mantissa bits), but the same approach applies to single precision
  723|       |  // (8 exponent bits with a -127 bias, 23 mantissa bits). Either way, the
  724|       |  // computation here happens with 64-bit values (e.g. man) or 128-bit values
  725|       |  // (e.g. x) before finally converting to 64- or 32-bit floating point.
  726|       |  //
  727|       |  // See also "Number Parsing at a Gigabyte per Second, Software: Practice and
  728|       |  // Experience 51 (8), 2021" (https://arxiv.org/abs/2101.11408) for detail.
  729|       |
  730|       |  // (+) Normalization.
  731|  7.67k|  int clz = countl_zero(man);
  732|  7.67k|  man <<= static_cast<unsigned int>(clz);
  733|       |  // The 217706 etc magic numbers are from the Power10Exponent function.
  734|  7.67k|  uint64_t ret_exp2 =
  735|  7.67k|      static_cast<uint64_t>((217706 * exp10 >> 16) + 64 +
  736|  7.67k|                            FloatTraits<FloatType>::kExponentBias - clz);
  737|       |
  738|       |  // (+) Multiplication.
  739|  7.67k|  uint128 x = static_cast<uint128>(man) *
  740|  7.67k|              static_cast<uint128>(
  741|  7.67k|                  kPower10MantissaHighTable[exp10 - kPower10TableMinInclusive]);
  742|       |
  743|       |  // (+) Wider Approximation.
  744|  7.67k|  static constexpr uint64_t high64_mask =
  745|  7.67k|      FloatTraits<FloatType>::kEiselLemireMask;
  746|  7.67k|  if (((Uint128High64(x) & high64_mask) == high64_mask) &&
  ------------------
  |  Branch (746:7): [True: 2.34k, False: 5.32k]
  ------------------
  747|  2.34k|      (man > (std::numeric_limits<uint64_t>::max() - Uint128Low64(x)))) {
  ------------------
  |  Branch (747:7): [True: 1.61k, False: 729]
  ------------------
  748|  1.61k|    uint128 y =
  749|  1.61k|        static_cast<uint128>(man) *
  750|  1.61k|        static_cast<uint128>(
  751|  1.61k|            kPower10MantissaLowTable[exp10 - kPower10TableMinInclusive]);
  752|  1.61k|    x += Uint128High64(y);
  753|       |    // For example, parsing "4503599627370497.5" will take the if-true
  754|       |    // branch here (for double precision), since:
  755|       |    //  - x   = 0x8000000000000BFF_FFFFFFFFFFFFFFFF
  756|       |    //  - y   = 0x8000000000000BFF_7FFFFFFFFFFFF400
  757|       |    //  - man = 0xA000000000000F00
  758|       |    // Likewise, when parsing "0.0625" for single precision:
  759|       |    //  - x   = 0x7FFFFFFFFFFFFFFF_FFFFFFFFFFFFFFFF
  760|       |    //  - y   = 0x813FFFFFFFFFFFFF_8A00000000000000
  761|       |    //  - man = 0x9C40000000000000
  762|  1.61k|    if (((Uint128High64(x) & high64_mask) == high64_mask) &&
  ------------------
  |  Branch (762:9): [True: 1.03k, False: 580]
  ------------------
  763|  1.03k|        ((Uint128Low64(x) + 1) == 0) &&
  ------------------
  |  Branch (763:9): [True: 723, False: 309]
  ------------------
  764|    723|        (man > (std::numeric_limits<uint64_t>::max() - Uint128Low64(y)))) {
  ------------------
  |  Branch (764:9): [True: 723, False: 0]
  ------------------
  765|    723|      return false;
  766|    723|    }
  767|  1.61k|  }
  768|       |
  769|       |  // (+) Shifting to 54 Bits (or for single precision, to 25 bits).
  770|  6.94k|  uint64_t msb = Uint128High64(x) >> 63;
  771|  6.94k|  uint64_t ret_man =
  772|  6.94k|      Uint128High64(x) >> (msb + FloatTraits<FloatType>::kEiselLemireShift);
  773|  6.94k|  ret_exp2 -= 1 ^ msb;
  774|       |
  775|       |  // (+) Half-way Ambiguity.
  776|       |  //
  777|       |  // For example, parsing "1e+23" will take the if-true branch here (for double
  778|       |  // precision), since:
  779|       |  //  - x       = 0x54B40B1F852BDA00_0000000000000000
  780|       |  //  - ret_man = 0x002A5A058FC295ED
  781|       |  // Likewise, when parsing "20040229.0" for single precision:
  782|       |  //  - x       = 0x4C72894000000000_0000000000000000
  783|       |  //  - ret_man = 0x000000000131CA25
  784|  6.94k|  if ((Uint128Low64(x) == 0) && ((Uint128High64(x) & high64_mask) == 0) &&
  ------------------
  |  Branch (784:7): [True: 4.47k, False: 2.47k]
  |  Branch (784:33): [True: 3.02k, False: 1.44k]
  ------------------
  785|  3.02k|      ((ret_man & 3) == 1)) {
  ------------------
  |  Branch (785:7): [True: 674, False: 2.34k]
  ------------------
  786|    674|    return false;
  787|    674|  }
  788|       |
  789|       |  // (+) From 54 to 53 Bits (or for single precision, from 25 to 24 bits).
  790|  6.27k|  ret_man += ret_man & 1;  // Line From54a.
  791|  6.27k|  ret_man >>= 1;           // Line From54b.
  792|       |  // Incrementing ret_man (at line From54a) may have overflowed 54 bits (53
  793|       |  // bits after the right shift by 1 at line From54b), so adjust for that.
  794|       |  //
  795|       |  // For example, parsing "9223372036854775807" will take the if-true branch
  796|       |  // here (for double precision), since:
  797|       |  //  - ret_man = 0x0020000000000000 = (1 << 53)
  798|       |  // Likewise, when parsing "2147483647.0" for single precision:
  799|       |  //  - ret_man = 0x0000000001000000 = (1 << 24)
  800|  6.27k|  if ((ret_man >> FloatTraits<FloatType>::kTargetMantissaBits) > 0) {
  ------------------
  |  Branch (800:7): [True: 202, False: 6.07k]
  ------------------
  801|    202|    ret_exp2 += 1;
  802|       |    // Conceptually, we need a "ret_man >>= 1" in this if-block to balance
  803|       |    // incrementing ret_exp2 in the line immediately above. However, we only
  804|       |    // get here when line From54a overflowed (after adding a 1), so ret_man
  805|       |    // here is (1 << 53). Its low 53 bits are therefore all zeroes. The only
  806|       |    // remaining use of ret_man is to mask it with ((1 << 52) - 1), so only its
  807|       |    // low 52 bits matter. A "ret_man >>= 1" would have no effect in practice.
  808|       |    //
  809|       |    // We omit the "ret_man >>= 1", even if it is cheap (and this if-branch is
  810|       |    // rarely taken) and technically 'more correct', so that mutation tests
  811|       |    // that would otherwise modify or omit that "ret_man >>= 1" don't complain
  812|       |    // that such code mutations have no observable effect.
  813|    202|  }
  814|       |
  815|       |  // ret_exp2 is a uint64_t. Zero or underflow means that we're in subnormal
  816|       |  // space. max_exp2 (0x7FF for double precision, 0xFF for single precision) or
  817|       |  // above means that we're in Inf/NaN space.
  818|       |  //
  819|       |  // The if block is equivalent to (but has fewer branches than):
  820|       |  //   if ((ret_exp2 <= 0) || (ret_exp2 >= max_exp2)) { etc }
  821|       |  //
  822|       |  // For example, parsing "4.9406564584124654e-324" will take the if-true
  823|       |  // branch here, since ret_exp2 = -51.
  824|  6.27k|  static constexpr uint64_t max_exp2 =
  825|  6.27k|      (1 << FloatTraits<FloatType>::kTargetExponentBits) - 1;
  826|  6.27k|  if ((ret_exp2 - 1) >= (max_exp2 - 1)) {
  ------------------
  |  Branch (826:7): [True: 2.06k, False: 4.21k]
  ------------------
  827|  2.06k|    return false;
  828|  2.06k|  }
  829|       |
  830|       |#ifndef ABSL_BIT_PACK_FLOATS
  831|       |  if (FloatTraits<FloatType>::kTargetBits == 64) {
  832|       |    *value = FloatTraits<FloatType>::Make(
  833|       |        (ret_man & 0x000FFFFFFFFFFFFFu) | 0x0010000000000000u,
  834|       |        static_cast<int>(ret_exp2) - 1023 - 52, negative);
  835|       |    return true;
  836|       |  } else if (FloatTraits<FloatType>::kTargetBits == 32) {
  837|       |    *value = FloatTraits<FloatType>::Make(
  838|       |        (static_cast<uint32_t>(ret_man) & 0x007FFFFFu) | 0x00800000u,
  839|       |        static_cast<int>(ret_exp2) - 127 - 23, negative);
  840|       |    return true;
  841|       |  }
  842|       |#else
  843|  4.21k|  if (FloatTraits<FloatType>::kTargetBits == 64) {
  ------------------
  |  Branch (843:7): [True: 4.21k, Folded]
  ------------------
  844|  4.21k|    uint64_t ret_bits = (ret_exp2 << 52) | (ret_man & 0x000FFFFFFFFFFFFFu);
  845|  4.21k|    if (negative) {
  ------------------
  |  Branch (845:9): [True: 435, False: 3.77k]
  ------------------
  846|    435|      ret_bits |= 0x8000000000000000u;
  847|    435|    }
  848|  4.21k|    *value = absl::bit_cast<double>(ret_bits);
  849|  4.21k|    return true;
  850|  4.21k|  } else if (FloatTraits<FloatType>::kTargetBits == 32) {
  ------------------
  |  Branch (850:14): [Folded, False: 0]
  ------------------
  851|      0|    uint32_t ret_bits = (static_cast<uint32_t>(ret_exp2) << 23) |
  852|      0|                        (static_cast<uint32_t>(ret_man) & 0x007FFFFFu);
  853|      0|    if (negative) {
  ------------------
  |  Branch (853:9): [True: 0, False: 0]
  ------------------
  854|      0|      ret_bits |= 0x80000000u;
  855|      0|    }
  856|      0|    *value = absl::bit_cast<float>(ret_bits);
  857|      0|    return true;
  858|      0|  }
  859|      0|#endif  // ABSL_BIT_PACK_FLOATS
  860|      0|  return false;
  861|  4.21k|}
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_126CalculateFromParsedDecimalIdEENS1_15CalculatedFloatERKNS0_16strings_internal11ParsedFloatE:
  620|  12.4k|    const strings_internal::ParsedFloat& parsed_decimal) {
  621|  12.4k|  CalculatedFloat result;
  622|       |
  623|       |  // Large or small enough decimal exponents will always result in overflow
  624|       |  // or underflow.
  625|  12.4k|  if (Power10Underflow(parsed_decimal.exponent)) {
  ------------------
  |  Branch (625:7): [True: 232, False: 12.2k]
  ------------------
  626|    232|    result.exponent = kUnderflow;
  627|    232|    return result;
  628|  12.2k|  } else if (Power10Overflow(parsed_decimal.exponent)) {
  ------------------
  |  Branch (628:14): [True: 232, False: 12.0k]
  ------------------
  629|    232|    result.exponent = kOverflow;
  630|    232|    return result;
  631|    232|  }
  632|       |
  633|       |  // Otherwise convert our power of 10 into a power of 2 times an integer
  634|       |  // mantissa, and multiply this by our parsed decimal mantissa.
  635|  12.0k|  uint128 wide_binary_mantissa = parsed_decimal.mantissa;
  636|  12.0k|  wide_binary_mantissa *= Power10Mantissa(parsed_decimal.exponent);
  637|  12.0k|  int binary_exponent = Power10Exponent(parsed_decimal.exponent);
  638|       |
  639|       |  // Discard bits that are inaccurate due to truncation error.  The magic
  640|       |  // `mantissa_width` constants below are justified in
  641|       |  // https://abseil.io/about/design/charconv. They represent the number of bits
  642|       |  // in `wide_binary_mantissa` that are guaranteed to be unaffected by error
  643|       |  // propagation.
  644|  12.0k|  bool mantissa_exact;
  645|  12.0k|  int mantissa_width;
  646|  12.0k|  if (parsed_decimal.subrange_begin) {
  ------------------
  |  Branch (646:7): [True: 8.54k, False: 3.45k]
  ------------------
  647|       |    // Truncated mantissa
  648|  8.54k|    mantissa_width = 58;
  649|  8.54k|    mantissa_exact = false;
  650|  8.54k|    binary_exponent +=
  651|  8.54k|        TruncateToBitWidth(mantissa_width, &wide_binary_mantissa);
  652|  8.54k|  } else if (!Power10Exact(parsed_decimal.exponent)) {
  ------------------
  |  Branch (652:14): [True: 2.78k, False: 674]
  ------------------
  653|       |    // Exact mantissa, truncated power of ten
  654|  2.78k|    mantissa_width = 63;
  655|  2.78k|    mantissa_exact = false;
  656|  2.78k|    binary_exponent +=
  657|  2.78k|        TruncateToBitWidth(mantissa_width, &wide_binary_mantissa);
  658|  2.78k|  } else {
  659|       |    // Product is exact
  660|    674|    mantissa_width = BitWidth(wide_binary_mantissa);
  661|    674|    mantissa_exact = true;
  662|    674|  }
  663|       |
  664|       |  // Shift into an FloatType-sized mantissa, and round to nearest.
  665|  12.0k|  const int shift =
  666|  12.0k|      NormalizedShiftSize<FloatType>(mantissa_width, binary_exponent);
  667|  12.0k|  bool result_exact;
  668|  12.0k|  binary_exponent += shift;
  669|  12.0k|  uint64_t binary_mantissa = ShiftRightAndRound(wide_binary_mantissa, shift,
  670|  12.0k|                                                mantissa_exact, &result_exact);
  671|  12.0k|  if (!result_exact) {
  ------------------
  |  Branch (671:7): [True: 9.39k, False: 2.61k]
  ------------------
  672|       |    // We could not determine the rounding direction using int128 math.  Use
  673|       |    // full resolution math instead.
  674|  9.39k|    if (MustRoundUp(binary_mantissa, binary_exponent, parsed_decimal)) {
  ------------------
  |  Branch (674:9): [True: 3.10k, False: 6.28k]
  ------------------
  675|  3.10k|      binary_mantissa += 1;
  676|  3.10k|    }
  677|  9.39k|  }
  678|       |
  679|  12.0k|  return CalculatedFloatFromRawValues<FloatType>(binary_mantissa,
  680|  12.0k|                                                 binary_exponent);
  681|  12.4k|}
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_116Power10UnderflowEi:
  288|  12.4k|bool Power10Underflow(int n) { return n < kPower10TableMinInclusive; }
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_115Power10OverflowEi:
  284|  12.2k|bool Power10Overflow(int n) { return n >= kPower10TableMaxExclusive; }
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_115Power10MantissaEi:
  270|  12.0k|uint64_t Power10Mantissa(int n) {
  271|  12.0k|  return kPower10MantissaHighTable[n - kPower10TableMinInclusive];
  272|  12.0k|}
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_115Power10ExponentEi:
  274|  12.0k|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.0k|  return (217706 * n >> 16) - 63;
  280|  12.0k|}
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_118TruncateToBitWidthEiPNS0_7uint128E:
  348|  11.3k|int TruncateToBitWidth(int bit_width, absl::Nonnull<uint128*> value) {
  349|  11.3k|  const int current_bit_width = BitWidth(*value);
  350|  11.3k|  const int shift = current_bit_width - bit_width;
  351|  11.3k|  *value >>= shift;
  352|  11.3k|  return shift;
  353|  11.3k|}
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_112Power10ExactEi:
  293|  3.45k|bool Power10Exact(int n) { return n >= 0 && n <= 27; }
  ------------------
  |  Branch (293:35): [True: 2.03k, False: 1.42k]
  |  Branch (293:45): [True: 674, False: 1.35k]
  ------------------
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_18BitWidthENS0_7uint128E:
  317|  12.0k|int BitWidth(uint128 value) {
  318|  12.0k|  if (Uint128High64(value) == 0) {
  ------------------
  |  Branch (318:7): [True: 854, False: 11.1k]
  ------------------
  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|    854|    return static_cast<int>(bit_width(Uint128Low64(value)));
  322|    854|  }
  323|  11.1k|  return 128 - countl_zero(Uint128High64(value));
  324|  12.0k|}
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_111MustRoundUpEmiRKNS0_16strings_internal11ParsedFloatE:
  513|  9.39k|                 const strings_internal::ParsedFloat& parsed_decimal) {
  514|       |  // 768 is the number of digits needed in the worst case.  We could determine a
  515|       |  // better limit dynamically based on the value of parsed_decimal.exponent.
  516|       |  // This would optimize pathological input cases only.  (Sane inputs won't have
  517|       |  // hundreds of digits of mantissa.)
  518|  9.39k|  absl::strings_internal::BigUnsigned<84> exact_mantissa;
  519|  9.39k|  int exact_exponent = exact_mantissa.ReadFloatMantissa(parsed_decimal, 768);
  520|       |
  521|       |  // Adjust the `guess` arguments to be halfway between A and B.
  522|  9.39k|  guess_mantissa = guess_mantissa * 2 + 1;
  523|  9.39k|  guess_exponent -= 1;
  524|       |
  525|       |  // In our comparison:
  526|       |  // lhs = exact = exact_mantissa * 10**exact_exponent
  527|       |  //             = exact_mantissa * 5**exact_exponent * 2**exact_exponent
  528|       |  // rhs = guess = guess_mantissa * 2**guess_exponent
  529|       |  //
  530|       |  // Because we are doing integer math, we can't directly deal with negative
  531|       |  // exponents.  We instead move these to the other side of the inequality.
  532|  9.39k|  absl::strings_internal::BigUnsigned<84>& lhs = exact_mantissa;
  533|  9.39k|  int comparison;
  534|  9.39k|  if (exact_exponent >= 0) {
  ------------------
  |  Branch (534:7): [True: 3.47k, False: 5.92k]
  ------------------
  535|  3.47k|    lhs.MultiplyByFiveToTheNth(exact_exponent);
  536|  3.47k|    absl::strings_internal::BigUnsigned<84> rhs(guess_mantissa);
  537|       |    // There are powers of 2 on both sides of the inequality; reduce this to
  538|       |    // a single bit-shift.
  539|  3.47k|    if (exact_exponent > guess_exponent) {
  ------------------
  |  Branch (539:9): [True: 0, False: 3.47k]
  ------------------
  540|      0|      lhs.ShiftLeft(exact_exponent - guess_exponent);
  541|  3.47k|    } else {
  542|  3.47k|      rhs.ShiftLeft(guess_exponent - exact_exponent);
  543|  3.47k|    }
  544|  3.47k|    comparison = Compare(lhs, rhs);
  545|  5.92k|  } else {
  546|       |    // Move the power of 5 to the other side of the equation, giving us:
  547|       |    // lhs = exact_mantissa * 2**exact_exponent
  548|       |    // rhs = guess_mantissa * 5**(-exact_exponent) * 2**guess_exponent
  549|  5.92k|    absl::strings_internal::BigUnsigned<84> rhs =
  550|  5.92k|        absl::strings_internal::BigUnsigned<84>::FiveToTheNth(-exact_exponent);
  551|  5.92k|    rhs.MultiplyBy(guess_mantissa);
  552|  5.92k|    if (exact_exponent > guess_exponent) {
  ------------------
  |  Branch (552:9): [True: 2.07k, False: 3.85k]
  ------------------
  553|  2.07k|      lhs.ShiftLeft(exact_exponent - guess_exponent);
  554|  3.85k|    } else {
  555|  3.85k|      rhs.ShiftLeft(guess_exponent - exact_exponent);
  556|  3.85k|    }
  557|  5.92k|    comparison = Compare(lhs, rhs);
  558|  5.92k|  }
  559|  9.39k|  if (comparison < 0) {
  ------------------
  |  Branch (559:7): [True: 5.78k, False: 3.61k]
  ------------------
  560|  5.78k|    return false;
  561|  5.78k|  } else if (comparison > 0) {
  ------------------
  |  Branch (561:14): [True: 2.75k, False: 851]
  ------------------
  562|  2.75k|    return true;
  563|  2.75k|  } else {
  564|       |    // When lhs == rhs, the decimal input is exactly between A and B.
  565|       |    // Round towards even -- round up only if the low bit of the initial
  566|       |    // `guess_mantissa` was a 1.  We shifted guess_mantissa left 1 bit at
  567|       |    // the beginning of this function, so test the 2nd bit here.
  568|    851|    return (guess_mantissa & 2) == 2;
  569|    851|  }
  570|  9.39k|}

_ZN4absl12lts_20240116anENS0_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_2024011619WebSafeBase64EscapeENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  914|      2|std::string WebSafeBase64Escape(absl::string_view src) {
  915|      2|  std::string dest;
  916|      2|  strings_internal::Base64EscapeInternal(
  917|      2|      reinterpret_cast<const unsigned char*>(src.data()), src.size(), &dest,
  918|      2|      false, strings_internal::kWebSafeBase64Chars);
  919|      2|  return dest;
  920|      2|}

_ZN4absl12lts_2024011616strings_internal11BigUnsignedILi84EE17ReadFloatMantissaERKNS1_11ParsedFloatEi:
  172|  9.39k|                                              int significant_digits) {
  173|  9.39k|  SetToZero();
  174|  9.39k|  assert(fp.type == FloatType::kNumber);
  175|       |
  176|  9.39k|  if (fp.subrange_begin == nullptr) {
  ------------------
  |  Branch (176:7): [True: 1.61k, False: 7.77k]
  ------------------
  177|       |    // We already exactly parsed the mantissa, so no more work is necessary.
  178|  1.61k|    words_[0] = fp.mantissa & 0xffffffffu;
  179|  1.61k|    words_[1] = fp.mantissa >> 32;
  180|  1.61k|    if (words_[1]) {
  ------------------
  |  Branch (180:9): [True: 449, False: 1.17k]
  ------------------
  181|    449|      size_ = 2;
  182|  1.17k|    } else if (words_[0]) {
  ------------------
  |  Branch (182:16): [True: 1.17k, False: 0]
  ------------------
  183|  1.17k|      size_ = 1;
  184|  1.17k|    }
  185|  1.61k|    return fp.exponent;
  186|  1.61k|  }
  187|  7.77k|  int exponent_adjust =
  188|  7.77k|      ReadDigits(fp.subrange_begin, fp.subrange_end, significant_digits);
  189|  7.77k|  return fp.literal_exponent + exponent_adjust;
  190|  9.39k|}
_ZN4absl12lts_2024011616strings_internal11BigUnsignedILi84EE12FiveToTheNthEi:
  289|  5.92k|    int n) {
  290|  5.92k|  BigUnsigned answer(1u);
  291|       |
  292|       |  // Seed from the table of large powers, if possible.
  293|  5.92k|  bool first_pass = true;
  294|  11.9k|  while (n >= kLargePowerOfFiveStep) {
  ------------------
  |  Branch (294:10): [True: 6.00k, False: 5.92k]
  ------------------
  295|  6.00k|    int big_power =
  296|  6.00k|        std::min(n / kLargePowerOfFiveStep, kLargestPowerOfFiveIndex);
  297|  6.00k|    if (first_pass) {
  ------------------
  |  Branch (297:9): [True: 3.61k, False: 2.38k]
  ------------------
  298|       |      // just copy, rather than multiplying by 1
  299|  3.61k|      std::copy_n(LargePowerOfFiveData(big_power),
  300|  3.61k|                  LargePowerOfFiveSize(big_power), answer.words_);
  301|  3.61k|      answer.size_ = LargePowerOfFiveSize(big_power);
  302|  3.61k|      first_pass = false;
  303|  3.61k|    } else {
  304|  2.38k|      answer.MultiplyBy(LargePowerOfFiveSize(big_power),
  305|  2.38k|                        LargePowerOfFiveData(big_power));
  306|  2.38k|    }
  307|  6.00k|    n -= kLargePowerOfFiveStep * big_power;
  308|  6.00k|  }
  309|  5.92k|  answer.MultiplyByFiveToTheNth(n);
  310|  5.92k|  return answer;
  311|  5.92k|}
_ZN4absl12lts_2024011616strings_internal11BigUnsignedILi84EE10ReadDigitsEPKcS5_i:
  194|  7.77k|                                       int significant_digits) {
  195|  7.77k|  assert(significant_digits <= Digits10() + 1);
  196|  7.77k|  SetToZero();
  197|       |
  198|  7.77k|  bool after_decimal_point = false;
  199|       |  // Discard any leading zeroes before the decimal point
  200|  8.23k|  while (begin < end && *begin == '0') {
  ------------------
  |  Branch (200:10): [True: 8.23k, False: 0]
  |  Branch (200:25): [True: 456, False: 7.77k]
  ------------------
  201|    456|    ++begin;
  202|    456|  }
  203|  7.77k|  int dropped_digits = 0;
  204|       |  // Discard any trailing zeroes.  These may or may not be after the decimal
  205|       |  // point.
  206|  1.89M|  while (begin < end && *std::prev(end) == '0') {
  ------------------
  |  Branch (206:10): [True: 1.89M, False: 0]
  |  Branch (206:25): [True: 1.88M, False: 7.77k]
  ------------------
  207|  1.88M|    --end;
  208|  1.88M|    ++dropped_digits;
  209|  1.88M|  }
  210|  7.77k|  if (begin < end && *std::prev(end) == '.') {
  ------------------
  |  Branch (210:7): [True: 7.77k, False: 0]
  |  Branch (210:22): [True: 328, False: 7.44k]
  ------------------
  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|    328|    dropped_digits = 0;
  214|    328|    --end;
  215|    723|    while (begin < end && *std::prev(end) == '0') {
  ------------------
  |  Branch (215:12): [True: 723, False: 0]
  |  Branch (215:27): [True: 395, False: 328]
  ------------------
  216|    395|      --end;
  217|    395|      ++dropped_digits;
  218|    395|    }
  219|  7.44k|  } else if (dropped_digits) {
  ------------------
  |  Branch (219:14): [True: 814, False: 6.63k]
  ------------------
  220|       |    // We dropped digits, and aren't sure if they're before or after the decimal
  221|       |    // point.  Figure that out now.
  222|    814|    const char* dp = std::find(begin, end, '.');
  223|    814|    if (dp != end) {
  ------------------
  |  Branch (223:9): [True: 550, False: 264]
  ------------------
  224|       |      // The dropped trailing digits were after the decimal point, so don't
  225|       |      // count them.
  226|    550|      dropped_digits = 0;
  227|    550|    }
  228|    814|  }
  229|       |  // Any non-fraction digits we dropped need to be accounted for in our exponent
  230|       |  // adjustment.
  231|  7.77k|  int exponent_adjust = dropped_digits;
  232|       |
  233|  7.77k|  uint32_t queued = 0;
  234|  7.77k|  int digits_queued = 0;
  235|  1.89M|  for (; begin != end && significant_digits > 0; ++begin) {
  ------------------
  |  Branch (235:10): [True: 1.88M, False: 6.70k]
  |  Branch (235:26): [True: 1.88M, False: 1.07k]
  ------------------
  236|  1.88M|    if (*begin == '.') {
  ------------------
  |  Branch (236:9): [True: 4.58k, False: 1.88M]
  ------------------
  237|  4.58k|      after_decimal_point = true;
  238|  4.58k|      continue;
  239|  4.58k|    }
  240|  1.88M|    if (after_decimal_point) {
  ------------------
  |  Branch (240:9): [True: 1.75M, False: 124k]
  ------------------
  241|       |      // For each fractional digit we emit in our parsed integer, adjust our
  242|       |      // decimal exponent to compensate.
  243|  1.75M|      --exponent_adjust;
  244|  1.75M|    }
  245|  1.88M|    char digit = (*begin - '0');
  246|  1.88M|    --significant_digits;
  247|  1.88M|    if (significant_digits == 0 && std::next(begin) != end &&
  ------------------
  |  Branch (247:9): [True: 1.28k, False: 1.87M]
  |  Branch (247:36): [True: 1.07k, False: 207]
  ------------------
  248|  1.07k|        (digit == 0 || digit == 5)) {
  ------------------
  |  Branch (248:10): [True: 511, False: 564]
  |  Branch (248:24): [True: 228, False: 336]
  ------------------
  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|  1.88M|    queued = 10 * queued + static_cast<uint32_t>(digit);
  259|  1.88M|    ++digits_queued;
  260|  1.88M|    if (digits_queued == kMaxSmallPowerOfTen) {
  ------------------
  |  Branch (260:9): [True: 206k, False: 1.67M]
  ------------------
  261|   206k|      MultiplyBy(kTenToNth[kMaxSmallPowerOfTen]);
  262|   206k|      AddWithCarry(0, queued);
  263|   206k|      queued = digits_queued = 0;
  264|   206k|    }
  265|  1.88M|  }
  266|       |  // Encode any remaining digits.
  267|  7.77k|  if (digits_queued) {
  ------------------
  |  Branch (267:7): [True: 6.95k, False: 824]
  ------------------
  268|  6.95k|    MultiplyBy(kTenToNth[digits_queued]);
  269|  6.95k|    AddWithCarry(0, queued);
  270|  6.95k|  }
  271|       |
  272|       |  // If any insignificant digits remain, we will drop them.  But if we have not
  273|       |  // yet read the decimal point, then we have to adjust the exponent to account
  274|       |  // for the dropped digits.
  275|  7.77k|  if (begin < end && !after_decimal_point) {
  ------------------
  |  Branch (275:7): [True: 1.07k, False: 6.70k]
  |  Branch (275:22): [True: 2, False: 1.07k]
  ------------------
  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 += (decimal_point - begin);
  283|      2|  }
  284|  7.77k|  return exponent_adjust;
  285|  7.77k|}
_ZN4absl12lts_2024011616strings_internal11BigUnsignedILi84EE12MultiplyStepEiPKjii:
  316|   269k|                                          int other_size, int step) {
  317|   269k|  int this_i = std::min(original_size - 1, step);
  318|   269k|  int other_i = step - this_i;
  319|       |
  320|   269k|  uint64_t this_word = 0;
  321|   269k|  uint64_t carry = 0;
  322|  1.68M|  for (; this_i >= 0 && other_i < other_size; --this_i, ++other_i) {
  ------------------
  |  Branch (322:10): [True: 1.64M, False: 40.1k]
  |  Branch (322:25): [True: 1.41M, False: 229k]
  ------------------
  323|  1.41M|    uint64_t product = words_[this_i];
  324|  1.41M|    product *= other_words[other_i];
  325|  1.41M|    this_word += product;
  326|  1.41M|    carry += (this_word >> 32);
  327|  1.41M|    this_word &= 0xffffffff;
  328|  1.41M|  }
  329|   269k|  AddWithCarry(step + 1, carry);
  330|   269k|  words_[step] = this_word & 0xffffffff;
  331|   269k|  if (this_word > 0 && size_ <= step) {
  ------------------
  |  Branch (331:7): [True: 269k, False: 0]
  |  Branch (331:24): [True: 3.76k, False: 265k]
  ------------------
  332|  3.76k|    size_ = step + 1;
  333|  3.76k|  }
  334|   269k|}
charconv_bigint.cc:_ZN4absl12lts_2024011616strings_internal12_GLOBAL__N_120LargePowerOfFiveDataEi:
  152|  6.00k|const uint32_t* LargePowerOfFiveData(int i) {
  153|  6.00k|  return kLargePowersOfFive + i * (i - 1);
  154|  6.00k|}
charconv_bigint.cc:_ZN4absl12lts_2024011616strings_internal12_GLOBAL__N_120LargePowerOfFiveSizeEi:
  158|  9.62k|int LargePowerOfFiveSize(int i) { return 2 * i; }

_ZN4absl12lts_2024011616strings_internal11BigUnsignedILi84EEC2Ev:
   62|  9.39k|  BigUnsigned() : size_(0), words_{} {}
_ZN4absl12lts_2024011616strings_internal11BigUnsignedILi84EE22MultiplyByFiveToTheNthEi:
  164|  9.39k|  void MultiplyByFiveToTheNth(int n) {
  165|  45.1k|    while (n >= kMaxSmallPowerOfFive) {
  ------------------
  |  Branch (165:12): [True: 35.7k, False: 9.39k]
  ------------------
  166|  35.7k|      MultiplyBy(kFiveToNth[kMaxSmallPowerOfFive]);
  167|  35.7k|      n -= kMaxSmallPowerOfFive;
  168|  35.7k|    }
  169|  9.39k|    if (n > 0) {
  ------------------
  |  Branch (169:9): [True: 7.64k, False: 1.75k]
  ------------------
  170|  7.64k|      MultiplyBy(kFiveToNth[n]);
  171|  7.64k|    }
  172|  9.39k|  }
_ZN4absl12lts_2024011616strings_internal11BigUnsignedILi84EE10MultiplyByEj:
  130|   256k|  void MultiplyBy(uint32_t v) {
  131|   256k|    if (size_ == 0 || v == 1) {
  ------------------
  |  Branch (131:9): [True: 7.77k, False: 249k]
  |  Branch (131:23): [True: 0, False: 249k]
  ------------------
  132|  7.77k|      return;
  133|  7.77k|    }
  134|   249k|    if (v == 0) {
  ------------------
  |  Branch (134:9): [True: 0, False: 249k]
  ------------------
  135|      0|      SetToZero();
  136|      0|      return;
  137|      0|    }
  138|   249k|    const uint64_t factor = v;
  139|   249k|    uint64_t window = 0;
  140|  8.08M|    for (int i = 0; i < size_; ++i) {
  ------------------
  |  Branch (140:21): [True: 7.83M, False: 249k]
  ------------------
  141|  7.83M|      window += factor * words_[i];
  142|  7.83M|      words_[i] = window & 0xffffffff;
  143|  7.83M|      window >>= 32;
  144|  7.83M|    }
  145|       |    // If carry bits remain and there's space for them, grow size_.
  146|   249k|    if (window && size_ < max_words) {
  ------------------
  |  Branch (146:9): [True: 227k, False: 21.2k]
  |  Branch (146:19): [True: 227k, False: 0]
  ------------------
  147|   227k|      words_[size_] = window & 0xffffffff;
  148|   227k|      ++size_;
  149|   227k|    }
  150|   249k|  }
_ZN4absl12lts_2024011616strings_internal11BigUnsignedILi84EE9SetToZeroEv:
  199|  17.1k|  void SetToZero() {
  200|  17.1k|    std::fill_n(words_, size_, 0u);
  201|  17.1k|    size_ = 0;
  202|  17.1k|  }
_ZN4absl12lts_2024011616strings_internal11BigUnsignedILi84EEC2Em:
   64|  9.39k|      : size_((v >> 32) ? 2 : v ? 1 : 0),
  ------------------
  |  Branch (64:15): [True: 3.47k, False: 5.92k]
  |  Branch (64:31): [True: 5.92k, False: 0]
  ------------------
   65|  9.39k|        words_{static_cast<uint32_t>(v & 0xffffffffu),
   66|  9.39k|               static_cast<uint32_t>(v >> 32)} {}
_ZN4absl12lts_2024011616strings_internal11BigUnsignedILi84EE9ShiftLeftEi:
  102|  9.39k|  void ShiftLeft(int count) {
  103|  9.39k|    if (count > 0) {
  ------------------
  |  Branch (103:9): [True: 9.14k, False: 247]
  ------------------
  104|  9.14k|      const int word_shift = count / 32;
  105|  9.14k|      if (word_shift >= max_words) {
  ------------------
  |  Branch (105:11): [True: 0, False: 9.14k]
  ------------------
  106|      0|        SetToZero();
  107|      0|        return;
  108|      0|      }
  109|  9.14k|      size_ = (std::min)(size_ + word_shift, max_words);
  110|  9.14k|      count %= 32;
  111|  9.14k|      if (count == 0) {
  ------------------
  |  Branch (111:11): [True: 953, False: 8.19k]
  ------------------
  112|    953|        std::copy_backward(words_, words_ + size_ - word_shift, words_ + size_);
  113|  8.19k|      } else {
  114|   140k|        for (int i = (std::min)(size_, max_words - 1); i > word_shift; --i) {
  ------------------
  |  Branch (114:56): [True: 131k, False: 8.19k]
  ------------------
  115|   131k|          words_[i] = (words_[i - word_shift] << count) |
  116|   131k|                      (words_[i - word_shift - 1] >> (32 - count));
  117|   131k|        }
  118|  8.19k|        words_[word_shift] = words_[0] << count;
  119|       |        // Grow size_ if necessary.
  120|  8.19k|        if (size_ < max_words && words_[size_]) {
  ------------------
  |  Branch (120:13): [True: 8.19k, False: 0]
  |  Branch (120:34): [True: 4.43k, False: 3.76k]
  ------------------
  121|  4.43k|          ++size_;
  122|  4.43k|        }
  123|  8.19k|      }
  124|  9.14k|      std::fill_n(words_, word_shift, 0u);
  125|  9.14k|    }
  126|  9.39k|  }
_ZN4absl12lts_2024011616strings_internal7CompareILi84ELi84EEEiRKNS1_11BigUnsignedIXT_EEERKNS3_IXT0_EEE:
  353|  9.39k|int Compare(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs) {
  354|  9.39k|  int limit = (std::max)(lhs.size(), rhs.size());
  355|  27.7k|  for (int i = limit - 1; i >= 0; --i) {
  ------------------
  |  Branch (355:27): [True: 26.8k, False: 851]
  ------------------
  356|  26.8k|    const uint32_t lhs_word = lhs.GetWord(i);
  357|  26.8k|    const uint32_t rhs_word = rhs.GetWord(i);
  358|  26.8k|    if (lhs_word < rhs_word) {
  ------------------
  |  Branch (358:9): [True: 5.78k, False: 21.0k]
  ------------------
  359|  5.78k|      return -1;
  360|  21.0k|    } else if (lhs_word > rhs_word) {
  ------------------
  |  Branch (360:16): [True: 2.75k, False: 18.3k]
  ------------------
  361|  2.75k|      return 1;
  362|  2.75k|    }
  363|  26.8k|  }
  364|    851|  return 0;
  365|  9.39k|}
_ZNK4absl12lts_2024011616strings_internal11BigUnsignedILi84EE4sizeEv:
  217|  18.7k|  int size() const { return size_; }
_ZNK4absl12lts_2024011616strings_internal11BigUnsignedILi84EE7GetWordEi:
  206|  53.7k|  uint32_t GetWord(int index) const {
  207|  53.7k|    if (index < 0 || index >= size_) {
  ------------------
  |  Branch (207:9): [True: 0, False: 53.7k]
  |  Branch (207:22): [True: 194, False: 53.5k]
  ------------------
  208|    194|      return 0;
  209|    194|    }
  210|  53.5k|    return words_[index];
  211|  53.7k|  }
_ZN4absl12lts_2024011616strings_internal11BigUnsignedILi84EE10MultiplyByEm:
  152|  5.92k|  void MultiplyBy(uint64_t v) {
  153|  5.92k|    uint32_t words[2];
  154|  5.92k|    words[0] = static_cast<uint32_t>(v);
  155|  5.92k|    words[1] = static_cast<uint32_t>(v >> 32);
  156|  5.92k|    if (words[1] == 0) {
  ------------------
  |  Branch (156:9): [True: 0, False: 5.92k]
  ------------------
  157|      0|      MultiplyBy(words[0]);
  158|  5.92k|    } else {
  159|  5.92k|      MultiplyBy(2, words);
  160|  5.92k|    }
  161|  5.92k|  }
_ZN4absl12lts_2024011616strings_internal11BigUnsignedILi84EE10MultiplyByEiPKj:
  270|  8.30k|  void MultiplyBy(int other_size, const uint32_t* other_words) {
  271|  8.30k|    const int original_size = size_;
  272|  8.30k|    const int first_step =
  273|  8.30k|        (std::min)(original_size + other_size - 2, max_words - 1);
  274|   277k|    for (int step = first_step; step >= 0; --step) {
  ------------------
  |  Branch (274:33): [True: 269k, False: 8.30k]
  ------------------
  275|   269k|      MultiplyStep(original_size, other_words, other_size, step);
  276|   269k|    }
  277|  8.30k|  }
_ZN4absl12lts_2024011616strings_internal11BigUnsignedILi84EE12AddWithCarryEij:
  280|   346k|  void AddWithCarry(int index, uint32_t value) {
  281|   346k|    if (value) {
  ------------------
  |  Branch (281:9): [True: 345k, False: 1.06k]
  ------------------
  282|   716k|      while (index < max_words && value > 0) {
  ------------------
  |  Branch (282:14): [True: 716k, False: 0]
  |  Branch (282:35): [True: 370k, False: 345k]
  ------------------
  283|   370k|        words_[index] += value;
  284|       |        // carry if we overflowed in this word:
  285|   370k|        if (value > words_[index]) {
  ------------------
  |  Branch (285:13): [True: 24.9k, False: 345k]
  ------------------
  286|  24.9k|          value = 1;
  287|  24.9k|          ++index;
  288|   345k|        } else {
  289|   345k|          value = 0;
  290|   345k|        }
  291|   370k|      }
  292|   345k|      size_ = (std::min)(max_words, (std::max)(index + 1, size_));
  293|   345k|    }
  294|   346k|  }
_ZN4absl12lts_2024011616strings_internal11BigUnsignedILi84EE12AddWithCarryEim:
  296|   269k|  void AddWithCarry(int index, uint64_t value) {
  297|   269k|    if (value && index < max_words) {
  ------------------
  |  Branch (297:9): [True: 265k, False: 4.23k]
  |  Branch (297:18): [True: 265k, False: 0]
  ------------------
  298|   265k|      uint32_t high = value >> 32;
  299|   265k|      uint32_t low = value & 0xffffffff;
  300|   265k|      words_[index] += low;
  301|   265k|      if (words_[index] < low) {
  ------------------
  |  Branch (301:11): [True: 91.9k, False: 173k]
  ------------------
  302|  91.9k|        ++high;
  303|  91.9k|        if (high == 0) {
  ------------------
  |  Branch (303:13): [True: 0, False: 91.9k]
  ------------------
  304|       |          // Carry from the low word caused our high word to overflow.
  305|       |          // Short circuit here to do the right thing.
  306|      0|          AddWithCarry(index + 2, static_cast<uint32_t>(1));
  307|      0|          return;
  308|      0|        }
  309|  91.9k|      }
  310|   265k|      if (high > 0) {
  ------------------
  |  Branch (310:11): [True: 133k, False: 132k]
  ------------------
  311|   133k|        AddWithCarry(index + 1, high);
  312|   133k|      } else {
  313|       |        // Normally 32-bit AddWithCarry() sets size_, but since we don't call
  314|       |        // it when `high` is 0, do it ourselves here.
  315|   132k|        size_ = (std::min)(max_words, (std::max)(index + 1, size_));
  316|   132k|      }
  317|   265k|    }
  318|   269k|  }

_ZN4absl12lts_2024011616strings_internal10ParseFloatILi10EEENS1_11ParsedFloatEPKcS5_NS0_12chars_formatE:
  356|  20.6k|                                         chars_format format_flags) {
  357|  20.6k|  strings_internal::ParsedFloat result;
  358|       |
  359|       |  // Exit early if we're given an empty range.
  360|  20.6k|  if (begin == end) return result;
  ------------------
  |  Branch (360:7): [True: 18, False: 20.6k]
  ------------------
  361|       |
  362|       |  // Handle the infinity and NaN cases.
  363|  20.6k|  if (ParseInfinityOrNan(begin, end, &result)) {
  ------------------
  |  Branch (363:7): [True: 1.12k, False: 19.4k]
  ------------------
  364|  1.12k|    return result;
  365|  1.12k|  }
  366|       |
  367|  19.4k|  const char* const mantissa_begin = begin;
  368|  21.4k|  while (begin < end && *begin == '0') {
  ------------------
  |  Branch (368:10): [True: 20.9k, False: 560]
  |  Branch (368:25): [True: 1.97k, False: 18.9k]
  ------------------
  369|  1.97k|    ++begin;  // skip leading zeros
  370|  1.97k|  }
  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.56k, False: 13.9k]
  ------------------
  383|       |    // We dropped some non-fraction digits on the floor.  Adjust our exponent
  384|       |    // to compensate.
  385|  5.56k|    exponent_adjustment =
  386|  5.56k|        static_cast<int>(pre_decimal_digits - MantissaDigitsMax<base>());
  387|  5.56k|    digits_left = 0;
  388|  13.9k|  } else {
  389|  13.9k|    digits_left =
  390|  13.9k|        static_cast<int>(MantissaDigitsMax<base>() - pre_decimal_digits);
  391|  13.9k|  }
  392|  19.4k|  if (begin < end && *begin == '.') {
  ------------------
  |  Branch (392:7): [True: 16.0k, False: 3.45k]
  |  Branch (392:22): [True: 8.29k, False: 7.75k]
  ------------------
  393|  8.29k|    ++begin;
  394|  8.29k|    if (mantissa == 0) {
  ------------------
  |  Branch (394:9): [True: 4.87k, False: 3.41k]
  ------------------
  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.87k|      const char* begin_zeros = begin;
  398|  5.75k|      while (begin < end && *begin == '0') {
  ------------------
  |  Branch (398:14): [True: 4.91k, False: 836]
  |  Branch (398:29): [True: 881, False: 4.03k]
  ------------------
  399|    881|        ++begin;
  400|    881|      }
  401|  4.87k|      int zeros_skipped = static_cast<int>(begin - begin_zeros);
  402|  4.87k|      if (zeros_skipped >= DigitLimit<base>()) {
  ------------------
  |  Branch (402:11): [True: 0, False: 4.87k]
  ------------------
  403|       |        // refuse to parse pathological inputs
  404|      0|        return result;
  405|      0|      }
  406|  4.87k|      exponent_adjustment -= static_cast<int>(zeros_skipped);
  407|  4.87k|    }
  408|  8.29k|    int post_decimal_digits = ConsumeDigits<base>(
  409|  8.29k|        begin, end, digits_left, &mantissa, &mantissa_is_inexact);
  410|  8.29k|    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.29k|    if (post_decimal_digits >= DigitLimit<base>()) {
  ------------------
  |  Branch (416:9): [True: 0, False: 8.29k]
  ------------------
  417|       |      // refuse to parse pathological inputs
  418|      0|      return result;
  419|  8.29k|    } else if (post_decimal_digits > digits_left) {
  ------------------
  |  Branch (419:16): [True: 4.91k, False: 3.37k]
  ------------------
  420|  4.91k|      exponent_adjustment -= digits_left;
  421|  4.91k|    } else {
  422|  3.37k|      exponent_adjustment -= post_decimal_digits;
  423|  3.37k|    }
  424|  8.29k|  }
  425|       |  // If we've found no mantissa whatsoever, this isn't a number.
  426|  19.4k|  if (mantissa_begin == begin) {
  ------------------
  |  Branch (426:7): [True: 93, False: 19.4k]
  ------------------
  427|     93|    return result;
  428|     93|  }
  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.23k, False: 14.1k]
  |  Branch (430:38): [True: 29, False: 5.20k]
  ------------------
  431|     29|    return result;
  432|     29|  }
  433|       |
  434|  19.3k|  if (mantissa_is_inexact) {
  ------------------
  |  Branch (434:7): [True: 9.01k, False: 10.3k]
  ------------------
  435|       |    // We dropped significant digits on the floor.  Handle this appropriately.
  436|  9.01k|    if (base == 10) {
  ------------------
  |  Branch (436:9): [True: 9.01k, 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.01k|      result.subrange_begin = mantissa_begin;
  440|  9.01k|      result.subrange_end = begin;
  441|  9.01k|    } 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.01k|  }
  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.51k, False: 10.8k]
  ------------------
  453|  8.51k|      IsExponentCharacter<base>(*begin)) {
  ------------------
  |  Branch (453:7): [True: 8.41k, False: 98]
  ------------------
  454|  8.41k|    bool negative_exponent = false;
  455|  8.41k|    ++begin;
  456|  8.41k|    if (begin < end && *begin == '-') {
  ------------------
  |  Branch (456:9): [True: 8.40k, False: 9]
  |  Branch (456:24): [True: 3.27k, False: 5.13k]
  ------------------
  457|  3.27k|      negative_exponent = true;
  458|  3.27k|      ++begin;
  459|  5.14k|    } else if (begin < end && *begin == '+') {
  ------------------
  |  Branch (459:16): [True: 5.13k, False: 9]
  |  Branch (459:31): [True: 338, False: 4.79k]
  ------------------
  460|    338|      ++begin;
  461|    338|    }
  462|  8.41k|    const char* const exponent_digits_begin = begin;
  463|       |    // Exponent is always expressed in decimal, even for hexadecimal floats.
  464|  8.41k|    begin += ConsumeDigits<10>(begin, end, kDecimalExponentDigitsMax,
  465|  8.41k|                               &result.literal_exponent, nullptr);
  466|  8.41k|    if (begin == exponent_digits_begin) {
  ------------------
  |  Branch (466:9): [True: 31, False: 8.38k]
  ------------------
  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|     31|      found_exponent = false;
  470|     31|      begin = exponent_begin;
  471|  8.38k|    } else {
  472|  8.38k|      found_exponent = true;
  473|  8.38k|      if (negative_exponent) {
  ------------------
  |  Branch (473:11): [True: 3.27k, False: 5.11k]
  ------------------
  474|  3.27k|        result.literal_exponent = -result.literal_exponent;
  475|  3.27k|      }
  476|  8.38k|    }
  477|  8.41k|  }
  478|       |
  479|  19.3k|  if (!found_exponent && RequireExponent(format_flags)) {
  ------------------
  |  Branch (479:7): [True: 10.9k, False: 8.38k]
  |  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.4k, False: 1.91k]
  ------------------
  488|  17.4k|    result.exponent = result.literal_exponent +
  489|  17.4k|                      (DigitMagnitude<base>() * exponent_adjustment);
  490|  17.4k|  } else {
  491|  1.91k|    result.exponent = 0;
  492|  1.91k|  }
  493|  19.3k|  result.end = begin;
  494|  19.3k|  return result;
  495|  19.3k|}
_ZN4absl12lts_2024011616strings_internal10ParseFloatILi16EEENS1_11ParsedFloatEPKcS5_NS0_12chars_formatE:
  356|  5.06k|                                         chars_format format_flags) {
  357|  5.06k|  strings_internal::ParsedFloat result;
  358|       |
  359|       |  // Exit early if we're given an empty range.
  360|  5.06k|  if (begin == end) return result;
  ------------------
  |  Branch (360:7): [True: 3, False: 5.06k]
  ------------------
  361|       |
  362|       |  // Handle the infinity and NaN cases.
  363|  5.06k|  if (ParseInfinityOrNan(begin, end, &result)) {
  ------------------
  |  Branch (363:7): [True: 2, False: 5.05k]
  ------------------
  364|      2|    return result;
  365|      2|  }
  366|       |
  367|  5.05k|  const char* const mantissa_begin = begin;
  368|  5.86k|  while (begin < end && *begin == '0') {
  ------------------
  |  Branch (368:10): [True: 5.62k, False: 246]
  |  Branch (368:25): [True: 808, False: 4.81k]
  ------------------
  369|    808|    ++begin;  // skip leading zeros
  370|    808|  }
  371|  5.05k|  uint64_t mantissa = 0;
  372|       |
  373|  5.05k|  int exponent_adjustment = 0;
  374|  5.05k|  bool mantissa_is_inexact = false;
  375|  5.05k|  int pre_decimal_digits = ConsumeDigits<base>(
  376|  5.05k|      begin, end, MantissaDigitsMax<base>(), &mantissa, &mantissa_is_inexact);
  377|  5.05k|  begin += pre_decimal_digits;
  378|  5.05k|  int digits_left;
  379|  5.05k|  if (pre_decimal_digits >= DigitLimit<base>()) {
  ------------------
  |  Branch (379:7): [True: 0, False: 5.05k]
  ------------------
  380|       |    // refuse to parse pathological inputs
  381|      0|    return result;
  382|  5.05k|  } else if (pre_decimal_digits > MantissaDigitsMax<base>()) {
  ------------------
  |  Branch (382:14): [True: 730, False: 4.32k]
  ------------------
  383|       |    // We dropped some non-fraction digits on the floor.  Adjust our exponent
  384|       |    // to compensate.
  385|    730|    exponent_adjustment =
  386|    730|        static_cast<int>(pre_decimal_digits - MantissaDigitsMax<base>());
  387|    730|    digits_left = 0;
  388|  4.32k|  } else {
  389|  4.32k|    digits_left =
  390|  4.32k|        static_cast<int>(MantissaDigitsMax<base>() - pre_decimal_digits);
  391|  4.32k|  }
  392|  5.05k|  if (begin < end && *begin == '.') {
  ------------------
  |  Branch (392:7): [True: 3.18k, False: 1.87k]
  |  Branch (392:22): [True: 1.83k, False: 1.34k]
  ------------------
  393|  1.83k|    ++begin;
  394|  1.83k|    if (mantissa == 0) {
  ------------------
  |  Branch (394:9): [True: 1.19k, False: 643]
  ------------------
  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.19k|      const char* begin_zeros = begin;
  398|  1.81k|      while (begin < end && *begin == '0') {
  ------------------
  |  Branch (398:14): [True: 1.37k, False: 436]
  |  Branch (398:29): [True: 615, False: 759]
  ------------------
  399|    615|        ++begin;
  400|    615|      }
  401|  1.19k|      int zeros_skipped = static_cast<int>(begin - begin_zeros);
  402|  1.19k|      if (zeros_skipped >= DigitLimit<base>()) {
  ------------------
  |  Branch (402:11): [True: 0, False: 1.19k]
  ------------------
  403|       |        // refuse to parse pathological inputs
  404|      0|        return result;
  405|      0|      }
  406|  1.19k|      exponent_adjustment -= static_cast<int>(zeros_skipped);
  407|  1.19k|    }
  408|  1.83k|    int post_decimal_digits = ConsumeDigits<base>(
  409|  1.83k|        begin, end, digits_left, &mantissa, &mantissa_is_inexact);
  410|  1.83k|    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.83k|    if (post_decimal_digits >= DigitLimit<base>()) {
  ------------------
  |  Branch (416:9): [True: 0, False: 1.83k]
  ------------------
  417|       |      // refuse to parse pathological inputs
  418|      0|      return result;
  419|  1.83k|    } else if (post_decimal_digits > digits_left) {
  ------------------
  |  Branch (419:16): [True: 579, False: 1.25k]
  ------------------
  420|    579|      exponent_adjustment -= digits_left;
  421|  1.25k|    } else {
  422|  1.25k|      exponent_adjustment -= post_decimal_digits;
  423|  1.25k|    }
  424|  1.83k|  }
  425|       |  // If we've found no mantissa whatsoever, this isn't a number.
  426|  5.05k|  if (mantissa_begin == begin) {
  ------------------
  |  Branch (426:7): [True: 9, False: 5.04k]
  ------------------
  427|      9|    return result;
  428|      9|  }
  429|       |  // A bare "." doesn't count as a mantissa either.
  430|  5.04k|  if (begin - mantissa_begin == 1 && *mantissa_begin == '.') {
  ------------------
  |  Branch (430:7): [True: 1.81k, False: 3.23k]
  |  Branch (430:38): [True: 15, False: 1.80k]
  ------------------
  431|     15|    return result;
  432|     15|  }
  433|       |
  434|  5.03k|  if (mantissa_is_inexact) {
  ------------------
  |  Branch (434:7): [True: 1.00k, False: 4.02k]
  ------------------
  435|       |    // We dropped significant digits on the floor.  Handle this appropriately.
  436|  1.00k|    if (base == 10) {
  ------------------
  |  Branch (436:9): [Folded, False: 1.00k]
  ------------------
  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|  1.00k|    } else if (base == 16) {
  ------------------
  |  Branch (441:16): [True: 1.00k, 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|  1.00k|      mantissa |= 1;
  445|  1.00k|    }
  446|  1.00k|  }
  447|  5.03k|  result.mantissa = mantissa;
  448|       |
  449|  5.03k|  const char* const exponent_begin = begin;
  450|  5.03k|  result.literal_exponent = 0;
  451|  5.03k|  bool found_exponent = false;
  452|  5.03k|  if (AllowExponent(format_flags) && begin < end &&
  ------------------
  |  Branch (452:7): [True: 5.03k, False: 0]
  |  Branch (452:38): [True: 1.71k, False: 3.32k]
  ------------------
  453|  1.71k|      IsExponentCharacter<base>(*begin)) {
  ------------------
  |  Branch (453:7): [True: 1.67k, False: 35]
  ------------------
  454|  1.67k|    bool negative_exponent = false;
  455|  1.67k|    ++begin;
  456|  1.67k|    if (begin < end && *begin == '-') {
  ------------------
  |  Branch (456:9): [True: 1.66k, False: 10]
  |  Branch (456:24): [True: 843, False: 823]
  ------------------
  457|    843|      negative_exponent = true;
  458|    843|      ++begin;
  459|    843|    } else if (begin < end && *begin == '+') {
  ------------------
  |  Branch (459:16): [True: 823, False: 10]
  |  Branch (459:31): [True: 258, False: 565]
  ------------------
  460|    258|      ++begin;
  461|    258|    }
  462|  1.67k|    const char* const exponent_digits_begin = begin;
  463|       |    // Exponent is always expressed in decimal, even for hexadecimal floats.
  464|  1.67k|    begin += ConsumeDigits<10>(begin, end, kDecimalExponentDigitsMax,
  465|  1.67k|                               &result.literal_exponent, nullptr);
  466|  1.67k|    if (begin == exponent_digits_begin) {
  ------------------
  |  Branch (466:9): [True: 25, False: 1.65k]
  ------------------
  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|     25|      found_exponent = false;
  470|     25|      begin = exponent_begin;
  471|  1.65k|    } else {
  472|  1.65k|      found_exponent = true;
  473|  1.65k|      if (negative_exponent) {
  ------------------
  |  Branch (473:11): [True: 842, False: 809]
  ------------------
  474|    842|        result.literal_exponent = -result.literal_exponent;
  475|    842|      }
  476|  1.65k|    }
  477|  1.67k|  }
  478|       |
  479|  5.03k|  if (!found_exponent && RequireExponent(format_flags)) {
  ------------------
  |  Branch (479:7): [True: 3.38k, False: 1.65k]
  |  Branch (479:26): [True: 0, False: 3.38k]
  ------------------
  480|       |    // Provided flags required an exponent, but none was found.  This results
  481|       |    // in a failure to scan.
  482|      0|    return result;
  483|      0|  }
  484|       |
  485|       |  // Success!
  486|  5.03k|  result.type = strings_internal::FloatType::kNumber;
  487|  5.03k|  if (result.mantissa > 0) {
  ------------------
  |  Branch (487:7): [True: 4.02k, False: 1.00k]
  ------------------
  488|  4.02k|    result.exponent = result.literal_exponent +
  489|  4.02k|                      (DigitMagnitude<base>() * exponent_adjustment);
  490|  4.02k|  } else {
  491|  1.00k|    result.exponent = 0;
  492|  1.00k|  }
  493|  5.03k|  result.end = begin;
  494|  5.03k|  return result;
  495|  5.03k|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_113AllowExponentENS0_12chars_formatE:
  122|  24.4k|bool AllowExponent(chars_format flags) {
  123|  24.4k|  bool fixed = (flags & chars_format::fixed) == chars_format::fixed;
  124|  24.4k|  bool scientific =
  125|  24.4k|      (flags & chars_format::scientific) == chars_format::scientific;
  126|  24.4k|  return scientific || !fixed;
  ------------------
  |  Branch (126:10): [True: 24.4k, False: 0]
  |  Branch (126:24): [True: 0, False: 0]
  ------------------
  127|  24.4k|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_115RequireExponentENS0_12chars_formatE:
  130|  14.3k|bool RequireExponent(chars_format flags) {
  131|  14.3k|  bool fixed = (flags & chars_format::fixed) == chars_format::fixed;
  132|  14.3k|  bool scientific =
  133|  14.3k|      (flags & chars_format::scientific) == chars_format::scientific;
  134|  14.3k|  return scientific && !fixed;
  ------------------
  |  Branch (134:10): [True: 14.3k, False: 0]
  |  Branch (134:24): [True: 0, False: 14.3k]
  ------------------
  135|  14.3k|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_119IsExponentCharacterILi10EEEbc:
  201|  8.51k|bool IsExponentCharacter<10>(char ch) {
  202|  8.51k|  return ch == 'e' || ch == 'E';
  ------------------
  |  Branch (202:10): [True: 6.45k, False: 2.06k]
  |  Branch (202:23): [True: 1.96k, False: 98]
  ------------------
  203|  8.51k|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_119IsExponentCharacterILi16EEEbc:
  206|  1.71k|bool IsExponentCharacter<16>(char ch) {
  207|  1.71k|  return ch == 'p' || ch == 'P';
  ------------------
  |  Branch (207:10): [True: 886, False: 825]
  |  Branch (207:23): [True: 790, False: 35]
  ------------------
  208|  1.71k|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_117MantissaDigitsMaxILi10EEEiv:
  211|  58.4k|constexpr int MantissaDigitsMax<10>() {
  212|  58.4k|  return kDecimalMantissaDigitsMax;
  213|  58.4k|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_117MantissaDigitsMaxILi16EEEiv:
  215|  15.1k|constexpr int MantissaDigitsMax<16>() {
  216|  15.1k|  return kHexadecimalMantissaDigitsMax;
  217|  15.1k|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_110DigitLimitILi10EEEiv:
  220|  32.6k|constexpr int DigitLimit<10>() {
  221|  32.6k|  return kDecimalDigitLimit;
  222|  32.6k|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_110DigitLimitILi16EEEiv:
  224|  8.09k|constexpr int DigitLimit<16>() {
  225|  8.09k|  return kHexadecimalDigitLimit;
  226|  8.09k|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_114DigitMagnitudeILi10EEEiv:
  229|  17.4k|constexpr int DigitMagnitude<10>() {
  230|  17.4k|  return 1;
  231|  17.4k|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_114DigitMagnitudeILi16EEEiv:
  233|  4.02k|constexpr int DigitMagnitude<16>() {
  234|  4.02k|  return 4;
  235|  4.02k|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_118ParseInfinityOrNanEPKcS3_PNS0_16strings_internal11ParsedFloatE:
  298|  25.6k|                        strings_internal::ParsedFloat* out) {
  299|  25.6k|  if (end - begin < 3) {
  ------------------
  |  Branch (299:7): [True: 4.55k, False: 21.1k]
  ------------------
  300|  4.55k|    return false;
  301|  4.55k|  }
  302|  21.1k|  switch (*begin) {
  303|    278|    case 'i':
  ------------------
  |  Branch (303:5): [True: 278, False: 20.8k]
  ------------------
  304|    475|    case 'I': {
  ------------------
  |  Branch (304:5): [True: 197, False: 20.9k]
  ------------------
  305|       |      // An infinity string consists of the characters "inf" or "infinity",
  306|       |      // case insensitive.
  307|    475|      if (strings_internal::memcasecmp(begin + 1, "nf", 2) != 0) {
  ------------------
  |  Branch (307:11): [True: 19, False: 456]
  ------------------
  308|     19|        return false;
  309|     19|      }
  310|    456|      out->type = strings_internal::FloatType::kInfinity;
  311|    456|      if (end - begin >= 8 &&
  ------------------
  |  Branch (311:11): [True: 44, False: 412]
  ------------------
  312|     44|          strings_internal::memcasecmp(begin + 3, "inity", 5) == 0) {
  ------------------
  |  Branch (312:11): [True: 1, False: 43]
  ------------------
  313|      1|        out->end = begin + 8;
  314|    455|      } else {
  315|    455|        out->end = begin + 3;
  316|    455|      }
  317|    456|      return true;
  318|    475|    }
  319|    261|    case 'n':
  ------------------
  |  Branch (319:5): [True: 261, False: 20.8k]
  ------------------
  320|    685|    case 'N': {
  ------------------
  |  Branch (320:5): [True: 424, False: 20.6k]
  ------------------
  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|    685|      if (strings_internal::memcasecmp(begin + 1, "an", 2) != 0) {
  ------------------
  |  Branch (324:11): [True: 18, False: 667]
  ------------------
  325|     18|        return false;
  326|     18|      }
  327|    667|      out->type = strings_internal::FloatType::kNan;
  328|    667|      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|    667|      begin += 3;
  332|    667|      if (begin < end && *begin == '(') {
  ------------------
  |  Branch (332:11): [True: 2, False: 665]
  |  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|    667|      return true;
  345|    685|    }
  346|  19.9k|    default:
  ------------------
  |  Branch (346:5): [True: 19.9k, False: 1.16k]
  ------------------
  347|  19.9k|      return false;
  348|  21.1k|  }
  349|  21.1k|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_113ConsumeDigitsILi10EmEEiPKcS4_iPT0_Pb:
  250|  27.7k|                  bool* dropped_nonzero_digit) {
  251|  27.7k|  if (base == 10) {
  ------------------
  |  Branch (251:7): [True: 27.7k, Folded]
  ------------------
  252|  27.7k|    assert(max_digits <= std::numeric_limits<T>::digits10);
  253|  27.7k|  } else if (base == 16) {
  ------------------
  |  Branch (253:14): [Folded, False: 0]
  ------------------
  254|      0|    assert(max_digits * 4 <= std::numeric_limits<T>::digits);
  255|      0|  }
  256|  27.7k|  const char* const original_begin = begin;
  257|       |
  258|       |  // Skip leading zeros, but only if *out is zero.
  259|       |  // They don't cause an overflow so we don't have to count them for
  260|       |  // `max_digits`.
  261|  27.7k|  while (!*out && end != begin && *begin == '0') ++begin;
  ------------------
  |  Branch (261:10): [True: 24.3k, False: 3.41k]
  |  Branch (261:19): [True: 22.9k, False: 1.39k]
  |  Branch (261:35): [True: 0, False: 22.9k]
  ------------------
  262|       |
  263|  27.7k|  T accumulator = *out;
  264|  27.7k|  const char* significant_digits_end =
  265|  27.7k|      (end - begin > max_digits) ? begin + max_digits : end;
  ------------------
  |  Branch (265:7): [True: 14.3k, False: 13.4k]
  ------------------
  266|   235k|  while (begin < significant_digits_end && IsDigit<base>(*begin)) {
  ------------------
  |  Branch (266:10): [True: 219k, False: 15.6k]
  |  Branch (266:44): [True: 207k, False: 12.1k]
  ------------------
  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|   207k|    auto digit = static_cast<T>(ToDigit<base>(*begin));
  270|   207k|    assert(accumulator * base >= accumulator);
  271|   207k|    accumulator *= base;
  272|   207k|    assert(accumulator + digit >= accumulator);
  273|   207k|    accumulator += digit;
  274|   207k|    ++begin;
  275|   207k|  }
  276|  27.7k|  bool dropped_nonzero = false;
  277|  10.6M|  while (begin < end && IsDigit<base>(*begin)) {
  ------------------
  |  Branch (277:10): [True: 10.6M, False: 10.8k]
  |  Branch (277:25): [True: 10.6M, False: 16.9k]
  ------------------
  278|  10.6M|    dropped_nonzero = dropped_nonzero || (*begin != '0');
  ------------------
  |  Branch (278:23): [True: 10.6M, False: 16.0k]
  |  Branch (278:42): [True: 10.4k, False: 5.56k]
  ------------------
  279|  10.6M|    ++begin;
  280|  10.6M|  }
  281|  27.7k|  if (dropped_nonzero && dropped_nonzero_digit != nullptr) {
  ------------------
  |  Branch (281:7): [True: 10.4k, False: 17.3k]
  |  Branch (281:26): [True: 10.4k, False: 0]
  ------------------
  282|  10.4k|    *dropped_nonzero_digit = true;
  283|  10.4k|  }
  284|  27.7k|  *out = accumulator;
  285|  27.7k|  return static_cast<int>(begin - original_begin);
  286|  27.7k|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_17IsDigitILi10EEEbc:
  183|  20.3M|bool IsDigit<10>(char ch) {
  184|  20.3M|  return ch >= '0' && ch <= '9';
  ------------------
  |  Branch (184:10): [True: 20.3M, False: 14.9k]
  |  Branch (184:23): [True: 20.3M, False: 14.2k]
  ------------------
  185|  20.3M|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_17ToDigitILi10EEEjc:
  192|   233k|unsigned ToDigit<10>(char ch) {
  193|   233k|  return static_cast<unsigned>(ch - '0');
  194|   233k|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_113ConsumeDigitsILi10EiEEiPKcS4_iPT0_Pb:
  250|  10.0k|                  bool* dropped_nonzero_digit) {
  251|  10.0k|  if (base == 10) {
  ------------------
  |  Branch (251:7): [True: 10.0k, Folded]
  ------------------
  252|  10.0k|    assert(max_digits <= std::numeric_limits<T>::digits10);
  253|  10.0k|  } 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.0k|  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|  11.0k|  while (!*out && end != begin && *begin == '0') ++begin;
  ------------------
  |  Branch (261:10): [True: 11.0k, False: 0]
  |  Branch (261:19): [True: 10.2k, False: 754]
  |  Branch (261:35): [True: 920, False: 9.34k]
  ------------------
  262|       |
  263|  10.0k|  T accumulator = *out;
  264|  10.0k|  const char* significant_digits_end =
  265|  10.0k|      (end - begin > max_digits) ? begin + max_digits : end;
  ------------------
  |  Branch (265:7): [True: 402, False: 9.69k]
  ------------------
  266|  36.4k|  while (begin < significant_digits_end && IsDigit<base>(*begin)) {
  ------------------
  |  Branch (266:10): [True: 26.3k, False: 10.0k]
  |  Branch (266:44): [True: 26.3k, False: 57]
  ------------------
  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.3k|    auto digit = static_cast<T>(ToDigit<base>(*begin));
  270|  26.3k|    assert(accumulator * base >= accumulator);
  271|  26.3k|    accumulator *= base;
  272|  26.3k|    assert(accumulator + digit >= accumulator);
  273|  26.3k|    accumulator += digit;
  274|  26.3k|    ++begin;
  275|  26.3k|  }
  276|  10.0k|  bool dropped_nonzero = false;
  277|  9.45M|  while (begin < end && IsDigit<base>(*begin)) {
  ------------------
  |  Branch (277:10): [True: 9.44M, False: 10.0k]
  |  Branch (277:25): [True: 9.44M, False: 65]
  ------------------
  278|  9.44M|    dropped_nonzero = dropped_nonzero || (*begin != '0');
  ------------------
  |  Branch (278:23): [True: 9.44M, False: 402]
  |  Branch (278:42): [True: 378, False: 24]
  ------------------
  279|  9.44M|    ++begin;
  280|  9.44M|  }
  281|  10.0k|  if (dropped_nonzero && dropped_nonzero_digit != nullptr) {
  ------------------
  |  Branch (281:7): [True: 378, False: 9.71k]
  |  Branch (281:26): [True: 0, False: 378]
  ------------------
  282|      0|    *dropped_nonzero_digit = true;
  283|      0|  }
  284|  10.0k|  *out = accumulator;
  285|  10.0k|  return static_cast<int>(begin - original_begin);
  286|  10.0k|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_113ConsumeDigitsILi16EmEEiPKcS4_iPT0_Pb:
  250|  6.89k|                  bool* dropped_nonzero_digit) {
  251|  6.89k|  if (base == 10) {
  ------------------
  |  Branch (251:7): [Folded, False: 6.89k]
  ------------------
  252|      0|    assert(max_digits <= std::numeric_limits<T>::digits10);
  253|  6.89k|  } else if (base == 16) {
  ------------------
  |  Branch (253:14): [True: 6.89k, Folded]
  ------------------
  254|  6.89k|    assert(max_digits * 4 <= std::numeric_limits<T>::digits);
  255|  6.89k|  }
  256|  6.89k|  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.89k|  while (!*out && end != begin && *begin == '0') ++begin;
  ------------------
  |  Branch (261:10): [True: 6.25k, False: 643]
  |  Branch (261:19): [True: 5.57k, False: 682]
  |  Branch (261:35): [True: 0, False: 5.57k]
  ------------------
  262|       |
  263|  6.89k|  T accumulator = *out;
  264|  6.89k|  const char* significant_digits_end =
  265|  6.89k|      (end - begin > max_digits) ? begin + max_digits : end;
  ------------------
  |  Branch (265:7): [True: 1.77k, False: 5.11k]
  ------------------
  266|  36.7k|  while (begin < significant_digits_end && IsDigit<base>(*begin)) {
  ------------------
  |  Branch (266:10): [True: 32.8k, False: 3.83k]
  |  Branch (266:44): [True: 29.8k, False: 3.05k]
  ------------------
  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|  29.8k|    auto digit = static_cast<T>(ToDigit<base>(*begin));
  270|  29.8k|    assert(accumulator * base >= accumulator);
  271|  29.8k|    accumulator *= base;
  272|  29.8k|    assert(accumulator + digit >= accumulator);
  273|  29.8k|    accumulator += digit;
  274|  29.8k|    ++begin;
  275|  29.8k|  }
  276|  6.89k|  bool dropped_nonzero = false;
  277|  15.4M|  while (begin < end && IsDigit<base>(*begin)) {
  ------------------
  |  Branch (277:10): [True: 15.4M, False: 3.33k]
  |  Branch (277:25): [True: 15.4M, False: 3.56k]
  ------------------
  278|  15.4M|    dropped_nonzero = dropped_nonzero || (*begin != '0');
  ------------------
  |  Branch (278:23): [True: 15.3M, False: 1.68k]
  |  Branch (278:42): [True: 1.13k, False: 553]
  ------------------
  279|  15.4M|    ++begin;
  280|  15.4M|  }
  281|  6.89k|  if (dropped_nonzero && dropped_nonzero_digit != nullptr) {
  ------------------
  |  Branch (281:7): [True: 1.13k, False: 5.76k]
  |  Branch (281:26): [True: 1.13k, False: 0]
  ------------------
  282|  1.13k|    *dropped_nonzero_digit = true;
  283|  1.13k|  }
  284|  6.89k|  *out = accumulator;
  285|  6.89k|  return static_cast<int>(begin - original_begin);
  286|  6.89k|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_17IsDigitILi16EEEbc:
  187|  15.4M|bool IsDigit<16>(char ch) {
  188|  15.4M|  return kAsciiToInt[static_cast<unsigned char>(ch)] >= 0;
  189|  15.4M|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_17ToDigitILi16EEEjc:
  196|  29.8k|unsigned ToDigit<16>(char ch) {
  197|  29.8k|  return static_cast<unsigned>(kAsciiToInt[static_cast<unsigned char>(ch)]);
  198|  29.8k|}

_ZN4absl12lts_2024011616strings_internal33CalculateBase64EscapedLenInternalEmb:
   35|      2|size_t CalculateBase64EscapedLenInternal(size_t input_len, bool do_padding) {
   36|       |  // Base64 encodes three bytes of input at a time. If the input is not
   37|       |  // divisible by three, we pad as appropriate.
   38|       |  //
   39|       |  // Base64 encodes each three bytes of input into four bytes of output.
   40|      2|  size_t len = (input_len / 3) * 4;
   41|       |
   42|       |  // Since all base 64 input is an integral number of octets, only the following
   43|       |  // cases can arise:
   44|      2|  if (input_len % 3 == 0) {
  ------------------
  |  Branch (44:7): [True: 0, False: 2]
  ------------------
   45|       |    // (from https://tools.ietf.org/html/rfc3548)
   46|       |    // (1) the final quantum of encoding input is an integral multiple of 24
   47|       |    // bits; here, the final unit of encoded output will be an integral
   48|       |    // multiple of 4 characters with no "=" padding,
   49|      2|  } else if (input_len % 3 == 1) {
  ------------------
  |  Branch (49:14): [True: 0, False: 2]
  ------------------
   50|       |    // (from https://tools.ietf.org/html/rfc3548)
   51|       |    // (2) the final quantum of encoding input is exactly 8 bits; here, the
   52|       |    // final unit of encoded output will be two characters followed by two
   53|       |    // "=" padding characters, or
   54|      0|    len += 2;
   55|      0|    if (do_padding) {
  ------------------
  |  Branch (55:9): [True: 0, False: 0]
  ------------------
   56|      0|      len += 2;
   57|      0|    }
   58|      2|  } else {  // (input_len % 3 == 2)
   59|       |    // (from https://tools.ietf.org/html/rfc3548)
   60|       |    // (3) the final quantum of encoding input is exactly 16 bits; here, the
   61|       |    // final unit of encoded output will be three characters followed by one
   62|       |    // "=" padding character.
   63|      2|    len += 3;
   64|      2|    if (do_padding) {
  ------------------
  |  Branch (64:9): [True: 0, False: 2]
  ------------------
   65|      0|      len += 1;
   66|      0|    }
   67|      2|  }
   68|       |
   69|       |  assert(len >= input_len);  // make sure we didn't overflow
   70|      2|  return len;
   71|      2|}
_ZN4absl12lts_2024011616strings_internal20Base64EscapeInternalEPKhmPcmPKcb:
   90|      2|                            bool do_padding) {
   91|      2|  static const char kPad64 = '=';
   92|       |
   93|      2|  if (szsrc * 4 > szdest * 3) return 0;
  ------------------
  |  Branch (93:7): [True: 0, False: 2]
  ------------------
   94|       |
   95|      2|  char* cur_dest = dest;
   96|      2|  const unsigned char* cur_src = src;
   97|       |
   98|      2|  char* const limit_dest = dest + szdest;
   99|      2|  const unsigned char* const limit_src = src + szsrc;
  100|       |
  101|       |  // (from https://tools.ietf.org/html/rfc3548)
  102|       |  // Special processing is performed if fewer than 24 bits are available
  103|       |  // at the end of the data being encoded.  A full encoding quantum is
  104|       |  // always completed at the end of a quantity.  When fewer than 24 input
  105|       |  // bits are available in an input group, zero bits are added (on the
  106|       |  // right) to form an integral number of 6-bit groups.
  107|       |  //
  108|       |  // If do_padding is true, padding at the end of the data is performed. This
  109|       |  // output padding uses the '=' character.
  110|       |
  111|       |  // Three bytes of data encodes to four characters of cyphertext.
  112|       |  // So we can pump through three-byte chunks atomically.
  113|      2|  if (szsrc >= 3) {                    // "limit_src - 3" is UB if szsrc < 3.
  ------------------
  |  Branch (113:7): [True: 2, False: 0]
  ------------------
  114|     22|    while (cur_src < limit_src - 3) {  // While we have >= 32 bits.
  ------------------
  |  Branch (114:12): [True: 20, False: 2]
  ------------------
  115|     20|      uint32_t in = absl::big_endian::Load32(cur_src) >> 8;
  116|       |
  117|     20|      cur_dest[0] = base64[in >> 18];
  118|     20|      in &= 0x3FFFF;
  119|     20|      cur_dest[1] = base64[in >> 12];
  120|     20|      in &= 0xFFF;
  121|     20|      cur_dest[2] = base64[in >> 6];
  122|     20|      in &= 0x3F;
  123|     20|      cur_dest[3] = base64[in];
  124|       |
  125|     20|      cur_dest += 4;
  126|     20|      cur_src += 3;
  127|     20|    }
  128|      2|  }
  129|       |  // To save time, we didn't update szdest or szsrc in the loop.  So do it now.
  130|      2|  szdest = static_cast<size_t>(limit_dest - cur_dest);
  131|      2|  szsrc = static_cast<size_t>(limit_src - cur_src);
  132|       |
  133|       |  /* now deal with the tail (<=3 bytes) */
  134|      2|  switch (szsrc) {
  135|      0|    case 0:
  ------------------
  |  Branch (135:5): [True: 0, False: 2]
  ------------------
  136|       |      // Nothing left; nothing more to do.
  137|      0|      break;
  138|      0|    case 1: {
  ------------------
  |  Branch (138:5): [True: 0, False: 2]
  ------------------
  139|       |      // One byte left: this encodes to two characters, and (optionally)
  140|       |      // two pad characters to round out the four-character cypherblock.
  141|      0|      if (szdest < 2) return 0;
  ------------------
  |  Branch (141:11): [True: 0, False: 0]
  ------------------
  142|      0|      uint32_t in = cur_src[0];
  143|      0|      cur_dest[0] = base64[in >> 2];
  144|      0|      in &= 0x3;
  145|      0|      cur_dest[1] = base64[in << 4];
  146|      0|      cur_dest += 2;
  147|      0|      szdest -= 2;
  148|      0|      if (do_padding) {
  ------------------
  |  Branch (148:11): [True: 0, False: 0]
  ------------------
  149|      0|        if (szdest < 2) return 0;
  ------------------
  |  Branch (149:13): [True: 0, False: 0]
  ------------------
  150|      0|        cur_dest[0] = kPad64;
  151|      0|        cur_dest[1] = kPad64;
  152|      0|        cur_dest += 2;
  153|      0|        szdest -= 2;
  154|      0|      }
  155|      0|      break;
  156|      0|    }
  157|      2|    case 2: {
  ------------------
  |  Branch (157:5): [True: 2, False: 0]
  ------------------
  158|       |      // Two bytes left: this encodes to three characters, and (optionally)
  159|       |      // one pad character to round out the four-character cypherblock.
  160|      2|      if (szdest < 3) return 0;
  ------------------
  |  Branch (160:11): [True: 0, False: 2]
  ------------------
  161|      2|      uint32_t in = absl::big_endian::Load16(cur_src);
  162|      2|      cur_dest[0] = base64[in >> 10];
  163|      2|      in &= 0x3FF;
  164|      2|      cur_dest[1] = base64[in >> 4];
  165|      2|      in &= 0x00F;
  166|      2|      cur_dest[2] = base64[in << 2];
  167|      2|      cur_dest += 3;
  168|      2|      szdest -= 3;
  169|      2|      if (do_padding) {
  ------------------
  |  Branch (169:11): [True: 0, False: 2]
  ------------------
  170|      0|        if (szdest < 1) return 0;
  ------------------
  |  Branch (170:13): [True: 0, False: 0]
  ------------------
  171|      0|        cur_dest[0] = kPad64;
  172|      0|        cur_dest += 1;
  173|      0|        szdest -= 1;
  174|      0|      }
  175|      2|      break;
  176|      2|    }
  177|      2|    case 3: {
  ------------------
  |  Branch (177:5): [True: 0, False: 2]
  ------------------
  178|       |      // Three bytes left: same as in the big loop above.  We can't do this in
  179|       |      // the loop because the loop above always reads 4 bytes, and the fourth
  180|       |      // byte is past the end of the input.
  181|      0|      if (szdest < 4) return 0;
  ------------------
  |  Branch (181:11): [True: 0, False: 0]
  ------------------
  182|      0|      uint32_t in =
  183|      0|          (uint32_t{cur_src[0]} << 16) + absl::big_endian::Load16(cur_src + 1);
  184|      0|      cur_dest[0] = base64[in >> 18];
  185|      0|      in &= 0x3FFFF;
  186|      0|      cur_dest[1] = base64[in >> 12];
  187|      0|      in &= 0xFFF;
  188|      0|      cur_dest[2] = base64[in >> 6];
  189|      0|      in &= 0x3F;
  190|      0|      cur_dest[3] = base64[in];
  191|      0|      cur_dest += 4;
  192|      0|      szdest -= 4;
  193|      0|      break;
  194|      0|    }
  195|      0|    default:
  ------------------
  |  Branch (195:5): [True: 0, False: 2]
  ------------------
  196|       |      // Should not be reached: blocks of 4 bytes are handled
  197|       |      // in the while loop before this switch statement.
  198|      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()
  |  |  |  |  ------------------
  |  |  |  |  |  |  225|      0|  do {                                           \
  |  |  |  |  |  |  226|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  227|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  228|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  203|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  229|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (229:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  199|      0|      break;
  200|      2|  }
  201|      2|  return static_cast<size_t>(cur_dest - dest);
  202|      2|}

_ZN4absl12lts_2024011616strings_internal20Base64EscapeInternalINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEvPKhmPT_bPKc:
   42|      2|                          bool do_padding, const char* base64_chars) {
   43|      2|  const size_t calc_escaped_size =
   44|      2|      CalculateBase64EscapedLenInternal(szsrc, do_padding);
   45|      2|  STLStringResizeUninitialized(dest, calc_escaped_size);
   46|       |
   47|      2|  const size_t escaped_len = Base64EscapeInternal(
   48|      2|      src, szsrc, &(*dest)[0], dest->size(), base64_chars, do_padding);
   49|       |  assert(calc_escaped_size == escaped_len);
   50|      2|  dest->erase(escaped_len);
   51|      2|}

_ZN4absl12lts_2024011616strings_internal10memcasecmpEPKcS3_m:
   25|  1.20k|int memcasecmp(const char* s1, const char* s2, size_t len) {
   26|  1.20k|  const unsigned char* us1 = reinterpret_cast<const unsigned char*>(s1);
   27|  1.20k|  const unsigned char* us2 = reinterpret_cast<const unsigned char*>(s2);
   28|       |
   29|  3.50k|  for (size_t i = 0; i < len; i++) {
  ------------------
  |  Branch (29:22): [True: 2.38k, False: 1.12k]
  ------------------
   30|  2.38k|    unsigned char c1 = us1[i];
   31|  2.38k|    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.38k|    if (c1 != c2) {
  ------------------
  |  Branch (36:9): [True: 713, False: 1.66k]
  ------------------
   37|    713|      c1 = c1 >= 'A' && c1 <= 'Z' ? c1 - 'A' + 'a' : c1;
  ------------------
  |  Branch (37:12): [True: 690, False: 23]
  |  Branch (37:25): [True: 662, False: 28]
  ------------------
   38|    713|      c2 = c2 >= 'A' && c2 <= 'Z' ? c2 - 'A' + 'a' : c2;
  ------------------
  |  Branch (38:12): [True: 713, False: 0]
  |  Branch (38:25): [True: 0, False: 713]
  ------------------
   39|    713|      const int diff = int{c1} - int{c2};
   40|    713|      if (diff != 0) return diff;
  ------------------
  |  Branch (40:11): [True: 80, False: 633]
  ------------------
   41|    713|    }
   42|  2.38k|  }
   43|  1.12k|  return 0;
   44|  1.20k|}

_ZN4absl12lts_2024011616strings_internal28STLStringResizeUninitializedINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEvEEvPT_m:
   67|     12|inline void STLStringResizeUninitialized(string_type* s, size_t new_size) {
   68|     12|  ResizeUninitializedTraits<string_type>::Resize(s, new_size);
   69|     12|}
_ZN4absl12lts_2024011616strings_internal25ResizeUninitializedTraitsINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEvE6ResizeEPS9_m:
   47|     12|  static void Resize(string_type* s, size_t new_size) {
   48|     12|    s->__resize_default_init(new_size);
   49|     12|  }

_ZN4absl12lts_2024011619str_format_internal13FormatUntypedENS1_17FormatRawSinkImplENS1_21UntypedFormatSpecImplENS0_4SpanIKNS1_13FormatArgImplEEE:
  214|  3.53k|                   absl::Span<const FormatArgImpl> args) {
  215|  3.53k|  FormatSinkImpl sink(raw_sink);
  216|  3.53k|  using Converter = DefaultConverter;
  217|  3.53k|  return ConvertAll(format, args, Converter(&sink));
  218|  3.53k|}
_ZN4absl12lts_2024011619str_format_internal7FprintFEP8_IO_FILENS1_21UntypedFormatSpecImplENS0_4SpanIKNS1_13FormatArgImplEEE:
  244|  3.53k|            absl::Span<const FormatArgImpl> args) {
  245|  3.53k|  FILERawSink sink(output);
  246|  3.53k|  if (!FormatUntyped(&sink, format, args)) {
  ------------------
  |  Branch (246:7): [True: 0, False: 3.53k]
  ------------------
  247|      0|    errno = EINVAL;
  248|      0|    return -1;
  249|      0|  }
  250|  3.53k|  if (sink.error()) {
  ------------------
  |  Branch (250:7): [True: 0, False: 3.53k]
  ------------------
  251|      0|    errno = sink.error();
  252|      0|    return -1;
  253|      0|  }
  254|  3.53k|  if (sink.count() > static_cast<size_t>(std::numeric_limits<int>::max())) {
  ------------------
  |  Branch (254:7): [True: 0, False: 3.53k]
  ------------------
  255|      0|    errno = EFBIG;
  256|      0|    return -1;
  257|      0|  }
  258|  3.53k|  return static_cast<int>(sink.count());
  259|  3.53k|}
bind.cc:_ZN4absl12lts_2024011619str_format_internal12_GLOBAL__N_110ArgContextC2ENS0_4SpanIKNS1_13FormatArgImplEEE:
   55|  3.53k|  explicit ArgContext(absl::Span<const FormatArgImpl> pack) : pack_(pack) {}
bind.cc:_ZN4absl12lts_2024011619str_format_internal12_GLOBAL__N_116DefaultConverterC2EPNS1_14FormatSinkImplE:
  154|  3.53k|  explicit DefaultConverter(FormatSinkImpl* sink) : sink_(sink) {}
bind.cc:_ZN4absl12lts_2024011619str_format_internal12_GLOBAL__N_110ConvertAllINS2_16DefaultConverterEEEbNS1_21UntypedFormatSpecImplENS0_4SpanIKNS1_13FormatArgImplEEET_:
  142|  3.53k|                absl::Span<const FormatArgImpl> args, Converter converter) {
  143|  3.53k|  if (format.has_parsed_conversion()) {
  ------------------
  |  Branch (143:7): [True: 0, False: 3.53k]
  ------------------
  144|      0|    return format.parsed_conversion()->ProcessFormat(
  145|      0|        ConverterConsumer<Converter>(converter, args));
  146|  3.53k|  } else {
  147|  3.53k|    return ParseFormatString(format.str(),
  148|  3.53k|                             ConverterConsumer<Converter>(converter, args));
  149|  3.53k|  }
  150|  3.53k|}
bind.cc:_ZN4absl12lts_2024011619str_format_internal12_GLOBAL__N_117ConverterConsumerINS2_16DefaultConverterEE6AppendENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEE:
  125|  3.53k|  bool Append(string_view s) {
  126|  3.53k|    converter_.Append(s);
  127|  3.53k|    return true;
  128|  3.53k|  }
bind.cc:_ZNK4absl12lts_2024011619str_format_internal12_GLOBAL__N_116DefaultConverter6AppendENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEE:
  156|  3.53k|  void Append(string_view s) const { sink_->Append(s); }
bind.cc:_ZN4absl12lts_2024011619str_format_internal12_GLOBAL__N_117ConverterConsumerINS2_16DefaultConverterEEC2ES4_NS0_4SpanIKNS1_13FormatArgImplEEE:
  123|  3.53k|      : converter_(converter), arg_context_(pack) {}

_ZN4absl12lts_2024011619str_format_internal21UntypedFormatSpecImplC2ENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   56|  3.53k|      : data_(s.data()), size_(s.size()) {}
_ZN4absl12lts_2024011619str_format_internal21UntypedFormatSpecImpl7ExtractINS1_18FormatSpecTemplateIJEEEEERKS2_RKT_:
   73|  3.53k|  static const UntypedFormatSpecImpl& Extract(const T& s) {
   74|  3.53k|    return s.spec_;
   75|  3.53k|  }
_ZN4absl12lts_2024011619str_format_internal18FormatSpecTemplateIJEEC2EUa9enable_ifIXclL_ZNS1_15ValidFormatImplITpTnNS0_23FormatConversionCharSetEJEEEbNSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEEfL0p_EEEPKc:
  159|  3.53k|      : Base(s) {}
_ZNK4absl12lts_2024011619str_format_internal21UntypedFormatSpecImpl21has_parsed_conversionEv:
   61|  3.53k|  bool has_parsed_conversion() const { return size_ == ~size_t{}; }
_ZNK4absl12lts_2024011619str_format_internal21UntypedFormatSpecImpl3strEv:
   63|  3.53k|  string_view str() const {
   64|       |    assert(!has_parsed_conversion());
   65|  3.53k|    return string_view(static_cast<const char*>(data_), size_);
   66|  3.53k|  }

_ZN4absl12lts_2024011619str_format_internal17FormatRawSinkImpl5WriteENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   48|  3.53k|  void Write(string_view s) { write_(sink_, s); }
_ZN4absl12lts_2024011619str_format_internal14FormatSinkImplC2ENS1_17FormatRawSinkImplE:
   68|  3.53k|  explicit FormatSinkImpl(FormatRawSinkImpl raw) : raw_(raw) {}
_ZN4absl12lts_2024011619str_format_internal14FormatSinkImplD2Ev:
   70|  3.53k|  ~FormatSinkImpl() { Flush(); }
_ZN4absl12lts_2024011619str_format_internal14FormatSinkImpl5FlushEv:
   72|  3.53k|  void Flush() {
   73|  3.53k|    raw_.Write(string_view(buf_, static_cast<size_t>(pos_ - buf_)));
   74|  3.53k|    pos_ = buf_;
   75|  3.53k|  }
_ZN4absl12lts_2024011619str_format_internal14FormatSinkImpl6AppendENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   94|  3.53k|  void Append(string_view v) {
   95|  3.53k|    size_t n = v.size();
   96|  3.53k|    if (n == 0) return;
  ------------------
  |  Branch (96:9): [True: 0, False: 3.53k]
  ------------------
   97|  3.53k|    size_ += n;
   98|  3.53k|    if (n >= Avail()) {
  ------------------
  |  Branch (98:9): [True: 0, False: 3.53k]
  ------------------
   99|      0|      Flush();
  100|      0|      raw_.Write(v);
  101|      0|      return;
  102|      0|    }
  103|  3.53k|    memcpy(pos_, v.data(), n);
  104|  3.53k|    pos_ += n;
  105|  3.53k|  }
_ZNK4absl12lts_2024011619str_format_internal14FormatSinkImpl5AvailEv:
  123|  3.53k|  size_t Avail() const {
  124|  3.53k|    return static_cast<size_t>(buf_ + sizeof(buf_) - pos_);
  125|  3.53k|  }
_ZN4absl12lts_2024011619str_format_internal17FormatRawSinkImplC2INS1_11FILERawSinkETnPDTclsr19str_format_internalE11InvokeFlushclsr3stdE7declvalIPT_EEcvNSt3__117basic_string_viewIcNS7_11char_traitsIcEEEE_EEELPv0EEES6_:
   46|  3.53k|      : sink_(raw), write_(&FormatRawSinkImpl::Flush<T>) {}
_ZN4absl12lts_2024011619str_format_internal17FormatRawSinkImpl5FlushINS1_11FILERawSinkEEEvPvNSt3__117basic_string_viewIcNS6_11char_traitsIcEEEE:
   57|  3.53k|  static void Flush(void* r, string_view s) {
   58|  3.53k|    str_format_internal::InvokeFlush(static_cast<T*>(r), s);
   59|  3.53k|  }

_ZN4absl12lts_2024011619str_format_internal11FILERawSink5WriteENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   42|  3.53k|void FILERawSink::Write(string_view v) {
   43|  7.06k|  while (!v.empty() && !error_) {
  ------------------
  |  Branch (43:10): [True: 3.53k, False: 3.53k]
  |  Branch (43:24): [True: 3.53k, False: 0]
  ------------------
   44|       |    // Reset errno to zero in case the libc implementation doesn't set errno
   45|       |    // when a failure occurs.
   46|  3.53k|    ClearErrnoGuard guard;
   47|       |
   48|  3.53k|    if (size_t result = std::fwrite(v.data(), 1, v.size(), output_)) {
  ------------------
  |  Branch (48:16): [True: 3.53k, False: 0]
  ------------------
   49|       |      // Some progress was made.
   50|  3.53k|      count_ += result;
   51|  3.53k|      v.remove_prefix(result);
   52|  3.53k|    } else {
   53|      0|      if (errno == EINTR) {
  ------------------
  |  Branch (53:11): [True: 0, False: 0]
  ------------------
   54|      0|        continue;
   55|      0|      } else if (errno) {
  ------------------
  |  Branch (55:18): [True: 0, False: 0]
  ------------------
   56|      0|        error_ = errno;
   57|      0|      } else if (std::ferror(output_)) {
  ------------------
  |  Branch (57:18): [True: 0, False: 0]
  ------------------
   58|       |        // Non-POSIX compliant libc implementations may not set errno, so we
   59|       |        // have check the streams error indicator.
   60|      0|        error_ = EBADF;
   61|      0|      } else {
   62|       |        // We're likely on a non-POSIX system that encountered EINTR but had no
   63|       |        // way of reporting it.
   64|      0|        continue;
   65|      0|      }
   66|      0|    }
   67|  3.53k|  }
   68|  3.53k|}
output.cc:_ZN4absl12lts_2024011619str_format_internal12_GLOBAL__N_115ClearErrnoGuardC2Ev:
   26|  3.53k|  ClearErrnoGuard() : old_value(errno) { errno = 0; }
output.cc:_ZN4absl12lts_2024011619str_format_internal12_GLOBAL__N_115ClearErrnoGuardD2Ev:
   27|  3.53k|  ~ClearErrnoGuard() {
   28|  3.53k|    if (!errno) errno = old_value;
  ------------------
  |  Branch (28:9): [True: 3.53k, False: 0]
  ------------------
   29|  3.53k|  }

_ZN4absl12lts_2024011619str_format_internal11FILERawSinkC2EP8_IO_FILE:
   57|  3.53k|  explicit FILERawSink(std::FILE* output) : output_(output) {}
_ZNK4absl12lts_2024011619str_format_internal11FILERawSink5countEv:
   61|  7.06k|  size_t count() const { return count_; }
_ZNK4absl12lts_2024011619str_format_internal11FILERawSink5errorEv:
   62|  3.53k|  int error() const { return error_; }
_ZN4absl12lts_2024011619str_format_internal15AbslFormatFlushEPNS1_11FILERawSinkENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEE:
   78|  3.53k|inline void AbslFormatFlush(FILERawSink* sink, string_view v) {
   79|  3.53k|  sink->Write(v);
   80|  3.53k|}
_ZN4absl12lts_2024011619str_format_internal11InvokeFlushINS1_11FILERawSinkEEEDTcl15AbslFormatFlushfp_fp0_EEPT_NSt3__117basic_string_viewIcNS7_11char_traitsIcEEEE:
   89|  3.53k|auto InvokeFlush(T* out, string_view s) -> decltype(AbslFormatFlush(out, s)) {
   90|  3.53k|  AbslFormatFlush(out, s);
   91|  3.53k|}

bind.cc:_ZN4absl12lts_2024011619str_format_internal17ParseFormatStringINS1_12_GLOBAL__N_117ConverterConsumerINS3_16DefaultConverterEEEEEbNSt3__117basic_string_viewIcNS7_11char_traitsIcEEEET_:
   57|  3.53k|bool ParseFormatString(string_view src, Consumer consumer) {
   58|  3.53k|  int next_arg = 0;
   59|  3.53k|  const char* p = src.data();
   60|  3.53k|  const char* const end = p + src.size();
   61|  3.53k|  while (p != end) {
  ------------------
  |  Branch (61:10): [True: 3.53k, False: 0]
  ------------------
   62|  3.53k|    const char* percent =
   63|  3.53k|        static_cast<const char*>(memchr(p, '%', static_cast<size_t>(end - p)));
   64|  3.53k|    if (!percent) {
  ------------------
  |  Branch (64:9): [True: 3.53k, False: 0]
  ------------------
   65|       |      // We found the last substring.
   66|  3.53k|      return consumer.Append(string_view(p, static_cast<size_t>(end - p)));
   67|  3.53k|    }
   68|       |    // We found a percent, so push the text run then process the percent.
   69|      0|    if (ABSL_PREDICT_FALSE(!consumer.Append(
  ------------------
  |  |  178|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 0]
  |  |  |  Branch (178:49): [Folded, False: 0]
  |  |  |  Branch (178:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
   70|      0|            string_view(p, static_cast<size_t>(percent - p))))) {
   71|      0|      return false;
   72|      0|    }
   73|      0|    if (ABSL_PREDICT_FALSE(percent + 1 >= end)) return false;
  ------------------
  |  |  178|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 0]
  |  |  |  Branch (178:49): [Folded, False: 0]
  |  |  |  Branch (178:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
   74|       |
   75|      0|    auto tag = GetTagForChar(percent[1]);
   76|      0|    if (tag.is_conv()) {
  ------------------
  |  Branch (76:9): [True: 0, False: 0]
  ------------------
   77|      0|      if (ABSL_PREDICT_FALSE(next_arg < 0)) {
  ------------------
  |  |  178|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 0]
  |  |  |  Branch (178:49): [Folded, False: 0]
  |  |  |  Branch (178:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
   78|       |        // This indicates an error in the format string.
   79|       |        // The only way to get `next_arg < 0` here is to have a positional
   80|       |        // argument first which sets next_arg to -1 and then a non-positional
   81|       |        // argument.
   82|      0|        return false;
   83|      0|      }
   84|      0|      p = percent + 2;
   85|       |
   86|       |      // Keep this case separate from the one below.
   87|       |      // ConvertOne is more efficient when the compiler can see that the `basic`
   88|       |      // flag is set.
   89|      0|      UnboundConversion conv;
   90|      0|      conv.conv = tag.as_conv();
   91|      0|      conv.arg_position = ++next_arg;
   92|      0|      if (ABSL_PREDICT_FALSE(
  ------------------
  |  |  178|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 0]
  |  |  |  Branch (178:49): [Folded, False: 0]
  |  |  |  Branch (178:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
   93|      0|              !consumer.ConvertOne(conv, string_view(percent + 1, 1)))) {
   94|      0|        return false;
   95|      0|      }
   96|      0|    } else if (percent[1] != '%') {
  ------------------
  |  Branch (96:16): [True: 0, False: 0]
  ------------------
   97|      0|      UnboundConversion conv;
   98|      0|      p = ConsumeUnboundConversionNoInline(percent + 1, end, &conv, &next_arg);
   99|      0|      if (ABSL_PREDICT_FALSE(p == nullptr)) return false;
  ------------------
  |  |  178|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 0]
  |  |  |  Branch (178:49): [Folded, False: 0]
  |  |  |  Branch (178:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  100|      0|      if (ABSL_PREDICT_FALSE(!consumer.ConvertOne(
  ------------------
  |  |  178|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 0]
  |  |  |  Branch (178:49): [Folded, False: 0]
  |  |  |  Branch (178:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  101|      0|              conv, string_view(percent + 1,
  102|      0|                                static_cast<size_t>(p - (percent + 1)))))) {
  103|      0|        return false;
  104|      0|      }
  105|      0|    } else {
  106|      0|      if (ABSL_PREDICT_FALSE(!consumer.Append("%"))) return false;
  ------------------
  |  |  178|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 0]
  |  |  |  Branch (178:49): [Folded, False: 0]
  |  |  |  Branch (178:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  107|      0|      p = percent + 2;
  108|      0|      continue;
  109|      0|    }
  110|      0|  }
  111|      0|  return true;
  112|  3.53k|}

_ZN4absl12lts_2024011611StrContainsENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEES5_:
   47|      2|                        absl::string_view needle) noexcept {
   48|      2|  return haystack.find(needle, 0) != haystack.npos;
   49|      2|}
_ZN4absl12lts_2024011610StartsWithENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEES5_:
   59|     10|                       absl::string_view prefix) noexcept {
   60|     10|  return prefix.empty() ||
  ------------------
  |  Branch (60:10): [True: 0, False: 10]
  ------------------
   61|     10|         (text.size() >= prefix.size() &&
  ------------------
  |  Branch (61:11): [True: 10, False: 0]
  ------------------
   62|     10|          memcmp(text.data(), prefix.data(), prefix.size()) == 0);
  ------------------
  |  Branch (62:11): [True: 8, False: 2]
  ------------------
   63|     10|}

_ZN4absl12lts_2024011610SimpleAtodENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEPd:
   83|  25.7k|bool SimpleAtod(absl::string_view str, absl::Nonnull<double*> out) {
   84|  25.7k|  *out = 0.0;
   85|  25.7k|  str = StripAsciiWhitespace(str);
   86|       |  // std::from_chars doesn't accept an initial +, but SimpleAtod does, so if one
   87|       |  // is present, skip it, while avoiding accepting "+-0" as valid.
   88|  25.7k|  if (!str.empty() && str[0] == '+') {
  ------------------
  |  Branch (88:7): [True: 25.6k, False: 16]
  |  Branch (88:23): [True: 221, False: 25.4k]
  ------------------
   89|    221|    str.remove_prefix(1);
   90|    221|    if (!str.empty() && str[0] == '-') {
  ------------------
  |  Branch (90:9): [True: 220, False: 1]
  |  Branch (90:25): [True: 1, False: 219]
  ------------------
   91|      1|      return false;
   92|      1|    }
   93|    221|  }
   94|  25.7k|  auto result = absl::from_chars(str.data(), str.data() + str.size(), *out);
   95|  25.7k|  if (result.ec == std::errc::invalid_argument) {
  ------------------
  |  Branch (95:7): [True: 140, False: 25.5k]
  ------------------
   96|    140|    return false;
   97|    140|  }
   98|  25.5k|  if (result.ptr != str.data() + str.size()) {
  ------------------
  |  Branch (98:7): [True: 306, False: 25.2k]
  ------------------
   99|       |    // not all non-whitespace characters consumed
  100|    306|    return false;
  101|    306|  }
  102|       |  // from_chars() with DR 3081's current wording will return max() on
  103|       |  // overflow.  SimpleAtod returns infinity instead.
  104|  25.2k|  if (result.ec == std::errc::result_out_of_range) {
  ------------------
  |  Branch (104:7): [True: 3.88k, False: 21.3k]
  ------------------
  105|  3.88k|    if (*out > 1.0) {
  ------------------
  |  Branch (105:9): [True: 2.26k, False: 1.61k]
  ------------------
  106|  2.26k|      *out = std::numeric_limits<double>::infinity();
  107|  2.26k|    } else if (*out < -1.0) {
  ------------------
  |  Branch (107:16): [True: 337, False: 1.28k]
  ------------------
  108|    337|      *out = -std::numeric_limits<double>::infinity();
  109|    337|    }
  110|  3.88k|  }
  111|  25.2k|  return true;
  112|  25.5k|}
_ZN4absl12lts_2024011616numbers_internal18safe_strtou64_baseENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPmi:
 1360|  1.30k|                        int base) {
 1361|  1.30k|  return safe_uint_internal<uint64_t>(text, value, base);
 1362|  1.30k|}
numbers.cc:_ZN4absl12lts_2024011612_GLOBAL__N_124safe_parse_sign_and_baseEPNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPiPb:
  923|  1.30k|    absl::Nonnull<bool*> negative_ptr /*output*/) {
  924|  1.30k|  if (text->data() == nullptr) {
  ------------------
  |  Branch (924:7): [True: 0, False: 1.30k]
  ------------------
  925|      0|    return false;
  926|      0|  }
  927|       |
  928|  1.30k|  const char* start = text->data();
  929|  1.30k|  const char* end = start + text->size();
  930|  1.30k|  int base = *base_ptr;
  931|       |
  932|       |  // Consume whitespace.
  933|  1.30k|  while (start < end &&
  ------------------
  |  Branch (933:10): [True: 1.28k, False: 13]
  ------------------
  934|  1.28k|         absl::ascii_isspace(static_cast<unsigned char>(start[0]))) {
  ------------------
  |  Branch (934:10): [True: 0, False: 1.28k]
  ------------------
  935|      0|    ++start;
  936|      0|  }
  937|  1.49k|  while (start < end &&
  ------------------
  |  Branch (937:10): [True: 1.48k, False: 13]
  ------------------
  938|  1.48k|         absl::ascii_isspace(static_cast<unsigned char>(end[-1]))) {
  ------------------
  |  Branch (938:10): [True: 194, False: 1.28k]
  ------------------
  939|    194|    --end;
  940|    194|  }
  941|  1.30k|  if (start >= end) {
  ------------------
  |  Branch (941:7): [True: 13, False: 1.28k]
  ------------------
  942|     13|    return false;
  943|     13|  }
  944|       |
  945|       |  // Consume sign.
  946|  1.28k|  *negative_ptr = (start[0] == '-');
  947|  1.28k|  if (*negative_ptr || start[0] == '+') {
  ------------------
  |  Branch (947:7): [True: 3, False: 1.28k]
  |  Branch (947:24): [True: 216, False: 1.07k]
  ------------------
  948|    219|    ++start;
  949|    219|    if (start >= end) {
  ------------------
  |  Branch (949:9): [True: 2, False: 217]
  ------------------
  950|      2|      return false;
  951|      2|    }
  952|    219|  }
  953|       |
  954|       |  // Consume base-dependent prefix.
  955|       |  //  base 0: "0x" -> base 16, "0" -> base 8, default -> base 10
  956|       |  //  base 16: "0x" -> base 16
  957|       |  // Also validate the base.
  958|  1.28k|  if (base == 0) {
  ------------------
  |  Branch (958:7): [True: 0, False: 1.28k]
  ------------------
  959|      0|    if (end - start >= 2 && start[0] == '0' &&
  ------------------
  |  Branch (959:9): [True: 0, False: 0]
  |  Branch (959:29): [True: 0, False: 0]
  ------------------
  960|      0|        (start[1] == 'x' || start[1] == 'X')) {
  ------------------
  |  Branch (960:10): [True: 0, False: 0]
  |  Branch (960:29): [True: 0, False: 0]
  ------------------
  961|      0|      base = 16;
  962|      0|      start += 2;
  963|      0|      if (start >= end) {
  ------------------
  |  Branch (963:11): [True: 0, False: 0]
  ------------------
  964|       |        // "0x" with no digits after is invalid.
  965|      0|        return false;
  966|      0|      }
  967|      0|    } else if (end - start >= 1 && start[0] == '0') {
  ------------------
  |  Branch (967:16): [True: 0, False: 0]
  |  Branch (967:36): [True: 0, False: 0]
  ------------------
  968|      0|      base = 8;
  969|      0|      start += 1;
  970|      0|    } else {
  971|      0|      base = 10;
  972|      0|    }
  973|  1.28k|  } else if (base == 16) {
  ------------------
  |  Branch (973:14): [True: 0, False: 1.28k]
  ------------------
  974|      0|    if (end - start >= 2 && start[0] == '0' &&
  ------------------
  |  Branch (974:9): [True: 0, False: 0]
  |  Branch (974:29): [True: 0, False: 0]
  ------------------
  975|      0|        (start[1] == 'x' || start[1] == 'X')) {
  ------------------
  |  Branch (975:10): [True: 0, False: 0]
  |  Branch (975:29): [True: 0, False: 0]
  ------------------
  976|      0|      start += 2;
  977|      0|      if (start >= end) {
  ------------------
  |  Branch (977:11): [True: 0, False: 0]
  ------------------
  978|       |        // "0x" with no digits after is invalid.
  979|      0|        return false;
  980|      0|      }
  981|      0|    }
  982|  1.28k|  } else if (base >= 2 && base <= 36) {
  ------------------
  |  Branch (982:14): [True: 1.28k, False: 0]
  |  Branch (982:27): [True: 1.28k, False: 0]
  ------------------
  983|       |    // okay
  984|  1.28k|  } else {
  985|      0|    return false;
  986|      0|  }
  987|  1.28k|  *text = absl::string_view(start, static_cast<size_t>(end - start));
  988|  1.28k|  *base_ptr = base;
  989|  1.28k|  return true;
  990|  1.28k|}
numbers.cc:_ZN4absl12lts_2024011612_GLOBAL__N_118safe_uint_internalImEEbNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPT_i:
 1305|  1.30k|                               absl::Nonnull<IntType*> value_p, int base) {
 1306|  1.30k|  *value_p = 0;
 1307|  1.30k|  bool negative;
 1308|  1.30k|  if (!safe_parse_sign_and_base(&text, &base, &negative) || negative) {
  ------------------
  |  Branch (1308:7): [True: 15, False: 1.28k]
  |  Branch (1308:61): [True: 2, False: 1.28k]
  ------------------
 1309|     17|    return false;
 1310|     17|  }
 1311|  1.28k|  return safe_parse_positive_int(text, base, value_p);
 1312|  1.30k|}
numbers.cc:_ZN4absl12lts_2024011612_GLOBAL__N_123safe_parse_positive_intImEEbNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEiPT_:
 1208|  1.28k|                                    absl::Nonnull<IntType*> value_p) {
 1209|  1.28k|  IntType value = 0;
 1210|  1.28k|  const IntType vmax = std::numeric_limits<IntType>::max();
 1211|  1.28k|  assert(vmax > 0);
 1212|  1.28k|  assert(base >= 0);
 1213|  1.28k|  const IntType base_inttype = static_cast<IntType>(base);
 1214|  1.28k|  assert(vmax >= base_inttype);
 1215|  1.28k|  const IntType vmax_over_base = LookupTables<IntType>::kVmaxOverBase[base];
 1216|  1.28k|  assert(base < 2 ||
 1217|  1.28k|         std::numeric_limits<IntType>::max() / base_inttype == vmax_over_base);
 1218|  1.28k|  const char* start = text.data();
 1219|  1.28k|  const char* end = start + text.size();
 1220|       |  // loop over digits
 1221|  5.43k|  for (; start < end; ++start) {
  ------------------
  |  Branch (1221:10): [True: 4.27k, False: 1.16k]
  ------------------
 1222|  4.27k|    unsigned char c = static_cast<unsigned char>(start[0]);
 1223|  4.27k|    IntType digit = static_cast<IntType>(kAsciiToInt[c]);
 1224|  4.27k|    if (digit >= base_inttype) {
  ------------------
  |  Branch (1224:9): [True: 51, False: 4.22k]
  ------------------
 1225|     51|      *value_p = value;
 1226|     51|      return false;
 1227|     51|    }
 1228|  4.22k|    if (value > vmax_over_base) {
  ------------------
  |  Branch (1228:9): [True: 72, False: 4.15k]
  ------------------
 1229|     72|      *value_p = vmax;
 1230|     72|      return false;
 1231|     72|    }
 1232|  4.15k|    value *= base_inttype;
 1233|  4.15k|    if (value > vmax - digit) {
  ------------------
  |  Branch (1233:9): [True: 1, False: 4.14k]
  ------------------
 1234|      1|      *value_p = vmax;
 1235|      1|      return false;
 1236|      1|    }
 1237|  4.14k|    value += digit;
 1238|  4.14k|  }
 1239|  1.16k|  *value_p = value;
 1240|  1.16k|  return true;
 1241|  1.28k|}

_ZN4absl12lts_2024011616numbers_internal16safe_strtoi_baseImEEbNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPT_i:
  354|  1.30k|                                           int base) {
  355|  1.30k|  static_assert(sizeof(*out) == 4 || sizeof(*out) == 8,
  356|  1.30k|                "SimpleAtoi works only with 32-bit or 64-bit integers.");
  357|  1.30k|  static_assert(!std::is_floating_point<int_type>::value,
  358|  1.30k|                "Use SimpleAtof or SimpleAtod instead.");
  359|  1.30k|  bool parsed;
  360|       |  // TODO(jorg): This signed-ness check is used because it works correctly
  361|       |  // with enums, and it also serves to check that int_type is not a pointer.
  362|       |  // If one day something like std::is_signed<enum E> works, switch to it.
  363|       |  // These conditions are constexpr bools to suppress MSVC warning C4127.
  364|  1.30k|  constexpr bool kIsSigned = static_cast<int_type>(1) - 2 < 0;
  365|  1.30k|  constexpr bool kUse64Bit = sizeof(*out) == 64 / 8;
  366|  1.30k|  if (kIsSigned) {
  ------------------
  |  Branch (366:7): [Folded, False: 1.30k]
  ------------------
  367|      0|    if (kUse64Bit) {
  ------------------
  |  Branch (367:9): [True: 0, Folded]
  ------------------
  368|      0|      int64_t val;
  369|      0|      parsed = numbers_internal::safe_strto64_base(s, &val, base);
  370|      0|      *out = static_cast<int_type>(val);
  371|      0|    } else {
  372|      0|      int32_t val;
  373|      0|      parsed = numbers_internal::safe_strto32_base(s, &val, base);
  374|      0|      *out = static_cast<int_type>(val);
  375|      0|    }
  376|  1.30k|  } else {
  377|  1.30k|    if (kUse64Bit) {
  ------------------
  |  Branch (377:9): [True: 1.30k, Folded]
  ------------------
  378|  1.30k|      uint64_t val;
  379|  1.30k|      parsed = numbers_internal::safe_strtou64_base(s, &val, base);
  380|  1.30k|      *out = static_cast<int_type>(val);
  381|  1.30k|    } else {
  382|      0|      uint32_t val;
  383|      0|      parsed = numbers_internal::safe_strtou32_base(s, &val, base);
  384|      0|      *out = static_cast<int_type>(val);
  385|      0|    }
  386|  1.30k|  }
  387|  1.30k|  return parsed;
  388|  1.30k|}
_ZN4absl12lts_2024011610SimpleAtoiImEEbNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPT_:
  423|  1.30k|                                     absl::Nonnull<int_type*> out) {
  424|  1.30k|  return numbers_internal::safe_strtoi_base(str, out, 10);
  425|  1.30k|}

_ZN4absl12lts_202401166StrCatERKNS0_8AlphaNumES3_:
   58|      2|std::string StrCat(const AlphaNum& a, const AlphaNum& b) {
   59|      2|  std::string result;
   60|      2|  absl::strings_internal::STLStringResizeUninitialized(&result,
   61|      2|                                                       a.size() + b.size());
   62|      2|  char* const begin = &result[0];
   63|      2|  char* out = begin;
   64|      2|  out = Append(out, a);
   65|      2|  out = Append(out, b);
   66|       |  assert(out == begin + result.size());
   67|      2|  return result;
   68|      2|}
_ZN4absl12lts_202401166StrCatERKNS0_8AlphaNumES3_S3_:
   70|      8|std::string StrCat(const AlphaNum& a, const AlphaNum& b, const AlphaNum& c) {
   71|      8|  std::string result;
   72|      8|  strings_internal::STLStringResizeUninitialized(
   73|      8|      &result, a.size() + b.size() + c.size());
   74|      8|  char* const begin = &result[0];
   75|      8|  char* out = begin;
   76|      8|  out = Append(out, a);
   77|      8|  out = Append(out, b);
   78|      8|  out = Append(out, c);
   79|       |  assert(out == begin + result.size());
   80|      8|  return result;
   81|      8|}
str_cat.cc:_ZN4absl12lts_2024011612_GLOBAL__N_16AppendEPcRKNS0_8AlphaNumE:
   46|     28|absl::Nonnull<char*> Append(absl::Nonnull<char*> 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|     28|  char* after = out + x.size();
   50|     28|  if (x.size() != 0) {
  ------------------
  |  Branch (50:7): [True: 26, False: 2]
  ------------------
   51|     26|    memcpy(out, x.data(), x.size());
   52|     26|  }
   53|     28|  return after;
   54|     28|}

_ZN4absl12lts_202401168AlphaNumC2EPKc:
  353|      8|      : piece_(NullSafeStringView(c_str)) {}
_ZN4absl12lts_202401168AlphaNumC2ENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
  356|      6|      : piece_(pc) {}
_ZNK4absl12lts_202401168AlphaNum4sizeEv:
  377|    110|  absl::string_view::size_type size() const { return piece_.size(); }
_ZNK4absl12lts_202401168AlphaNum4dataEv:
  378|     26|  absl::Nullable<const char*> data() const { return piece_.data(); }
_ZN4absl12lts_202401168AlphaNumC2INSt3__19allocatorIcEEEERKNS3_12basic_stringIcNS3_11char_traitsIcEET_EE:
  369|     14|      : piece_(str) {}

_ZN4absl12lts_2024011617UntypedFormatSpecC2ENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
  111|  3.53k|  explicit UntypedFormatSpec(string_view s) : spec_(s) {}
_ZN4absl12lts_202401167FPrintFIJEEEiP8_IO_FILERKNS0_19str_format_internal18FormatSpecTemplateIJXspclsr19str_format_internalE14ArgumentToConvIT_EEEEEEDpRKS6_:
  441|  3.53k|            const Args&... args) {
  442|  3.53k|  return str_format_internal::FprintF(
  443|  3.53k|      output, str_format_internal::UntypedFormatSpecImpl::Extract(format),
  444|  3.53k|      {str_format_internal::FormatArgImpl(args)...});
  445|  3.53k|}

_ZN4absl12lts_2024011618NullSafeStringViewEPKc:
  762|      8|constexpr string_view NullSafeStringView(absl::Nullable<const char*> p) {
  763|      8|  return p ? string_view(p) : string_view();
  ------------------
  |  Branch (763:10): [True: 8, False: 0]
  ------------------
  764|      8|}

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

_ZN4absl12lts_2024011624synchronization_internal14InvalidGraphIdEv:
   58|  3.67k|inline GraphId InvalidGraphId() {
   59|  3.67k|  return GraphId{0};
   60|  3.67k|}

_ZN4absl12lts_202401165Mutex4LockEv:
 1524|  3.67k|void Mutex::Lock() {
 1525|  3.67k|  ABSL_TSAN_MUTEX_PRE_LOCK(this, 0);
 1526|  3.67k|  GraphId id = DebugOnlyDeadlockCheck(this);
 1527|  3.67k|  intptr_t v = mu_.load(std::memory_order_relaxed);
 1528|       |  // try fast acquire, then spin loop
 1529|  3.67k|  if (ABSL_PREDICT_FALSE((v & (kMuWriter | kMuReader | kMuEvent)) != 0) ||
  ------------------
  |  |  178|  7.34k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 3.67k]
  |  |  |  Branch (178:49): [Folded, False: 3.67k]
  |  |  |  Branch (178:58): [True: 0, False: 3.67k]
  |  |  ------------------
  ------------------
 1530|  3.67k|      ABSL_PREDICT_FALSE(!mu_.compare_exchange_strong(
  ------------------
  |  |  178|  3.67k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 3.67k]
  |  |  |  Branch (178:49): [Folded, False: 3.67k]
  |  |  |  Branch (178:58): [True: 0, False: 3.67k]
  |  |  ------------------
  ------------------
 1531|  3.67k|          v, kMuWriter | v, std::memory_order_acquire,
 1532|  3.67k|          std::memory_order_relaxed))) {
 1533|       |    // try spin acquire, then slow loop
 1534|      0|    if (ABSL_PREDICT_FALSE(!TryAcquireWithSpinning(&this->mu_))) {
  ------------------
  |  |  178|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 0]
  |  |  |  Branch (178:49): [Folded, False: 0]
  |  |  |  Branch (178:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1535|      0|      this->LockSlow(kExclusive, nullptr, 0);
 1536|      0|    }
 1537|      0|  }
 1538|  3.67k|  DebugOnlyLockEnter(this, id);
 1539|  3.67k|  ABSL_TSAN_MUTEX_POST_LOCK(this, 0, 0);
 1540|  3.67k|}
_ZN4absl12lts_202401165Mutex6UnlockEv:
 1702|  3.67k|void Mutex::Unlock() {
 1703|  3.67k|  ABSL_TSAN_MUTEX_PRE_UNLOCK(this, 0);
 1704|  3.67k|  DebugOnlyLockLeave(this);
 1705|  3.67k|  intptr_t v = mu_.load(std::memory_order_relaxed);
 1706|       |
 1707|  3.67k|  if (kDebugMode && ((v & (kMuWriter | kMuReader)) != kMuWriter)) {
  ------------------
  |  Branch (1707:7): [Folded, False: 3.67k]
  |  Branch (1707:21): [True: 0, False: 0]
  ------------------
 1708|      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()
  |  |  |  |  ------------------
  |  |  |  |  |  |  225|      0|  do {                                           \
  |  |  |  |  |  |  226|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  227|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  228|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  203|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  229|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (229:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1709|      0|                 static_cast<unsigned>(v));
 1710|      0|  }
 1711|       |
 1712|       |  // should_try_cas is whether we'll try a compare-and-swap immediately.
 1713|       |  // NOTE: optimized out when kDebugMode is false.
 1714|  3.67k|  bool should_try_cas = ((v & (kMuEvent | kMuWriter)) == kMuWriter &&
  ------------------
  |  Branch (1714:26): [True: 3.67k, False: 0]
  ------------------
 1715|  3.67k|                         (v & (kMuWait | kMuDesig)) != kMuWait);
  ------------------
  |  Branch (1715:26): [True: 3.67k, False: 0]
  ------------------
 1716|       |  // But, we can use an alternate computation of it, that compilers
 1717|       |  // currently don't find on their own.  When that changes, this function
 1718|       |  // can be simplified.
 1719|  3.67k|  intptr_t x = (v ^ (kMuWriter | kMuWait)) & (kMuWriter | kMuEvent);
 1720|  3.67k|  intptr_t y = (v ^ (kMuWriter | kMuWait)) & (kMuWait | kMuDesig);
 1721|       |  // Claim: "x == 0 && y > 0" is equal to should_try_cas.
 1722|       |  // Also, because kMuWriter and kMuEvent exceed kMuDesig and kMuWait,
 1723|       |  // all possible non-zero values for x exceed all possible values for y.
 1724|       |  // Therefore, (x == 0 && y > 0) == (x < y).
 1725|  3.67k|  if (kDebugMode && should_try_cas != (x < y)) {
  ------------------
  |  Branch (1725:7): [Folded, False: 3.67k]
  |  Branch (1725:21): [True: 0, False: 0]
  ------------------
 1726|       |    // We would usually use PRIdPTR here, but is not correctly implemented
 1727|       |    // within the android toolchain.
 1728|      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()
  |  |  |  |  ------------------
  |  |  |  |  |  |  225|      0|  do {                                           \
  |  |  |  |  |  |  226|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  227|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  228|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  203|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  229|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (229:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1729|      0|                 static_cast<long long>(v), static_cast<long long>(x),
 1730|      0|                 static_cast<long long>(y));
 1731|      0|  }
 1732|  3.67k|  if (x < y && mu_.compare_exchange_strong(v, v & ~(kMuWrWait | kMuWriter),
  ------------------
  |  Branch (1732:7): [True: 3.67k, False: 0]
  |  Branch (1732:16): [True: 3.67k, False: 0]
  ------------------
 1733|  3.67k|                                           std::memory_order_release,
 1734|  3.67k|                                           std::memory_order_relaxed)) {
 1735|       |    // fast writer release (writer with no waiters or with designated waker)
 1736|  3.67k|  } else {
 1737|      0|    this->UnlockSlow(nullptr /*no waitp*/);  // take slow path
 1738|      0|  }
 1739|  3.67k|  ABSL_TSAN_MUTEX_POST_UNLOCK(this, 0);
 1740|  3.67k|}
mutex.cc:_ZN4absl12lts_20240116L22DebugOnlyDeadlockCheckEPNS0_5MutexE:
 1466|  3.67k|static inline GraphId DebugOnlyDeadlockCheck(Mutex* mu) {
 1467|  3.67k|  if (kDebugMode && synch_deadlock_detection.load(std::memory_order_acquire) !=
  ------------------
  |  Branch (1467:7): [Folded, False: 3.67k]
  |  Branch (1467:21): [True: 0, False: 0]
  ------------------
 1468|      0|                        OnDeadlockCycle::kIgnore) {
 1469|      0|    return DeadlockCheck(mu);
 1470|  3.67k|  } else {
 1471|  3.67k|    return InvalidGraphId();
 1472|  3.67k|  }
 1473|  3.67k|}
mutex.cc:_ZN4absl12lts_20240116L18DebugOnlyLockEnterEPNS0_5MutexENS0_24synchronization_internal7GraphIdE:
 1298|  3.67k|static inline void DebugOnlyLockEnter(Mutex* mu, GraphId id) {
 1299|  3.67k|  if (kDebugMode) {
  ------------------
  |  Branch (1299:7): [Folded, False: 3.67k]
  ------------------
 1300|      0|    if (synch_deadlock_detection.load(std::memory_order_acquire) !=
  ------------------
  |  Branch (1300:9): [True: 0, False: 0]
  ------------------
 1301|      0|        OnDeadlockCycle::kIgnore) {
 1302|      0|      LockEnter(mu, id, Synch_GetAllLocks());
 1303|      0|    }
 1304|      0|  }
 1305|  3.67k|}
mutex.cc:_ZN4absl12lts_20240116L18DebugOnlyLockLeaveEPNS0_5MutexE:
 1308|  3.67k|static inline void DebugOnlyLockLeave(Mutex* mu) {
 1309|  3.67k|  if (kDebugMode) {
  ------------------
  |  Branch (1309:7): [Folded, False: 3.67k]
  ------------------
 1310|      0|    if (synch_deadlock_detection.load(std::memory_order_acquire) !=
  ------------------
  |  Branch (1310:9): [True: 0, False: 0]
  ------------------
 1311|      0|        OnDeadlockCycle::kIgnore) {
 1312|      0|      LockLeave(mu, GetGraphId(mu), Synch_GetAllLocks());
 1313|      0|    }
 1314|      0|  }
 1315|  3.67k|}

_ZN4absl12lts_202401169MutexLockC2EPNS0_5MutexE:
  583|  3.63k|  explicit MutexLock(Mutex* mu) ABSL_EXCLUSIVE_LOCK_FUNCTION(mu) : mu_(mu) {
  584|  3.63k|    this->mu_->Lock();
  585|  3.63k|  }
_ZN4absl12lts_202401169MutexLockD2Ev:
  601|  3.63k|  ~MutexLock() ABSL_UNLOCK_FUNCTION() { this->mu_->Unlock(); }
_ZN4absl12lts_202401165MutexC2Ev:
 1061|     34|inline Mutex::Mutex() : mu_(0) {
 1062|     34|  ABSL_TSAN_MUTEX_CREATE(this, __tsan_mutex_not_static);
 1063|     34|}

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

_ZN4absl12lts_202401168DurationmIES1_:
  419|  5.53k|Duration& Duration::operator-=(Duration rhs) {
  420|  5.53k|  if (time_internal::IsInfiniteDuration(*this)) return *this;
  ------------------
  |  Branch (420:7): [True: 0, False: 5.53k]
  ------------------
  421|  5.53k|  if (time_internal::IsInfiniteDuration(rhs)) {
  ------------------
  |  Branch (421:7): [True: 0, False: 5.53k]
  ------------------
  422|      0|    return *this = rhs.rep_hi_.Get() >= 0 ? -InfiniteDuration()
  ------------------
  |  Branch (422:20): [True: 0, False: 0]
  ------------------
  423|      0|                                          : InfiniteDuration();
  424|      0|  }
  425|  5.53k|  const int64_t orig_rep_hi = rep_hi_.Get();
  426|  5.53k|  rep_hi_ = DecodeTwosComp(EncodeTwosComp(rep_hi_.Get()) -
  427|  5.53k|                           EncodeTwosComp(rhs.rep_hi_.Get()));
  428|  5.53k|  if (rep_lo_ < rhs.rep_lo_) {
  ------------------
  |  Branch (428:7): [True: 3, False: 5.52k]
  ------------------
  429|      3|    rep_hi_ = DecodeTwosComp(EncodeTwosComp(rep_hi_.Get()) - 1);
  430|      3|    rep_lo_ += kTicksPerSecond;
  431|      3|  }
  432|  5.53k|  rep_lo_ -= rhs.rep_lo_;
  433|  5.53k|  if (rhs.rep_hi_.Get() < 0 ? rep_hi_.Get() < orig_rep_hi
  ------------------
  |  Branch (433:7): [True: 0, False: 5.53k]
  |  Branch (433:7): [True: 0, False: 5.53k]
  ------------------
  434|  5.53k|                            : rep_hi_.Get() > orig_rep_hi) {
  435|      0|    return *this = rhs.rep_hi_.Get() >= 0 ? -InfiniteDuration()
  ------------------
  |  Branch (435:20): [True: 0, False: 0]
  ------------------
  436|      0|                                          : InfiniteDuration();
  437|      0|  }
  438|  5.53k|  return *this;
  439|  5.53k|}
duration.cc:_ZN4absl12lts_2024011612_GLOBAL__N_114DecodeTwosCompEm:
  187|  5.53k|inline int64_t DecodeTwosComp(uint64_t v) { return absl::bit_cast<int64_t>(v); }
duration.cc:_ZN4absl12lts_2024011612_GLOBAL__N_114EncodeTwosCompEl:
  184|  11.0k|inline uint64_t EncodeTwosComp(int64_t v) {
  185|  11.0k|  return absl::bit_cast<uint64_t>(v);
  186|  11.0k|}

clock.cc:_ZN4absl12lts_2024011613time_internalL29GetCurrentTimeNanosFromSystemEv:
   13|  11.0k|static int64_t GetCurrentTimeNanosFromSystem() {
   14|  11.0k|  const int64_t kNanosPerSecond = 1000 * 1000 * 1000;
   15|  11.0k|  struct timespec ts;
   16|  11.0k|  ABSL_RAW_CHECK(clock_gettime(CLOCK_REALTIME, &ts) == 0,
  ------------------
  |  |   60|  11.0k|  do {                                                                 \
  |  |   61|  11.0k|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  178|  11.0k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (178:31): [True: 0, False: 11.0k]
  |  |  |  |  |  Branch (178:49): [Folded, False: 11.0k]
  |  |  |  |  |  Branch (178:58): [True: 0, False: 11.0k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   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()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  225|      0|  do {                                           \
  |  |  |  |  |  |  |  |  226|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  227|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  228|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  203|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  229|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (229:12): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   52|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|      0|    }                                                                  \
  |  |   64|  11.0k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 11.0k]
  |  |  ------------------
  ------------------
   17|  11.0k|                 "Failed to read real-time clock.");
   18|  11.0k|  return (int64_t{ts.tv_sec} * kNanosPerSecond +
   19|  11.0k|          int64_t{ts.tv_nsec});
   20|  11.0k|}

_ZN4absl12lts_202401168DurationC2Ev:
  169|  5.53k|  constexpr Duration() : rep_hi_(0), rep_lo_(0) {}  // zero-length duration
_ZN4absl12lts_202401168DurationC2Elj:
  231|  20.1k|  constexpr Duration(int64_t hi, uint32_t lo) : rep_hi_(hi), rep_lo_(lo) {}
_ZN4absl12lts_202401168Duration5HiRepC2El:
  251|  25.6k|          lo_(0),
  252|  25.6k|          hi_(0)
  253|       |#endif
  254|  25.6k|    {
  255|  25.6k|      *this = value;
  256|  25.6k|    }
_ZNK4absl12lts_202401168Duration5HiRep3GetEv:
  258|  45.7k|    constexpr int64_t Get() const {
  259|  45.7k|      const uint64_t unsigned_value =
  260|  45.7k|          (static_cast<uint64_t>(hi_) << 32) | static_cast<uint64_t>(lo_);
  261|       |      // `static_cast<int64_t>(unsigned_value)` is implementation-defined
  262|       |      // before c++20. On all supported platforms the behaviour is that mandated
  263|       |      // by c++20, i.e. "If the destination type is signed, [...] the result is
  264|       |      // the unique value of the destination type equal to the source value
  265|       |      // modulo 2^n, where n is the number of bits used to represent the
  266|       |      // destination type."
  267|  45.7k|      static_assert(
  268|  45.7k|          (static_cast<int64_t>((std::numeric_limits<uint64_t>::max)()) ==
  269|  45.7k|           int64_t{-1}) &&
  270|  45.7k|              (static_cast<int64_t>(static_cast<uint64_t>(
  271|  45.7k|                                        (std::numeric_limits<int64_t>::max)()) +
  272|  45.7k|                                    1) ==
  273|  45.7k|               (std::numeric_limits<int64_t>::min)()),
  274|  45.7k|          "static_cast<int64_t>(uint64_t) does not have c++20 semantics");
  275|  45.7k|      return static_cast<int64_t>(unsigned_value);
  276|  45.7k|    }
_ZN4absl12lts_202401168Duration5HiRepaSEl:
  278|  31.1k|    constexpr HiRep& operator=(const int64_t value) {
  279|       |      // "If the destination type is unsigned, the resulting value is the
  280|       |      // smallest unsigned value equal to the source value modulo 2^n
  281|       |      // where `n` is the number of bits used to represent the destination
  282|       |      // type".
  283|  31.1k|      const auto unsigned_value = static_cast<uint64_t>(value);
  284|  31.1k|      hi_ = static_cast<uint32_t>(unsigned_value >> 32);
  285|  31.1k|      lo_ = static_cast<uint32_t>(unsigned_value);
  286|  31.1k|      return *this;
  287|  31.1k|    }
_ZN4absl12lts_202401164TimeC2ENS0_8DurationE:
  850|  20.1k|  constexpr explicit Time(Duration rep) : rep_(rep) {}
_ZN4absl12lts_20240116leENS0_8DurationES1_:
  320|      2|                                                        Duration rhs) {
  321|      2|  return !(rhs < lhs);
  322|      2|}
_ZN4absl12lts_20240116miENS0_8DurationES1_:
  337|  5.53k|                                                        Duration rhs) {
  338|  5.53k|  return lhs -= rhs;
  339|  5.53k|}
_ZN4absl12lts_2024011612ZeroDurationEv:
  416|  5.53k|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr Duration ZeroDuration() {
  417|  5.53k|  return Duration();
  418|  5.53k|}
_ZN4absl12lts_20240116eqENS0_4TimeES1_:
  867|  9.06k|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr bool operator==(Time lhs, Time rhs) {
  868|  9.06k|  return lhs.rep_ == rhs.rep_;
  869|  9.06k|}
_ZN4absl12lts_20240116neENS0_4TimeES1_:
  870|  9.06k|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr bool operator!=(Time lhs, Time rhs) {
  871|  9.06k|  return !(lhs == rhs);
  872|  9.06k|}
_ZN4absl12lts_20240116miENS0_4TimeES1_:
  884|  5.53k|ABSL_ATTRIBUTE_CONST_FUNCTION inline Duration operator-(Time lhs, Time rhs) {
  885|  5.53k|  return lhs.rep_ - rhs.rep_;
  886|  5.53k|}
_ZN4absl12lts_2024011614InfiniteFutureEv:
  907|  9.06k|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr Time InfiniteFuture() {
  908|  9.06k|  return Time(time_internal::MakeDuration((std::numeric_limits<int64_t>::max)(),
  909|  9.06k|                                          ~uint32_t{0}));
  910|  9.06k|}
_ZN4absl12lts_2024011613time_internal12MakeDurationElj:
 1561|  20.1k|                                                              uint32_t lo = 0) {
 1562|  20.1k|  return Duration(hi, lo);
 1563|  20.1k|}
_ZN4absl12lts_2024011613time_internal12MakeDurationEll:
 1566|  11.0k|                                                              int64_t lo) {
 1567|  11.0k|  return MakeDuration(hi, static_cast<uint32_t>(lo));
 1568|  11.0k|}
_ZN4absl12lts_2024011613time_internal8GetRepHiENS0_8DurationE:
 1593|  18.1k|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr int64_t GetRepHi(Duration d) {
 1594|  18.1k|  return d.rep_hi_.Get();
 1595|  18.1k|}
_ZN4absl12lts_2024011613time_internal8GetRepLoENS0_8DurationE:
 1596|  29.1k|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr uint32_t GetRepLo(Duration d) {
 1597|  29.1k|  return d.rep_lo_;
 1598|  29.1k|}
_ZN4absl12lts_2024011613time_internal18IsInfiniteDurationENS0_8DurationE:
 1601|  11.0k|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr bool IsInfiniteDuration(Duration d) {
 1602|  11.0k|  return GetRepLo(d) == ~uint32_t{0};
 1603|  11.0k|}
_ZN4absl12lts_2024011613time_internal16FromUnixDurationENS0_8DurationE:
 1626|  11.0k|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr Time FromUnixDuration(Duration d) {
 1627|  11.0k|  return Time(d);
 1628|  11.0k|}
_ZN4absl12lts_20240116ltENS0_8DurationES1_:
 1721|      2|                                                       Duration rhs) {
 1722|      2|  return time_internal::GetRepHi(lhs) != time_internal::GetRepHi(rhs)
  ------------------
  |  Branch (1722:10): [True: 2, False: 0]
  ------------------
 1723|      2|             ? time_internal::GetRepHi(lhs) < time_internal::GetRepHi(rhs)
 1724|      2|         : time_internal::GetRepHi(lhs) == (std::numeric_limits<int64_t>::min)()
  ------------------
  |  Branch (1724:12): [True: 0, False: 0]
  ------------------
 1725|      0|             ? time_internal::GetRepLo(lhs) + 1 <
 1726|      0|                   time_internal::GetRepLo(rhs) + 1
 1727|      0|             : time_internal::GetRepLo(lhs) < time_internal::GetRepLo(rhs);
 1728|      2|}
_ZN4absl12lts_20240116eqENS0_8DurationES1_:
 1731|  9.06k|                                                        Duration rhs) {
 1732|  9.06k|  return time_internal::GetRepHi(lhs) == time_internal::GetRepHi(rhs) &&
  ------------------
  |  Branch (1732:10): [True: 9.06k, False: 0]
  ------------------
 1733|  9.06k|         time_internal::GetRepLo(lhs) == time_internal::GetRepLo(rhs);
  ------------------
  |  Branch (1733:10): [True: 9.06k, False: 0]
  ------------------
 1734|  9.06k|}
_ZN4absl12lts_2024011616InfiniteDurationEv:
 1762|      4|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr Duration InfiniteDuration() {
 1763|      4|  return time_internal::MakeDuration((std::numeric_limits<int64_t>::max)(),
 1764|      4|                                     ~uint32_t{0});
 1765|      4|}
_ZN4absl12lts_202401164TimeC2Ev:
  780|      4|  constexpr Time() = default;

_ZN4absl12lts_2024011613span_internal7GetDataIKNSt3__16vectorIN8fuzztest8internal8IRObjectENS3_9allocatorIS7_EEEEEEDTcl11GetDataImplfp_Li0EEERT_:
   50|  5.67k|    -> decltype(GetDataImpl(c, 0)) {
   51|  5.67k|  return GetDataImpl(c, 0);
   52|  5.67k|}
_ZN4absl12lts_2024011613span_internal11GetDataImplIKNSt3__16vectorIN8fuzztest8internal8IRObjectENS3_9allocatorIS7_EEEEEEDTcldtfp_4dataEERT_c:
   38|  5.67k|    -> decltype(c.data()) {
   39|  5.67k|  return c.data();
   40|  5.67k|}
_ZN4absl12lts_2024011613span_internal7GetDataIKNSt3__16vectorIjNS3_9allocatorIjEEEEEEDTcl11GetDataImplfp_Li0EEERT_:
   50|      2|    -> decltype(GetDataImpl(c, 0)) {
   51|      2|  return GetDataImpl(c, 0);
   52|      2|}
_ZN4absl12lts_2024011613span_internal11GetDataImplIKNSt3__16vectorIjNS3_9allocatorIjEEEEEEDTcldtfp_4dataEERT_c:
   38|      2|    -> decltype(c.data()) {
   39|      2|  return c.data();
   40|      2|}
_ZN4absl12lts_2024011613span_internal7GetDataIKNS0_4SpanIjEEEEDTcl11GetDataImplfp_Li0EEERT_:
   50|     16|    -> decltype(GetDataImpl(c, 0)) {
   51|     16|  return GetDataImpl(c, 0);
   52|     16|}
_ZN4absl12lts_2024011613span_internal11GetDataImplIKNS0_4SpanIjEEEEDTcldtfp_4dataEERT_c:
   38|     16|    -> decltype(c.data()) {
   39|     16|  return c.data();
   40|     16|}

_ZN4absl12lts_202401164SpanIKNS0_19str_format_internal13FormatArgImplEEC2EPS4_m:
  193|  3.53k|      : ptr_(array), len_(length) {}
_ZN4absl12lts_202401164SpanIKNS0_19str_format_internal13FormatArgImplEEC2Ev:
  191|  3.53k|  constexpr Span() noexcept : Span(nullptr, 0) {}
_ZN4absl12lts_202401164SpanIKN8fuzztest8internal8IRObjectEEC2INSt3__16vectorIS4_NS8_9allocatorIS4_EEEEvSC_iEERKT_:
  217|  5.67k|      : Span(span_internal::GetData(v), v.size()) {}
_ZN4absl12lts_202401164SpanIKN8fuzztest8internal8IRObjectEEC2EPS5_m:
  193|  5.67k|      : ptr_(array), len_(length) {}
_ZN4absl12lts_202401164SpanIKN8fuzztest8internal8IRObjectEEC2Ev:
  191|      2|  constexpr Span() noexcept : Span(nullptr, 0) {}
_ZNK4absl12lts_202401164SpanIKN8fuzztest8internal8IRObjectEE4sizeEv:
  286|  5.67k|  constexpr size_type size() const noexcept { return len_; }
_ZNK4absl12lts_202401164SpanIKN8fuzztest8internal8IRObjectEE5beginEv:
  336|  5.54k|  constexpr iterator begin() const noexcept { return data(); }
_ZNK4absl12lts_202401164SpanIKN8fuzztest8internal8IRObjectEE4dataEv:
  281|  5.54k|  constexpr pointer data() const noexcept { return ptr_; }
_ZNK4absl12lts_202401164SpanIhE4dataEv:
  281|      2|  constexpr pointer data() const noexcept { return ptr_; }
_ZNK4absl12lts_202401164SpanIhE4sizeEv:
  286|      2|  constexpr size_type size() const noexcept { return len_; }
_ZNK4absl12lts_202401164SpanIjE4dataEv:
  281|     20|  constexpr pointer data() const noexcept { return ptr_; }
_ZNK4absl12lts_202401164SpanIjE4sizeEv:
  286|     20|  constexpr size_type size() const noexcept { return len_; }
_ZN4absl12lts_202401168MakeSpanITpTnRiJEhEENS0_4SpanIT0_EEPS4_m:
  685|      2|constexpr Span<T> MakeSpan(absl::Nullable<T*> ptr, size_t size) noexcept {
  686|      2|  return Span<T>(ptr, size);
  687|      2|}
_ZN4absl12lts_202401164SpanIhEC2EPhm:
  193|      2|      : ptr_(array), len_(length) {}
_ZN4absl12lts_202401164SpanIKjEC2INSt3__16vectorIjNS5_9allocatorIjEEEEvS9_iEERKT_:
  217|      2|      : Span(span_internal::GetData(v), v.size()) {}
_ZN4absl12lts_202401164SpanIKjEC2EPS2_m:
  193|     18|      : ptr_(array), len_(length) {}
_ZNK4absl12lts_202401164SpanIKjE4dataEv:
  281|     34|  constexpr pointer data() const noexcept { return ptr_; }
_ZNK4absl12lts_202401164SpanIKjE4sizeEv:
  286|     18|  constexpr size_type size() const noexcept { return len_; }
_ZN4absl12lts_202401168MakeSpanITpTnRiJEjLm512EEENS0_4SpanIT0_EERAT1__S4_:
  702|      2|constexpr Span<T> MakeSpan(T (&array)[N]) noexcept {
  703|      2|  return Span<T>(array, N);
  704|      2|}
_ZN4absl12lts_202401164SpanIjEC2EPjm:
  193|     18|      : ptr_(array), len_(length) {}
_ZNK4absl12lts_202401164SpanIKjE5beginEv:
  336|     16|  constexpr iterator begin() const noexcept { return data(); }
_ZNK4absl12lts_202401164SpanIKjE3endEv:
  349|     16|  constexpr iterator end() const noexcept { return data() + size(); }
_ZN4absl12lts_202401168MakeSpanITpTnRiJEjEENS0_4SpanIT0_EEPS4_m:
  685|     16|constexpr Span<T> MakeSpan(absl::Nullable<T*> ptr, size_t size) noexcept {
  686|     16|  return Span<T>(ptr, size);
  687|     16|}
_ZN4absl12lts_202401164SpanIKjEC2INS1_IjEEvS5_TnNSt3__19enable_ifIXsr6IsViewIT_EE5valueEiE4typeELi0EEERKS8_:
  232|     16|      : Span(span_internal::GetData(v), v.size()) {}
_ZNK4absl12lts_202401164SpanIjE5emptyEv:
  296|      2|  constexpr bool empty() const noexcept { return size() == 0; }

_ZN4absl12lts_202401167forwardINS0_18container_internal12CommonFieldsEEEOT_RNSt3__116remove_referenceIS4_E4typeE:
  149|      6|    absl::remove_reference_t<T>& t) noexcept {  // NOLINT(runtime/references)
  150|      6|  return static_cast<T&&>(t);
  151|      6|}
_ZN4absl12lts_202401167forwardINS0_18container_internal10StringHashEEEOT_RNSt3__116remove_referenceIS4_E4typeE:
  149|      6|    absl::remove_reference_t<T>& t) noexcept {  // NOLINT(runtime/references)
  150|      6|  return static_cast<T&&>(t);
  151|      6|}
_ZN4absl12lts_202401167forwardINS0_18container_internal8StringEqEEEOT_RNSt3__116remove_referenceIS4_E4typeE:
  149|      6|    absl::remove_reference_t<T>& t) noexcept {  // NOLINT(runtime/references)
  150|      6|  return static_cast<T&&>(t);
  151|      6|}
_ZN4absl12lts_202401167forwardINSt3__19allocatorINS2_4pairIKNS2_17basic_string_viewIcNS2_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEEEEEOT_RNS2_16remove_referenceISE_E4typeE:
  149|      6|    absl::remove_reference_t<T>& t) noexcept {  // NOLINT(runtime/references)
  150|      6|  return static_cast<T&&>(t);
  151|      6|}

_ZN8fuzztest15internal_no_adl7TupleOfITpTnRiJEJNS_8internal23SequenceContainerOfImplINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEENS3_13ArbitraryImplIcvEEEEEEEDaDpT0_:
  564|      2|auto TupleOf(Inner... inner) {
  565|      2|  return internal::AggregateOfImpl<std::tuple<internal::value_type_t<Inner>...>,
  566|      2|                                   internal::RequireCustomCorpusType::kNo,
  567|      2|                                   Inner...>(std::in_place,
  568|      2|                                             std::move(inner)...);
  569|      2|}
_ZN8fuzztest15internal_no_adl6StringEv:
  500|      2|inline auto String() { return Arbitrary<std::string>(); }
_ZN8fuzztest15internal_no_adl9ArbitraryINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEDav:
  274|      2|auto Arbitrary() {
  275|      2|  return internal::ArbitraryImpl<T>{};
  276|      2|}

main:
   21|      2|int main(int argc, char** argv) {
   22|      2|  testing::InitGoogleTest(&argc, argv);
   23|       |  // We call fuzztest::ParseAbslFlagsrather than absl::ParseCommandLine
   24|       |  // since the latter would complain about any unknown flags that need
   25|       |  // to be passed to legacy fuzzing engines (e.g. libfuzzer).
   26|      2|  fuzztest::ParseAbslFlags(argc, argv);
   27|      2|  fuzztest::InitFuzzTest(&argc, &argv);
   28|      2|  return RUN_ALL_TESTS();
   29|      2|}

_ZN8fuzztest19ListRegisteredTestsEv:
  124|      4|std::vector<std::string> ListRegisteredTests() {
  125|      4|  std::vector<std::string> result;
  126|      4|  internal::ForEachTest(
  127|      4|      [&](const auto& test) { result.push_back(test.full_name()); });
  128|      4|  return result;
  129|      4|}
_ZN8fuzztest25GetMatchingFuzzTestOrExitENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE:
  131|      2|std::string GetMatchingFuzzTestOrExit(std::string_view name) {
  132|      2|  const std::string partial_name(name);
  133|      2|  const std::vector<std::string> full_names = ListRegisteredTests();
  134|      2|  std::vector<const std::string*> matches;
  135|      2|  for (const std::string& full_name : full_names) {
  ------------------
  |  Branch (135:37): [True: 2, False: 0]
  ------------------
  136|      2|    if (absl::StrContains(full_name, partial_name)) {
  ------------------
  |  Branch (136:9): [True: 2, False: 0]
  ------------------
  137|      2|      if (full_name == partial_name) {
  ------------------
  |  Branch (137:11): [True: 2, False: 0]
  ------------------
  138|       |        // In case of an exact match, we end the search and use it. This is to
  139|       |        // handle the case when we want to select `MySuite.MyTest`, but the
  140|       |        // binary has both `MySuite.MyTest` and `MySuite.MyTestX`.
  141|      2|        return full_name;
  142|      2|      } else {
  143|      0|        matches.push_back(&full_name);
  144|      0|      }
  145|      2|    }
  146|      2|  }
  147|       |
  148|      0|  if (matches.empty()) {
  ------------------
  |  Branch (148:7): [True: 0, False: 0]
  ------------------
  149|      0|    absl::FPrintF(stderr, "\n\nNo FUZZ_TEST matches the name: %s\n\n",
  150|      0|                  partial_name);
  151|      0|    absl::FPrintF(stderr, "Valid tests:\n");
  152|      0|    for (const std::string& full_name : full_names) {
  ------------------
  |  Branch (152:39): [True: 0, False: 0]
  ------------------
  153|      0|      absl::FPrintF(stderr, " %s\n", full_name);
  154|      0|    }
  155|      0|    exit(1);
  156|      0|  } else if (matches.size() > 1) {
  ------------------
  |  Branch (156:14): [True: 0, False: 0]
  ------------------
  157|      0|    absl::FPrintF(stderr, "\n\nMultiple FUZZ_TESTs match the name: %s\n\n",
  158|      0|                  partial_name);
  159|      0|    absl::FPrintF(stderr, "Please select one. Matching tests:\n");
  160|      0|    for (const std::string* full_name : matches) {
  ------------------
  |  Branch (160:39): [True: 0, False: 0]
  ------------------
  161|      0|      absl::FPrintF(stderr, " %s\n", *full_name);
  162|      0|    }
  163|      0|    exit(1);
  164|      0|  }
  165|      0|  return *matches[0];
  166|      0|}
_ZN8fuzztest12InitFuzzTestEPiPPPcNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEE:
  241|      2|void InitFuzzTest(int* argc, char*** argv, std::string_view binary_id) {
  242|      2|  const char* centipede_binary = std::getenv("FUZZTEST_CENTIPEDE_BINARY");
  243|      2|  const bool is_runner_mode = std::getenv("CENTIPEDE_RUNNER_FLAGS");
  244|      2|  if (centipede_binary != nullptr && !is_runner_mode) {
  ------------------
  |  Branch (244:7): [True: 0, False: 2]
  |  Branch (244:38): [True: 0, False: 0]
  ------------------
  245|      0|    ExecvToCentipede(centipede_binary, *argc, *argv);
  246|      0|  }
  247|       |
  248|      2|  const bool is_listing = absl::GetFlag(FUZZTEST_FLAG(list_fuzz_tests));
  ------------------
  |  |   20|      2|#define FUZZTEST_FLAG(name) FLAGS_##name
  ------------------
  249|      2|  if (is_listing) {
  ------------------
  |  Branch (249:7): [True: 0, False: 2]
  ------------------
  250|      0|    for (const auto& name : ListRegisteredTests()) {
  ------------------
  |  Branch (250:27): [True: 0, False: 0]
  ------------------
  251|      0|      std::cout << "[*] Fuzz test: " << name << '\n';
  252|      0|    }
  253|      0|    std::exit(0);
  254|      0|  }
  255|       |
  256|      2|  const auto test_to_fuzz = absl::GetFlag(FUZZTEST_FLAG(fuzz));
  ------------------
  |  |   20|      2|#define FUZZTEST_FLAG(name) FLAGS_##name
  ------------------
  257|      2|  const bool is_test_to_fuzz_specified = test_to_fuzz != kUnspecified;
  258|      2|  if (is_test_to_fuzz_specified) {
  ------------------
  |  Branch (258:7): [True: 2, False: 0]
  ------------------
  259|      2|    const std::string matching_fuzz_test =
  260|      2|        GetMatchingFuzzTestOrExit(test_to_fuzz);
  261|       |    // Delegate the test to GoogleTest.
  262|      2|    GTEST_FLAG_SET(filter, matching_fuzz_test);
  263|      2|  }
  264|       |
  265|      2|  std::string derived_binary_id =
  266|      2|      binary_id.empty() ? std::string(internal::Basename(*argv[0]))
  ------------------
  |  Branch (266:7): [True: 2, False: 0]
  ------------------
  267|      2|                        : std::string(binary_id);
  268|      2|  std::optional<std::string> reproduction_command_template;
  269|      2|  internal::Configuration configuration =
  270|      2|      CreateConfigurationsFromFlags(derived_binary_id);
  271|      2|  configuration.reproduction_command_template = reproduction_command_template;
  272|      2|  internal::RegisterFuzzTestsAsGoogleTests(argc, argv, configuration);
  273|       |
  274|      2|  const bool has_time_limit_per_test =
  275|      2|      configuration.time_limit_per_test < absl::InfiniteDuration();
  276|      2|  const RunMode run_mode = is_test_to_fuzz_specified || has_time_limit_per_test
  ------------------
  |  Branch (276:28): [True: 2, False: 0]
  |  Branch (276:57): [True: 0, False: 0]
  ------------------
  277|      2|                               ? RunMode::kFuzz
  278|      2|                               : RunMode::kUnitTest;
  279|       |
  280|      2|  if (run_mode == RunMode::kFuzz && !is_test_to_fuzz_specified &&
  ------------------
  |  Branch (280:7): [True: 2, False: 0]
  |  Branch (280:37): [True: 0, False: 2]
  ------------------
  281|      2|      GTEST_FLAG_GET(filter) == "*") {
  ------------------
  |  Branch (281:7): [True: 0, False: 0]
  ------------------
  282|       |    // Run only the fuzz tests, and not the unit tests when the user doesn't
  283|       |    // set the test filter.
  284|       |    // TODO: b/340232436 -- This is needed because we currently rely on a fuzz
  285|       |    // test being the first test to run so that Centipede can get the serialized
  286|       |    // configuration from the binary. For simplicity, we don't restrict the
  287|       |    // filter to fuzz tests when the user explicitly sets the filter. Instead of
  288|       |    // improving the logic here, once we fix b/340232436 we will remove this
  289|       |    // altogether and allow a mix of fuzz tests and unit tests in all cases.
  290|      0|    GTEST_FLAG_SET(filter, absl::StrJoin(configuration.fuzz_tests, ":"));
  291|      0|  }
  292|       |
  293|       |  // TODO(b/307513669): Use the Configuration class instead of Runtime.
  294|      2|  internal::Runtime::instance().SetRunMode(run_mode);
  295|      2|}
_ZN8fuzztest14ParseAbslFlagsEiPPc:
  297|      2|void ParseAbslFlags(int argc, char** argv) {
  298|      2|  std::vector<char*> positional_args;
  299|      2|  std::vector<absl::UnrecognizedFlag> unrecognized_flags;
  300|      2|  absl::ParseAbseilFlagsOnly(argc, argv, positional_args, unrecognized_flags);
  301|      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:_ZN8fuzztest12_GLOBAL__N_129CreateConfigurationsFromFlagsENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  171|      2|    absl::string_view binary_identifier) {
  172|      2|  bool reproduce_findings_as_separate_tests =
  173|      2|      absl::GetFlag(FUZZTEST_FLAG(reproduce_findings_as_separate_tests));
  ------------------
  |  |   20|      2|#define FUZZTEST_FLAG(name) FLAGS_##name
  ------------------
  174|      2|  absl::Duration time_limit_per_test = absl::GetFlag(FUZZTEST_FLAG(fuzz_for));
  ------------------
  |  |   20|      2|#define FUZZTEST_FLAG(name) FLAGS_##name
  ------------------
  175|      2|  if (time_limit_per_test <= absl::ZeroDuration()) {
  ------------------
  |  Branch (175:7): [True: 0, False: 2]
  ------------------
  176|      0|    time_limit_per_test = absl::InfiniteDuration();
  177|      0|  }
  178|      2|  return internal::Configuration{
  179|      2|      absl::GetFlag(FUZZTEST_FLAG(corpus_database)),
  ------------------
  |  |   20|      2|#define FUZZTEST_FLAG(name) FLAGS_##name
  ------------------
  180|      2|      std::string(binary_identifier),
  181|      2|      /*fuzz_tests=*/ListRegisteredTests(),
  182|      2|      reproduce_findings_as_separate_tests,
  183|      2|      absl::GetFlag(FUZZTEST_FLAG(replay_coverage_inputs)),
  ------------------
  |  |   20|      2|#define FUZZTEST_FLAG(name) FLAGS_##name
  ------------------
  184|      2|      /*stack_limit=*/absl::GetFlag(FUZZTEST_FLAG(stack_limit_kb)) * 1024,
  ------------------
  |  |   20|      2|#define FUZZTEST_FLAG(name) FLAGS_##name
  ------------------
  185|      2|      /*rss_limit=*/absl::GetFlag(FUZZTEST_FLAG(rss_limit_mb)) * 1024 * 1024,
  ------------------
  |  |   20|      2|#define FUZZTEST_FLAG(name) FLAGS_##name
  ------------------
  186|      2|      absl::GetFlag(FUZZTEST_FLAG(time_limit_per_input)),
  ------------------
  |  |   20|      2|#define FUZZTEST_FLAG(name) FLAGS_##name
  ------------------
  187|      2|      time_limit_per_test};
  188|      2|}
init_fuzztest.cc:_ZZN8fuzztest19ListRegisteredTestsEvENK3$_0clINS_8internal8FuzzTestEEEDaRKT_:
  127|      4|      [&](const auto& test) { result.push_back(test.full_name()); });

_ZN8fuzztest8internal11CopyableAnyC2INSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEJSB_EEENS3_15in_place_type_tIT_EEDpOT0_:
  169|  5.53k|      : AnyBase(std::in_place, std::true_type{},
  170|  5.53k|                new T(std::forward<U>(args)...)) {}
_ZN8fuzztest8internal7AnyBaseC2INSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEENS3_10in_place_tENS3_17integral_constantIbLb1EEEPT_:
   34|  5.53k|  explicit AnyBase(std::in_place_t, std::true_type, T* value) {
   35|  5.53k|    static constexpr VTable kVTable = {type_id<T>, DestroyImpl<T>, CopyImpl<T>};
   36|  5.53k|    vtable_ = &kVTable;
   37|  5.53k|    value_ = const_cast<void*>(static_cast<const void*>(value));
   38|  5.53k|  }
_ZN8fuzztest8internal7AnyBase11DestroyImplINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEEvPv:
  122|  11.0k|  static void DestroyImpl(void* p) {
  123|  11.0k|    delete static_cast<T*>(p);
  124|  11.0k|  }
_ZNR8fuzztest8internal7AnyBase5GetAsINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEERT_v:
   58|  5.53k|  T& GetAs() & {
   59|  5.53k|    FUZZTEST_INTERNAL_CHECK_PRECONDITION(has_value(), "Object is empty!");
  ------------------
  |  |   42|  5.53k|  ((P) ? (void)0                                     \
  |  |  ------------------
  |  |  |  Branch (42:4): [True: 5.53k, False: 0]
  |  |  ------------------
  |  |   43|  5.53k|       : ::fuzztest::internal::Abort(                \
  |  |   44|      0|             __FILE__, __LINE__,                     \
  |  |   45|      0|             absl::StrCat("Failed precondition (", #P, "): ", __VA_ARGS__)))
  ------------------
   60|  5.53k|    FUZZTEST_INTERNAL_CHECK_PRECONDITION(Has<T>(), "Wrong type!");
  ------------------
  |  |   42|  5.53k|  ((P) ? (void)0                                     \
  |  |  ------------------
  |  |  |  Branch (42:4): [True: 5.53k, False: 0]
  |  |  ------------------
  |  |   43|  5.53k|       : ::fuzztest::internal::Abort(                \
  |  |   44|      0|             __FILE__, __LINE__,                     \
  |  |   45|      0|             absl::StrCat("Failed precondition (", #P, "): ", __VA_ARGS__)))
  ------------------
   61|  5.53k|    return *static_cast<T*>(value_);
   62|  5.53k|  }
_ZNK8fuzztest8internal7AnyBase9has_valueEv:
   46|  60.8k|  bool has_value() const {
   47|  60.8k|    FUZZTEST_INTERNAL_CHECK((vtable_ == nullptr) == (value_ == nullptr),
  ------------------
  |  |   48|  60.8k|  ((cond) ? (void)0                                            \
  |  |  ------------------
  |  |  |  Branch (48:4): [True: 60.8k, False: 0]
  |  |  ------------------
  |  |   49|  60.8k|          : ::fuzztest::internal::Abort(                       \
  |  |   50|      0|                __FILE__, __LINE__,                            \
  |  |   51|      0|                absl::StrCat("Internal error! Check (", #cond, \
  |  |   52|      0|                             ") failed: ", __VA_ARGS__)))
  ------------------
   48|  60.8k|                            "Inconsistent state between value and vtable.");
   49|  60.8k|    return value_ != nullptr;
   50|  60.8k|  }
_ZNK8fuzztest8internal7AnyBase3HasINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEEbv:
   53|  16.5k|  bool Has() const {
   54|  16.5k|    return has_value() && vtable_->type_id == type_id<T>;
  ------------------
  |  Branch (54:12): [True: 16.5k, False: 0]
  |  Branch (54:27): [True: 16.5k, False: 0]
  ------------------
   55|  16.5k|  }
_ZNKR8fuzztest8internal7AnyBase5GetAsINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEERKT_v:
   65|  11.0k|  const T& GetAs() const& {
   66|  11.0k|    FUZZTEST_INTERNAL_CHECK_PRECONDITION(has_value(), "Object is empty!");
  ------------------
  |  |   42|  11.0k|  ((P) ? (void)0                                     \
  |  |  ------------------
  |  |  |  Branch (42:4): [True: 11.0k, False: 0]
  |  |  ------------------
  |  |   43|  11.0k|       : ::fuzztest::internal::Abort(                \
  |  |   44|      0|             __FILE__, __LINE__,                     \
  |  |   45|      0|             absl::StrCat("Failed precondition (", #P, "): ", __VA_ARGS__)))
  ------------------
   67|  11.0k|    FUZZTEST_INTERNAL_CHECK_PRECONDITION(Has<T>(), "Wrong type!");
  ------------------
  |  |   42|  11.0k|  ((P) ? (void)0                                     \
  |  |  ------------------
  |  |  |  Branch (42:4): [True: 11.0k, False: 0]
  |  |  ------------------
  |  |   43|  11.0k|       : ::fuzztest::internal::Abort(                \
  |  |   44|      0|             __FILE__, __LINE__,                     \
  |  |   45|      0|             absl::StrCat("Failed precondition (", #P, "): ", __VA_ARGS__)))
  ------------------
   68|  11.0k|    return *static_cast<T*>(value_);
   69|  11.0k|  }
_ZN8fuzztest8internal11CopyableAnyC2EOS1_:
  174|  16.5k|  CopyableAny(CopyableAny&& other) = default;
_ZN8fuzztest8internal7AnyBaseC2EOS1_:
   89|  16.5k|      : vtable_(std::exchange(other.vtable_, nullptr)),
   90|  16.5k|        value_(std::exchange(other.value_, nullptr)) {}
_ZN8fuzztest8internal7AnyBaseD2Ev:
  100|  27.6k|  ~AnyBase() { Destroy(); }
_ZN8fuzztest8internal7AnyBase7DestroyEv:
  102|  27.6k|  void Destroy() {
  103|  27.6k|    if (has_value()) vtable_->destroy(value_);
  ------------------
  |  Branch (103:9): [True: 11.0k, False: 16.5k]
  ------------------
  104|  27.6k|  }
_ZN8fuzztest8internal11MoveOnlyAnyC2INSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEJSB_EEENS3_15in_place_type_tIT_EEDpOT0_:
  150|  5.53k|      : AnyBase(std::in_place, std::false_type{},
  151|  5.53k|                new T(std::forward<U>(args)...)) {}
_ZN8fuzztest8internal7AnyBaseC2INSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEENS3_10in_place_tENS3_17integral_constantIbLb0EEEPT_:
   40|  5.53k|  explicit AnyBase(std::in_place_t, std::false_type, T* value) {
   41|  5.53k|    static constexpr VTable kVTable = {type_id<T>, DestroyImpl<T>, nullptr};
   42|  5.53k|    vtable_ = &kVTable;
   43|  5.53k|    value_ = const_cast<void*>(static_cast<const void*>(value));
   44|  5.53k|  }

_ZN8fuzztest8internal25SetExternalEngineCallbackEPNS0_22ExternalEngineCallbackE:
   33|      2|void SetExternalEngineCallback(ExternalEngineCallback* callback) {
   34|      2|  external_engine_callback = callback;
   35|      2|}
_ZN8fuzztest8internal25GetExternalEngineCallbackEv:
   37|  9.06k|ExternalEngineCallback* GetExternalEngineCallback() {
   38|  9.06k|  return external_engine_callback;
   39|  9.06k|}
_ZN8fuzztest8internal29FuzzTestExternalEngineAdaptorC2ERKNS0_8FuzzTestENSt3__110unique_ptrINS0_20UntypedFixtureDriverENS5_14default_deleteIS7_EEEE:
   66|      2|    : test_(test), fixture_driver_staging_(std::move(fixture_driver)) {}
_ZN8fuzztest8internal29FuzzTestExternalEngineAdaptor16RunInFuzzingModeEPiPPPcRKNS0_13ConfigurationE:
   74|      2|    int* argc, char*** argv, const Configuration& configuration) {
   75|      2|  FUZZTEST_INTERNAL_CHECK(&LLVMFuzzerRunDriver,
  ------------------
  |  |   48|      2|  ((cond) ? (void)0                                            \
  |  |  ------------------
  |  |  |  Branch (48:4): [True: 2, Folded]
  |  |  ------------------
  |  |   49|      2|          : ::fuzztest::internal::Abort(                       \
  |  |   50|      0|                __FILE__, __LINE__,                            \
  |  |   51|      0|                absl::StrCat("Internal error! Check (", #cond, \
  |  |   52|      0|                             ") failed: ", __VA_ARGS__)))
  ------------------
   76|      2|                          "LibFuzzer Driver API not defined.");
   77|      2|  FUZZTEST_INTERNAL_CHECK(
  ------------------
  |  |   48|      2|  ((cond) ? (void)0                                            \
  |  |  ------------------
  |  |  |  Branch (48:4): [True: 2, False: 0]
  |  |  ------------------
  |  |   49|      2|          : ::fuzztest::internal::Abort(                       \
  |  |   50|      0|                __FILE__, __LINE__,                            \
  |  |   51|      0|                absl::StrCat("Internal error! Check (", #cond, \
  |  |   52|      0|                             ") failed: ", __VA_ARGS__)))
  ------------------
   78|      2|      GetExternalEngineCallback() == nullptr,
   79|      2|      "External engine callback is already set while running a fuzz test.");
   80|      2|  SetExternalEngineCallback(this);
   81|      2|  runtime_.SetRunMode(RunMode::kFuzz);
   82|      2|  auto& impl = GetFuzzerImpl();
   83|      2|  runtime_.EnableReporter(&impl.stats_, [] { return absl::Now(); });
   84|       |
   85|      2|  FUZZTEST_INTERNAL_CHECK(impl.fixture_driver_ != nullptr,
  ------------------
  |  |   48|      2|  ((cond) ? (void)0                                            \
  |  |  ------------------
  |  |  |  Branch (48:4): [True: 2, False: 0]
  |  |  ------------------
  |  |   49|      2|          : ::fuzztest::internal::Abort(                       \
  |  |   50|      0|                __FILE__, __LINE__,                            \
  |  |   51|      0|                absl::StrCat("Internal error! Check (", #cond, \
  |  |   52|      0|                             ") failed: ", __VA_ARGS__)))
  ------------------
   86|      2|                          "Invalid fixture driver!");
   87|      2|  impl.fixture_driver_->SetUpFuzzTest();
   88|       |
   89|      2|  static bool driver_started = false;
   90|      2|  FUZZTEST_INTERNAL_CHECK(!driver_started, "Driver started more than once!");
  ------------------
  |  |   48|      2|  ((cond) ? (void)0                                            \
  |  |  ------------------
  |  |  |  Branch (48:4): [True: 2, False: 0]
  |  |  ------------------
  |  |   49|      2|          : ::fuzztest::internal::Abort(                       \
  |  |   50|      0|                __FILE__, __LINE__,                            \
  |  |   51|      0|                absl::StrCat("Internal error! Check (", #cond, \
  |  |   52|      0|                             ") failed: ", __VA_ARGS__)))
  ------------------
   91|      2|  driver_started = true;
   92|      2|  LLVMFuzzerRunDriver(argc, argv, [](const uint8_t* data, size_t size) -> int {
   93|      2|    GetExternalEngineCallback()->RunOneInputData(
   94|      2|        absl::string_view(reinterpret_cast<const char*>(data), size));
   95|      2|    return 0;
   96|      2|  });
   97|       |
   98|       |  // If we're here, we didn't exit from RunOneInputData(), and hence we didn't
   99|       |  // tear down the fixture.
  100|      2|  FUZZTEST_INTERNAL_CHECK(impl.fixture_driver_ != nullptr,
  ------------------
  |  |   48|      2|  ((cond) ? (void)0                                            \
  |  |  ------------------
  |  |  |  Branch (48:4): [True: 0, False: 2]
  |  |  ------------------
  |  |   49|      2|          : ::fuzztest::internal::Abort(                       \
  |  |   50|      2|                __FILE__, __LINE__,                            \
  |  |   51|      2|                absl::StrCat("Internal error! Check (", #cond, \
  |  |   52|      2|                             ") failed: ", __VA_ARGS__)))
  ------------------
  101|      2|                          "Invalid fixture driver!");
  102|      2|  impl.fixture_driver_->TearDownFuzzTest();
  103|       |
  104|      2|  return 0;
  105|      2|}
_ZN8fuzztest8internal29FuzzTestExternalEngineAdaptor15RunOneInputDataENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
  117|  9.06k|void FuzzTestExternalEngineAdaptor::RunOneInputData(absl::string_view data) {
  118|  9.06k|  auto& impl = GetFuzzerImpl();
  119|  9.06k|  if (impl.ShouldStop()) {
  ------------------
  |  Branch (119:7): [True: 0, False: 9.06k]
  ------------------
  120|      0|    FUZZTEST_INTERNAL_CHECK(impl.fixture_driver_ != nullptr,
  ------------------
  |  |   48|      0|  ((cond) ? (void)0                                            \
  |  |  ------------------
  |  |  |  Branch (48:4): [True: 0, False: 0]
  |  |  ------------------
  |  |   49|      0|          : ::fuzztest::internal::Abort(                       \
  |  |   50|      0|                __FILE__, __LINE__,                            \
  |  |   51|      0|                absl::StrCat("Internal error! Check (", #cond, \
  |  |   52|      0|                             ") failed: ", __VA_ARGS__)))
  ------------------
  121|      0|                            "Invalid fixture driver!");
  122|      0|    impl.fixture_driver_->TearDownFuzzTest();
  123|      0|    runtime_.PrintFinalStatsOnDefaultSink();
  124|       |    // Use _Exit instead of exit so libFuzzer does not treat it as a crash.
  125|      0|    std::_Exit(0);
  126|      0|  }
  127|  9.06k|  runtime_.SetCurrentTest(&impl.test_, nullptr);
  128|  9.06k|  if (data.size() == 0) return;
  ------------------
  |  Branch (128:7): [True: 0, False: 9.06k]
  ------------------
  129|  9.06k|  auto input = impl.TryParse(data);
  130|  9.06k|  if (!input) return;
  ------------------
  |  Branch (130:7): [True: 3.53k, False: 5.53k]
  ------------------
  131|  5.53k|  impl.RunOneInput({*std::move(input)});
  132|  5.53k|}
_ZN8fuzztest8internal29FuzzTestExternalEngineAdaptor13GetFuzzerImplEv:
  160|  9.06k|FuzzTestExternalEngineAdaptor::GetFuzzerImpl() {
  161|       |  // Postpone the creation to override libFuzzer signal setup.
  162|  9.06k|  if (!fuzzer_impl_) {
  ------------------
  |  Branch (162:7): [True: 2, False: 9.06k]
  ------------------
  163|      2|    fuzzer_impl_ =
  164|      2|        std::make_unique<FuzzerImpl>(test_, std::move(fixture_driver_staging_));
  165|      2|    fixture_driver_staging_ = nullptr;
  166|      2|  }
  167|  9.06k|  return *fuzzer_impl_;
  168|  9.06k|}
compatibility_mode.cc:_ZZN8fuzztest8internal29FuzzTestExternalEngineAdaptor16RunInFuzzingModeEPiPPPcRKNS0_13ConfigurationEENK3$_1clEPKhm:
   92|  9.06k|  LLVMFuzzerRunDriver(argc, argv, [](const uint8_t* data, size_t size) -> int {
   93|  9.06k|    GetExternalEngineCallback()->RunOneInputData(
   94|  9.06k|        absl::string_view(reinterpret_cast<const char*>(data), size));
   95|  9.06k|    return 0;
   96|  9.06k|  });

_ZN8fuzztest8internal14CorpusDatabaseC2ENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEES6_bb:
   44|      2|    : corpus_path_for_test_binary_([=] () -> std::string {
   45|      2|        if (database_path.empty()) return "";
   46|      2|        std::string corpus_path_for_test_binary =
   47|      2|            absl::StrCat(database_path, "/", binary_identifier);
   48|      2|        if (!absl::StartsWith(corpus_path_for_test_binary, "/") &&
   49|      2|            std::getenv("TEST_SRCDIR")) {
   50|      2|          corpus_path_for_test_binary = absl::StrCat(
   51|      2|              std::getenv("TEST_SRCDIR"), "/", corpus_path_for_test_binary);
   52|      2|        }
   53|      2|        return corpus_path_for_test_binary;
   54|      2|      }()),
   55|      2|      use_coverage_inputs_(use_coverage_inputs),
   56|      2|      use_crashing_inputs_(use_crashing_inputs) {}
_ZN8fuzztest8internal14CorpusDatabaseC2ERKNS0_13ConfigurationE:
   59|      2|    : CorpusDatabase(
   60|      2|          configuration.corpus_database, configuration.binary_identifier,
   61|      2|          /*use_coverage_inputs=*/configuration.replay_coverage_inputs,
   62|       |          /*use_crashing_inputs=*/
   63|      2|          configuration.reproduce_findings_as_separate_tests) {}
_ZNK8fuzztest8internal14CorpusDatabase22GetCrashingInputsIfAnyENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
   71|      2|    absl::string_view test_name) const {
   72|      2|  if (!use_crashing_inputs_) return {};
  ------------------
  |  Branch (72:7): [True: 2, False: 0]
  ------------------
   73|      0|  return GetInputs(corpus_path_for_test_binary_, test_name, "crashing");
   74|      2|}
corpus_database.cc:_ZZN8fuzztest8internal14CorpusDatabaseC1ENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEES6_bbENK3$_0clEv:
   44|      2|    : corpus_path_for_test_binary_([=] () -> std::string {
   45|      2|        if (database_path.empty()) return "";
  ------------------
  |  Branch (45:13): [True: 0, False: 2]
  ------------------
   46|      2|        std::string corpus_path_for_test_binary =
   47|      2|            absl::StrCat(database_path, "/", binary_identifier);
   48|      2|        if (!absl::StartsWith(corpus_path_for_test_binary, "/") &&
  ------------------
  |  Branch (48:13): [True: 2, False: 0]
  ------------------
   49|      2|            std::getenv("TEST_SRCDIR")) {
  ------------------
  |  Branch (49:13): [True: 0, False: 2]
  ------------------
   50|      0|          corpus_path_for_test_binary = absl::StrCat(
   51|      0|              std::getenv("TEST_SRCDIR"), "/", corpus_path_for_test_binary);
   52|      0|        }
   53|      2|        return corpus_path_for_test_binary;
   54|      2|      }()),

_ZN8fuzztest8internal20GetExecutionCoverageEv:
   86|      2|ExecutionCoverage* GetExecutionCoverage() {
   87|      2|  return execution_coverage_instance;
   88|      2|}
_ZN8fuzztest8internal14CorpusCoverageC2Em:
  264|      2|CorpusCoverage::CorpusCoverage(size_t map_size) {
  265|      2|  size_t alignment = alignof(Vector);
  266|       |  // Round up to a multiple of alignment.
  267|      2|  map_size += alignment - 1;
  268|      2|  map_size -= map_size % alignment;
  269|       |  // And allocate an extra step to make sure the alignment logic has the
  270|       |  // necessary space.
  271|      2|  map_size += alignment;
  272|      2|  corpus_map_size_ = map_size;
  273|      2|  corpus_map_ = static_cast<uint8_t*>(std::aligned_alloc(alignment, map_size));
  274|      2|  std::fill(corpus_map_, corpus_map_ + corpus_map_size_, 0);
  275|      2|}

_ZNK8fuzztest8internal15AggregateOfImplINSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplIS9_NS0_13ArbitraryImplIcvEEEEEE19ValidateCorpusValueERKSA_:
  166|  5.53k|  absl::Status ValidateCorpusValue(const corpus_type& corpus_value) const {
  167|  5.53k|    absl::Status result = absl::OkStatus();
  168|  5.53k|    ApplyIndex<sizeof...(Inner)>([&](auto... I) {
  169|  5.53k|      (
  170|  5.53k|          [&] {
  171|  5.53k|            if (!result.ok()) return;
  172|  5.53k|            const absl::Status s = std::get<I>(inner_).ValidateCorpusValue(
  173|  5.53k|                std::get<I>(corpus_value));
  174|  5.53k|            result = Prefix(s, "Invalid value in aggregate");
  175|  5.53k|          }(),
  176|  5.53k|          ...);
  177|  5.53k|    });
  178|  5.53k|    return result;
  179|  5.53k|  }
_ZZNK8fuzztest8internal15AggregateOfImplINSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplIS9_NS0_13ArbitraryImplIcvEEEEEE19ValidateCorpusValueERKSA_ENKUlDpT_E_clIJNS2_17integral_constantImLm0EEEEEEDaSK_:
  168|  5.53k|    ApplyIndex<sizeof...(Inner)>([&](auto... I) {
  169|  5.53k|      (
  170|  5.53k|          [&] {
  171|  5.53k|            if (!result.ok()) return;
  172|  5.53k|            const absl::Status s = std::get<I>(inner_).ValidateCorpusValue(
  173|  5.53k|                std::get<I>(corpus_value));
  174|  5.53k|            result = Prefix(s, "Invalid value in aggregate");
  175|  5.53k|          }(),
  176|  5.53k|          ...);
  177|  5.53k|    });
_ZZZNK8fuzztest8internal15AggregateOfImplINSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplIS9_NS0_13ArbitraryImplIcvEEEEEE19ValidateCorpusValueERKSA_ENKUlDpT_E_clIJNS2_17integral_constantImLm0EEEEEEDaSK_ENKUlvE_clEv:
  170|  5.53k|          [&] {
  171|  5.53k|            if (!result.ok()) return;
  ------------------
  |  Branch (171:17): [True: 0, False: 5.53k]
  ------------------
  172|  5.53k|            const absl::Status s = std::get<I>(inner_).ValidateCorpusValue(
  173|  5.53k|                std::get<I>(corpus_value));
  174|  5.53k|            result = Prefix(s, "Invalid value in aggregate");
  175|  5.53k|          }(),
_ZNK8fuzztest8internal15AggregateOfImplINSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplIS9_NS0_13ArbitraryImplIcvEEEEEE11ParseCorpusERKNS0_8IRObjectE:
  150|  7.53k|  std::optional<corpus_type> ParseCorpus(const IRObject& obj) const {
  151|       |    if constexpr (has_custom_corpus_type) {
  152|       |      return ParseWithDomainTuple(inner_, obj);
  153|  7.53k|    } else {
  154|  7.53k|      return obj.ToCorpus<corpus_type>();
  155|  7.53k|    }
  156|  7.53k|  }
_ZNK8fuzztest8internal15AggregateOfImplINSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplIS9_NS0_13ArbitraryImplIcvEEEEEE8GetValueERKSA_:
  108|  5.53k|  value_type GetValue(const corpus_type& value) const {
  109|       |    if constexpr (has_custom_corpus_type) {
  110|       |      if constexpr (DetectBindableFieldCount<value_type>() ==
  111|       |                    DetectBraceInitCount<value_type>()) {
  112|       |        return ApplyIndex<sizeof...(Inner)>([&](auto... I) {
  113|       |          return T{std::get<I>(inner_).GetValue(std::get<I>(value))...};
  114|       |        });
  115|       |      } else {
  116|       |        // Right now the only other possibility is that the bindable field count
  117|       |        // is one less than the brace init field count. In that case, that extra
  118|       |        // field is used to initialize an empty base class. We'll need to update
  119|       |        // this if that ever changes.
  120|       |        return ApplyIndex<sizeof...(Inner)>([&](auto... I) {
  121|       |          return T{{}, std::get<I>(inner_).GetValue(std::get<I>(value))...};
  122|       |        });
  123|       |      }
  124|  5.53k|    } else {
  125|  5.53k|      return value;
  126|  5.53k|    }
  127|  5.53k|  }
_ZN8fuzztest8internal15AggregateOfImplINSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplIS9_NS0_13ArbitraryImplIcvEEEEEEC2ENS2_10in_place_tESF_:
   58|      2|      : inner_(std::move(inner)...) {}

_ZNK8fuzztest8internal13ArbitraryImplIcvE19ValidateCorpusValueERKc:
  189|  23.0M|  absl::Status ValidateCorpusValue(const value_type&) const {
  190|  23.0M|    return absl::OkStatus();  // Nothing to validate.
  191|  23.0M|  }

_ZNK8fuzztest8internal19ContainerOfImplBaseINS0_23SequenceContainerOfImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_13ArbitraryImplIcvEEEEE19ValidateCorpusValueERKS9_:
  319|  5.53k|  absl::Status ValidateCorpusValue(const corpus_type& corpus_value) const {
  320|       |    // Check size.
  321|  5.53k|    if (corpus_value.size() < min_size()) {
  ------------------
  |  Branch (321:9): [True: 0, False: 5.53k]
  ------------------
  322|      0|      return absl::InvalidArgumentError(absl::StrCat(
  323|      0|          "Invalid size: ", corpus_value.size(), ". Min size: ", min_size()));
  324|      0|    }
  325|  5.53k|    if (corpus_value.size() > max_size()) {
  ------------------
  |  Branch (325:9): [True: 0, False: 5.53k]
  ------------------
  326|      0|      return absl::InvalidArgumentError(absl::StrCat(
  327|      0|          "Invalid size: ", corpus_value.size(), ". Max size: ", max_size()));
  328|      0|    }
  329|       |    // Check elements.
  330|  5.53k|    int i = 0;
  331|  23.0M|    for (const auto& elem : corpus_value) {
  ------------------
  |  Branch (331:27): [True: 23.0M, False: 5.53k]
  ------------------
  332|  23.0M|      const absl::Status s = inner_.ValidateCorpusValue(elem);
  333|  23.0M|      if (!s.ok()) {
  ------------------
  |  Branch (333:11): [True: 0, False: 23.0M]
  ------------------
  334|      0|        return Prefix(s,
  335|      0|                      absl::StrCat("Invalid value in container at index ", i));
  336|      0|      }
  337|  23.0M|      i++;
  338|  23.0M|    }
  339|  5.53k|    return absl::OkStatus();
  340|  5.53k|  }
_ZNK8fuzztest8internal19ContainerOfImplBaseINS0_23SequenceContainerOfImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_13ArbitraryImplIcvEEEEE8min_sizeEv:
  371|  5.53k|  size_t min_size() const { return min_size_; }
_ZNK8fuzztest8internal19ContainerOfImplBaseINS0_23SequenceContainerOfImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_13ArbitraryImplIcvEEEEE8max_sizeEv:
  372|  5.53k|  size_t max_size() const {
  373|  5.53k|    return max_size_.value_or(std::max(min_size_, kDefaultContainerMaxSize));
  374|  5.53k|  }
_ZN8fuzztest8internal19ContainerOfImplBaseINS0_23SequenceContainerOfImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_13ArbitraryImplIcvEEEEE4SelfEv:
  377|      2|  Derived& Self() { return static_cast<Derived&>(*this); }
_ZN8fuzztest8internal23SequenceContainerOfImplINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS0_13ArbitraryImplIcvEEEC2Ev:
  534|      2|  SequenceContainerOfImpl() = default;
_ZN8fuzztest8internal19ContainerOfImplBaseINS0_23SequenceContainerOfImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_13ArbitraryImplIcvEEEEEC2Ev:
  112|      2|  ContainerOfImplBase() = default;
_ZN8fuzztest8internal19ContainerOfImplBaseINS0_23SequenceContainerOfImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_13ArbitraryImplIcvEEEEE11WithMaxSizeEm:
  224|      2|  Derived& WithMaxSize(size_t s) {
  225|      2|    FUZZTEST_INTERNAL_CHECK_PRECONDITION(
  ------------------
  |  |   42|      2|  ((P) ? (void)0                                     \
  |  |  ------------------
  |  |  |  Branch (42:4): [True: 2, False: 0]
  |  |  ------------------
  |  |   43|      2|       : ::fuzztest::internal::Abort(                \
  |  |   44|      0|             __FILE__, __LINE__,                     \
  |  |   45|      0|             absl::StrCat("Failed precondition (", #P, "): ", __VA_ARGS__)))
  ------------------
  226|      2|        min_size_ <= s, "Maximal size ", s,
  227|      2|        " cannot be smaller than minimal size ", min_size_);
  228|      2|    max_size_ = s;
  229|      2|    return Self();
  230|      2|  }

_ZN8fuzztest6DomainINSt3__15tupleIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEEEC2INS_8internal15AggregateOfImplIS9_LNSC_23RequireCustomCorpusTypeE0EJNSC_23SequenceContainerOfImplIS8_NSC_13ArbitraryImplIcvEEEEEEES9_EEONS_18domain_implementor10DomainBaseIT_S9_T0_EE:
  108|      2|      : inner_(std::make_unique<internal::DomainModel<Inner>>(
  109|      2|            static_cast<Inner&&>(inner))) {}
_ZN8fuzztest6DomainINSt3__15tupleIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEEEC2ERKSA_:
  111|     12|  Domain(const Domain& other) { *this = other; }
_ZN8fuzztest6DomainINSt3__15tupleIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEEEaSERKSA_:
  112|     12|  Domain& operator=(const Domain& other) {
  113|     12|    inner_ = other.inner_->TypedClone();
  114|     12|    return *this;
  115|     12|  }
_ZN8fuzztest13UntypedDomainC2INSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEERKNS_6DomainIT_EE:
  301|      2|      : inner_(domain.inner_->UntypedClone()) {}
_ZNK8fuzztest13UntypedDomain8GetValueERKNS_8internal11CopyableAnyE:
  310|  5.53k|  value_type GetValue(const corpus_type& corpus_value) const {
  311|  5.53k|    return inner_->UntypedGetValue(corpus_value);
  312|  5.53k|  }
_ZNK8fuzztest13UntypedDomain11ParseCorpusERKNS_8internal8IRObjectE:
  314|  7.53k|  std::optional<corpus_type> ParseCorpus(const internal::IRObject& obj) const {
  315|  7.53k|    return inner_->UntypedParseCorpus(obj);
  316|  7.53k|  }
_ZNK8fuzztest13UntypedDomain19ValidateCorpusValueERKNS_8internal11CopyableAnyE:
  322|  5.53k|  absl::Status ValidateCorpusValue(const corpus_type& corpus_value) const {
  323|  5.53k|    return inner_->UntypedValidateCorpusValue(corpus_value);
  324|  5.53k|  }

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

_ZN8fuzztest8internal11DomainModelINS0_15AggregateOfImplINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplISA_NS0_13ArbitraryImplIcvEEEEEEEEC2EOSH_:
  126|      2|  explicit DomainModel(D&& domain) : domain_(std::forward<D>(domain)) {}
_ZN8fuzztest8internal20UntypedDomainConceptD2Ev:
   55|     10|  virtual ~UntypedDomainConcept() = default;
_ZNK8fuzztest8internal18TypedDomainConceptINSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEE12UntypedCloneEv:
  104|      2|  std::unique_ptr<UntypedDomainConcept> UntypedClone() const final {
  105|      2|    return TypedClone();
  106|      2|  }
_ZNK8fuzztest8internal11DomainModelINS0_15AggregateOfImplINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplISA_NS0_13ArbitraryImplIcvEEEEEEEE18UntypedParseCorpusERKNS0_8IRObjectE:
  165|  7.53k|      const IRObject& obj) const final {
  166|  7.53k|    if (auto res = domain_.ParseCorpus(obj)) {
  ------------------
  |  Branch (166:14): [True: 5.53k, False: 2.00k]
  ------------------
  167|  5.53k|      return GenericDomainCorpusType(std::in_place_type<CorpusType>,
  168|  5.53k|                                     *std::move(res));
  169|  5.53k|    } else {
  170|  2.00k|      return std::nullopt;
  171|  2.00k|    }
  172|  7.53k|  }
_ZNK8fuzztest8internal11DomainModelINS0_15AggregateOfImplINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplISA_NS0_13ArbitraryImplIcvEEEEEEEE26UntypedValidateCorpusValueERKNS0_11CopyableAnyE:
  180|  5.53k|      const GenericDomainCorpusType& corpus_value) const final {
  181|  5.53k|    return domain_.ValidateCorpusValue(corpus_value.GetAs<CorpusType>());
  182|  5.53k|  }
_ZNK8fuzztest8internal18TypedDomainConceptINSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEE15UntypedGetValueERKNS0_11CopyableAnyE:
  109|  5.53k|      const GenericDomainCorpusType& v) const final {
  110|  5.53k|    return GenericDomainValueType(std::in_place_type<ValueType>,
  111|  5.53k|                                  TypedGetValue(v));
  112|  5.53k|  }
_ZNK8fuzztest8internal11DomainModelINS0_15AggregateOfImplINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplISA_NS0_13ArbitraryImplIcvEEEEEEEE10TypedCloneEv:
  128|     14|  std::unique_ptr<TypedDomainConcept<ValueType>> TypedClone() const final {
  129|     14|    return std::make_unique<DomainModel>(*this);
  130|     14|  }
_ZNK8fuzztest8internal11DomainModelINS0_15AggregateOfImplINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplISA_NS0_13ArbitraryImplIcvEEEEEEEE13TypedGetValueERKNS0_11CopyableAnyE:
  150|  5.53k|  ValueType TypedGetValue(const GenericDomainCorpusType& v) const final {
  151|  5.53k|    return domain_.GetValue(v.GetAs<CorpusType>());
  152|  5.53k|  }

_ZN8fuzztest8internal20UntypedFixtureDriver13SetUpFuzzTestEv:
   20|      2|void UntypedFixtureDriver::SetUpFuzzTest() {}
_ZN8fuzztest8internal20UntypedFixtureDriver14SetUpIterationEv:
   21|  5.53k|void UntypedFixtureDriver::SetUpIteration() {}
_ZN8fuzztest8internal20UntypedFixtureDriver17TearDownIterationEv:
   22|  5.53k|void UntypedFixtureDriver::TearDownIteration() {}

_ZN8fuzztest8internal13FixtureDriverINS_6DomainINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEENS0_9NoFixtureEPFvNS3_17basic_string_viewIcS7_EEEPvEC2ESH_SC_NS3_6vectorINS0_11CopyableAnyENS8_ISL_EEEERKSI_:
  287|      2|      : FixtureDriver::TypedFixtureDriver(std::move(domain), std::move(seeds),
  288|      2|                                          seed_provider),
  289|      2|        target_function_(target_function) {}
_ZN8fuzztest8internal18TypedFixtureDriverINSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEPvEC2ENS_6DomainISA_EENS2_6vectorINS0_11CopyableAnyENS7_ISG_EEEERKSB_:
  104|      2|      : domain_(std::move(domain)),
  105|      2|        seeds_(std::move(seeds)),
  106|      2|        seed_provider_(seed_provider) {}
_ZNK8fuzztest8internal13FixtureDriverINS_6DomainINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEENS0_9NoFixtureEPFvNS3_17basic_string_viewIcS7_EEEPvE4TestEONS0_11MoveOnlyAnyE:
  291|  5.53k|  void Test(MoveOnlyAny&& args_untyped) const override {
  292|  5.53k|    std::apply(
  293|  5.53k|        [&](auto&&... args) {
  294|  5.53k|          target_function_(ForceVectorForStringView<Args>(std::move(args))...);
  295|  5.53k|        },
  296|  5.53k|        args_untyped.GetAs<value_type_t<DomainT>>());
  297|  5.53k|  }
_ZZNK8fuzztest8internal13FixtureDriverINS_6DomainINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEENS0_9NoFixtureEPFvNS3_17basic_string_viewIcS7_EEEPvE4TestEONS0_11MoveOnlyAnyEENKUlDpOT_E_clIJRSA_EEEDaSO_:
  293|  5.53k|        [&](auto&&... args) {
  294|  5.53k|          target_function_(ForceVectorForStringView<Args>(std::move(args))...);
  295|  5.53k|        },
_ZN8fuzztest8internal24ForceVectorForStringViewINSt3__117basic_string_viewIcNS2_11char_traitsIcEEEENS2_12basic_stringIcS5_NS2_9allocatorIcEEEEEEDcOT0_:
  181|  5.53k|decltype(auto) ForceVectorForStringView(Src&& src) {
  182|       |  // We only do this when Src is a std::string. If it's a string view it is
  183|       |  // handled by the string view domain itself.
  184|       |  if constexpr (std::is_same_v<void(std::decay_t<Dest>, std::decay_t<Src>),
  185|  5.53k|                               void(std::string_view, std::string)>) {
  186|  5.53k|    return ForceVector{std::vector<char>(src.begin(), src.end())};
  187|       |  } else {
  188|       |    return std::forward<Src>(src);
  189|       |  }
  190|  5.53k|}
_ZNK8fuzztest8internal11ForceVectorcvNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEEv:
  176|  5.53k|  operator std::string_view() const { return {value.data(), value.size()}; }
_ZNK8fuzztest8internal18TypedFixtureDriverINSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEPvE10GetDomainsEv:
  120|      2|  UntypedDomain GetDomains() const final { return domain_; }

_ZN8fuzztest8internal30RegisterFuzzTestsAsGoogleTestsEPiPPPcRKNS0_13ConfigurationE:
   64|      2|                                    const Configuration& configuration) {
   65|      2|  ::fuzztest::internal::ForEachTest([&](auto& test) {
   66|      2|    if (test.uses_fixture()) {
   67|      2|      RegisterTests<::fuzztest::internal::GTest_TestAdaptor>(argc, argv, test,
   68|      2|                                                             configuration);
   69|      2|    } else {
   70|      2|      RegisterTests<::testing::Test>(argc, argv, test, configuration);
   71|      2|    }
   72|      2|  });
   73|       |
   74|      2|  ::testing::UnitTest::GetInstance()->listeners().Append(
   75|      2|      new ::fuzztest::internal::GTest_EventListener<
   76|      2|          ::testing::EmptyTestEventListener, ::testing::TestPartResult>());
   77|      2|}
_ZN8fuzztest8internal28FuzzTestListingModeValidator26RegisterGoogleTestListenerEv:
  133|      2|void FuzzTestListingModeValidator::RegisterGoogleTestListener() {
  134|      2|  testing::UnitTest::GetInstance()->listeners().Append(
  135|      2|      new ValidatorProxyListener(this));
  136|      2|}
_ZN8fuzztest8internal44SetFuzzTestListingModeValidatorForGoogleTestEb:
  138|      2|void SetFuzzTestListingModeValidatorForGoogleTest(bool listing_mode) {
  139|      2|  FuzzTestListingModeValidator::GetInstance().set_listing_mode(listing_mode);
  140|      2|}
_ZN8fuzztest8internal22ValidatorProxyListenerC2EPNS0_28FuzzTestListingModeValidatorE:
  128|      2|      : validator_(validator) {}
_ZN8fuzztest8internal22ValidatorProxyListener18OnTestProgramStartERKN7testing8UnitTestE:
  120|      2|  void OnTestProgramStart(const testing::UnitTest& unit_test) override {
  121|      2|    validator_->Run();
  122|      2|  }
_ZN8fuzztest8internal28FuzzTestListingModeValidator3RunEv:
   83|      2|  void Run() {
   84|      2|    if (listing_mode_) {
  ------------------
  |  Branch (84:9): [True: 0, False: 2]
  ------------------
   85|       |      // Since InitFuzzTest calls std::exit after listing the fuzz tests, we
   86|       |      // would not reach here if InitFuzzTest is called before.
   87|       |      absl::FPrintF(stderr,
   88|      0|                    "[!] --" FUZZTEST_FLAG_PREFIX
   89|      0|                    "list_fuzz_tests not handled by InitFuzzTest - fuzz tests "
   90|      0|                    "would not be listed even if defined.\n");
   91|      0|      std::exit(0);
   92|      0|    }
   93|      2|  }
_ZN8fuzztest8internal28FuzzTestListingModeValidator11GetInstanceEv:
   97|      2|  static FuzzTestListingModeValidator& GetInstance() {
   98|      2|    static auto* instance = [] {
   99|      2|      static_assert(
  100|      2|          std::is_trivially_destructible_v<FuzzTestListingModeValidator>);
  101|      2|      static FuzzTestListingModeValidator instance;
  102|      2|      instance.RegisterGoogleTestListener();
  103|      2|      return &instance;
  104|      2|    }();
  105|      2|    return *instance;
  106|      2|  }
_ZZN8fuzztest8internal28FuzzTestListingModeValidator11GetInstanceEvENKUlvE_clEv:
   98|      2|    static auto* instance = [] {
   99|      2|      static_assert(
  100|      2|          std::is_trivially_destructible_v<FuzzTestListingModeValidator>);
  101|      2|      static FuzzTestListingModeValidator instance;
  102|      2|      instance.RegisterGoogleTestListener();
  103|      2|      return &instance;
  104|      2|    }();
_ZN8fuzztest8internal28FuzzTestListingModeValidator16set_listing_modeEb:
   95|      2|  void set_listing_mode(bool listing_mode) { listing_mode_ = listing_mode; }
googletest_adaptor.cc:_ZZN8fuzztest8internal30RegisterFuzzTestsAsGoogleTestsEPiPPPcRKNS0_13ConfigurationEENK3$_0clINS0_8FuzzTestEEEDaRT_:
   65|      2|  ::fuzztest::internal::ForEachTest([&](auto& test) {
   66|      2|    if (test.uses_fixture()) {
  ------------------
  |  Branch (66:9): [True: 0, False: 2]
  ------------------
   67|      0|      RegisterTests<::fuzztest::internal::GTest_TestAdaptor>(argc, argv, test,
   68|      0|                                                             configuration);
   69|      2|    } else {
   70|      2|      RegisterTests<::testing::Test>(argc, argv, test, configuration);
   71|      2|    }
   72|      2|  });
googletest_adaptor.cc:_ZN8fuzztest8internal12_GLOBAL__N_113RegisterTestsIN7testing4TestEEEvPiPPPcRNS0_8FuzzTestERKNS0_13ConfigurationE:
   55|      2|                   const Configuration& configuration) {
   56|      2|  RegisterFuzzTestAsGTest<T>(argc, argv, test, configuration);
   57|      2|  RegisterSeparateRegressionTestForEachCrashingInput<T>(argc, argv, test,
   58|      2|                                                        configuration);
   59|      2|}
googletest_adaptor.cc:_ZN8fuzztest8internal12_GLOBAL__N_123RegisterFuzzTestAsGTestIN7testing4TestEEEvPiPPPcRNS0_8FuzzTestERKNS0_13ConfigurationENSt3__117basic_string_viewIcNSE_11char_traitsIcEEEE:
   25|      2|                             absl::string_view suffix = "") {
   26|      2|  auto fixture_factory = [argc, argv, &test,
   27|      2|                          configuration = configuration]() -> T* {
   28|      2|    return new ::fuzztest::internal::GTest_TestAdaptor(test, argc, argv,
   29|      2|                                                       configuration);
   30|      2|  };
   31|      2|  const std::string test_name_with_suffix =
   32|      2|      absl::StrCat(test.test_name(), suffix);
   33|      2|  ::testing::RegisterTest(
   34|      2|      test.suite_name().c_str(), test_name_with_suffix.c_str(), nullptr,
   35|      2|      nullptr, test.file().c_str(), test.line(), std::move(fixture_factory));
   36|      2|}
googletest_adaptor.cc:_ZZN8fuzztest8internal12_GLOBAL__N_123RegisterFuzzTestAsGTestIN7testing4TestEEEvPiPPPcRNS0_8FuzzTestERKNS0_13ConfigurationENSt3__117basic_string_viewIcNSE_11char_traitsIcEEEEENKUlvE_clEv:
   27|      2|                          configuration = configuration]() -> T* {
   28|      2|    return new ::fuzztest::internal::GTest_TestAdaptor(test, argc, argv,
   29|      2|                                                       configuration);
   30|      2|  };
googletest_adaptor.cc:_ZN8fuzztest8internal12_GLOBAL__N_150RegisterSeparateRegressionTestForEachCrashingInputIN7testing4TestEEEvPiPPPcRNS0_8FuzzTestERKNS0_13ConfigurationE:
   41|      2|    const Configuration& configuration) {
   42|      2|  CorpusDatabase corpus_database(configuration);
   43|      2|  for (const std::string& input :
  ------------------
  |  Branch (43:33): [True: 0, False: 2]
  ------------------
   44|      2|       corpus_database.GetCrashingInputsIfAny(test.full_name())) {
   45|      0|    Configuration updated_configuration = configuration;
   46|      0|    updated_configuration.crashing_input_to_reproduce = input;
   47|      0|    const std::string suffix =
   48|      0|        absl::StrCat("/Regression/", std::string(Basename(input)));
   49|      0|    RegisterFuzzTestAsGTest<T>(argc, argv, test, updated_configuration, suffix);
   50|      0|  }
   51|      2|}

_ZN8fuzztest8internal17GTest_TestAdaptorC2ERNS0_8FuzzTestEPiPPPcNS0_13ConfigurationE:
   33|      2|      : test_(test),
   34|      2|        argc_(argc),
   35|      2|        argv_(argv),
   36|      2|        configuration_(std::move(configuration)) {}
_ZN8fuzztest8internal17GTest_TestAdaptor8TestBodyEv:
   38|      2|  void TestBody() override {
   39|      2|    auto test = test_.make();
   40|      2|    if (Runtime::instance().run_mode() == RunMode::kUnitTest) {
  ------------------
  |  Branch (40:9): [True: 0, False: 2]
  ------------------
   41|       |      // In "bug reproduction" mode, sometimes we need to reproduce multiple
   42|       |      // bugs, i.e., run multiple tests that lead to a crash.
   43|      0|      bool needs_subprocess = false;
   44|      0|#ifdef GTEST_HAS_DEATH_TEST
   45|      0|      needs_subprocess =
   46|      0|          configuration_.crashing_input_to_reproduce.has_value() &&
  ------------------
  |  Branch (46:11): [True: 0, False: 0]
  ------------------
   47|      0|          (
   48|       |              // When only a single test runs, it's okay to crash the process on
   49|       |              // error, as we don't need to run other tests.
   50|      0|              testing::UnitTest::GetInstance()->test_to_run_count() > 1 ||
  ------------------
  |  Branch (50:15): [True: 0, False: 0]
  ------------------
   51|       |              // EXPECT_EXIT is required in the death-test subprocess, but in
   52|       |              // the subprocess there's only one test to run.
   53|      0|              testing::internal::InDeathTestChild());
  ------------------
  |  Branch (53:15): [True: 0, False: 0]
  ------------------
   54|      0|#endif
   55|      0|      if (needs_subprocess) {
  ------------------
  |  Branch (55:11): [True: 0, False: 0]
  ------------------
   56|      0|        configuration_.preprocess_crash_reproducing = [] {
   57|       |          // EXPECT_EXIT disables event forwarding in gtest and as a result,
   58|       |          // EXPECT/ASSERT-s are disabled. Here, we overwrite this option.
   59|      0|          testing::UnitTest::GetInstance()->listeners().SuppressEventForwarding(
   60|      0|              false);
   61|      0|        };
   62|       |        // `RunInUnitTestMode` is supposed to fail and we wish to show the
   63|       |        // failure to the user. Directly running the test would terminate the
   64|       |        // process and using `EXPECT_DEATH` causes the test to pass. We use
   65|       |        // `EXPECT_EXIT` so that the test exit unsuccessfully, meaning that the
   66|       |        // test below fails without terminating the process.
   67|      0|#ifdef GTEST_HAS_DEATH_TEST
   68|      0|        EXPECT_EXIT(
  ------------------
  |  Branch (68:9): [True: 0, False: 0]
  |  Branch (68:9): [True: 0, False: 0]
  |  Branch (68:9): [True: 0, False: 0]
  |  Branch (68:9): [True: 0, False: 0]
  |  Branch (68:9): [True: 0, False: 0]
  |  Branch (68:9): [True: 0, False: 0]
  |  Branch (68:9): [True: 0, False: 0]
  |  Branch (68:9): [True: 0, False: 0]
  |  Branch (68:9): [True: 0, False: 0]
  |  Branch (68:9): [True: 0, False: 0]
  ------------------
   69|      0|            (test->RunInUnitTestMode(configuration_),
   70|      0|             void(
   71|      0|                 R"( FuzzTest failure! Please see 'actual message' below for the crash report. )"),
   72|      0|             std::exit(0)),
   73|      0|            ::testing::ExitedWithCode(0), "");
   74|       |#else
   75|       |        EXPECT_TRUE(false) << "Death test is not supported.";
   76|       |#endif
   77|      0|      } else {
   78|      0|        test->RunInUnitTestMode(configuration_);
   79|      0|      }
   80|      2|    } else {
   81|       |      // TODO(b/245753736): Consider using `tolerate_failure` when FuzzTest can
   82|       |      // tolerate crashes in fuzzing mode.
   83|      6|      ASSERT_EQ(0, test->RunInFuzzingMode(argc_, argv_, configuration_))
  ------------------
  |  Branch (83:7): [True: 0, False: 2]
  |  Branch (83:7): [True: 0, False: 2]
  |  Branch (83:7): [True: 2, False: 0]
  ------------------
   84|      6|          << "Fuzzing failure.";
   85|      2|    }
   86|      2|  }

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

_ZN8fuzztest8internal9GetStderrEv:
  125|  3.53k|FILE* GetStderr() {
  126|  3.53k|  absl::MutexLock lock(&stderr_file_guard_);
  127|  3.53k|  if (!stderr_file_) {
  ------------------
  |  Branch (127:7): [True: 2, False: 3.53k]
  ------------------
  128|       |    stderr_file_ = stderr;
  129|      2|  }
  130|  3.53k|  return stderr_file_;
  131|  3.53k|}

_ZN8fuzztest8internal10ApplyIndexILm1EZNKS0_15AggregateOfImplINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplISA_NS0_13ArbitraryImplIcvEEEEEE19ValidateCorpusValueERKSB_EUlDpT_E_EEDaT0_:
   54|  5.53k|constexpr auto ApplyIndex(F f) {
   55|  5.53k|  return ApplyIndexImpl(f, std::make_index_sequence<N>{});
   56|  5.53k|}
_ZN8fuzztest8internal14ApplyIndexImplIJLm0EEZNKS0_15AggregateOfImplINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplISA_NS0_13ArbitraryImplIcvEEEEEE19ValidateCorpusValueERKSB_EUlDpT_E_EEDaT0_NS3_16integer_sequenceImJXspT_EEEE:
   39|  5.53k|constexpr auto ApplyIndexImpl(F f, std::index_sequence<I...>) {
   40|  5.53k|  return f(std::integral_constant<size_t, I>{}...);
   41|  5.53k|}
_ZN8fuzztest8internal10ApplyIndexILm1EZNKS0_8IRObject8ToCorpusINSt3__15tupleIJNS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEEEENS4_8optionalIT_EEvEUlDpT_E_EEDaT0_:
   54|  5.54k|constexpr auto ApplyIndex(F f) {
   55|  5.54k|  return ApplyIndexImpl(f, std::make_index_sequence<N>{});
   56|  5.54k|}
_ZN8fuzztest8internal14ApplyIndexImplIJLm0EEZNKS0_8IRObject8ToCorpusINSt3__15tupleIJNS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEEEENS4_8optionalIT_EEvEUlDpT_E_EEDaT0_NS4_16integer_sequenceImJXspT_EEEE:
   39|  5.54k|constexpr auto ApplyIndexImpl(F f, std::index_sequence<I...>) {
   40|  5.54k|  return f(std::integral_constant<size_t, I>{}...);
   41|  5.54k|}
_ZN8fuzztest8internal11CheckIsSameINSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEESA_EEvv:
  806|      4|constexpr void CheckIsSame() {
  807|      4|  static_assert(std::is_same_v<T, U>);
  808|      4|}
_ZN8fuzztest8internal11CheckIsSameINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEES8_EEvv:
  806|      4|constexpr void CheckIsSame() {
  807|      4|  static_assert(std::is_same_v<T, U>);
  808|      4|}
_ZN8fuzztest8internal11CheckIsSameIccEEvv:
  806|      4|constexpr void CheckIsSame() {
  807|      4|  static_assert(std::is_same_v<T, U>);
  808|      4|}

_ZN8fuzztest15GetRegistrationIPFvNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEEEEDaNS1_12basic_stringIcS4_NS1_9allocatorIcEEEESB_SB_iT_:
  339|      2|                     TargetFunction target_function) {
  340|      2|  return ::fuzztest::internal::Registration<::fuzztest::internal::NoFixture,
  341|      2|                                            TargetFunction>(
  342|      2|      ::fuzztest::internal::BasicTestInfo{std::move(suite_name),
  343|      2|                                          std::move(test_name), std::move(file),
  344|      2|                                          line, false},
  345|      2|      target_function);
  346|      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_:
  294|      2|      : Base(std::move(base)),
  295|      2|        test_info_(std::move(info)),
  296|      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:
  272|      2|  std::vector<GenericDomainCorpusType> seeds() const {
  273|       |    if constexpr (Base::kHasSeeds) {
  274|       |      return this->seeds_;
  275|      2|    } else {
  276|      2|      return {};
  277|      2|    }
  278|      2|  }
_ZN8fuzztest8internal12RegistrationINS0_9NoFixtureEPFvNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEENS0_27RegistrationWithDomainsBaseIJNS3_12basic_stringIcS6_NS3_9allocatorIcEEEEEEEPvE13seed_providerEv:
  280|      2|  SeedProvider seed_provider() {
  281|       |    if constexpr (Base::kHasSeedProvider) {
  282|       |      return std::move(this->seed_provider_);
  283|      2|    } else {
  284|      2|      return {};
  285|      2|    }
  286|      2|  }

_ZN8fuzztest8internal11ForEachTestEN4absl12lts_2024011611FunctionRefIFvRNS0_8FuzzTestEEEE:
   56|      6|void ForEachTest(absl::FunctionRef<void(FuzzTest&)> func) {
   57|      6|  for (auto& t : Regs()) func(t);
  ------------------
  |  Branch (57:16): [True: 6, False: 6]
  ------------------
   58|      6|}
_ZN8fuzztest8internal12RegisterImplENS0_13BasicTestInfoEN4absl12lts_2024011612AnyInvocableIKFNSt3__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|      8|auto& Regs() {
   31|       |  // We use a deque because FuzzTest is not copyable/movable.
   32|      8|  static auto* reg = new std::deque<FuzzTest>;
   33|      8|  return *reg;
   34|      8|}

_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_2024011612AnyInvocableIKFNS4_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_2024011612AnyInvocableIKFNS4_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|    };

_ZN8fuzztest8internal7Runtime19CheckWatchdogLimitsEv:
  258|  5.53k|void Runtime::CheckWatchdogLimits() {
  259|       |  // Centipede runner has its own watchdog.
  260|  5.53k|#ifndef FUZZTEST_USE_CENTIPEDE
  261|  5.53k|  if (current_configuration_ == nullptr) return;
  ------------------
  |  Branch (261:7): [True: 5.53k, False: 0]
  ------------------
  262|      0|  const absl::Duration run_duration =
  263|      0|      clock_fn_() - current_iteration_start_time_;
  264|      0|  if (current_configuration_->time_limit_per_input > absl::ZeroDuration() &&
  ------------------
  |  Branch (264:7): [True: 0, False: 0]
  ------------------
  265|      0|      run_duration > current_configuration_->time_limit_per_input) {
  ------------------
  |  Branch (265:7): [True: 0, False: 0]
  ------------------
  266|      0|    absl::FPrintF(
  267|      0|        GetStderr(), "[!] Per-input timeout exceeded: %s > %s - aborting\n",
  268|      0|        absl::FormatDuration(run_duration),
  269|      0|        absl::FormatDuration(current_configuration_->time_limit_per_input));
  270|      0|    std::abort();
  271|      0|  }
  272|      0|  const size_t rss_usage = GetPeakRSSBytes();
  273|      0|  if (current_configuration_->rss_limit > 0 &&
  ------------------
  |  Branch (273:7): [True: 0, False: 0]
  ------------------
  274|      0|      rss_usage > current_configuration_->rss_limit) {
  ------------------
  |  Branch (274:7): [True: 0, False: 0]
  ------------------
  275|      0|    absl::FPrintF(GetStderr(),
  276|      0|                  "[!] RSS limit exceeded: %zu > %zu (bytes) - aborting\n",
  277|      0|                  rss_usage, current_configuration_->rss_limit);
  278|      0|    std::abort();
  279|      0|  }
  280|      0|#endif
  281|      0|}
_ZN8fuzztest8internal7Runtime18OnTestIterationEndEv:
  283|  5.53k|void Runtime::OnTestIterationEnd() {
  284|  5.53k|  test_iteration_started_ = false;
  285|  5.53k|  while (watchdog_spinlock_.test_and_set()) std::this_thread::yield();
  ------------------
  |  Branch (285:10): [True: 0, False: 5.53k]
  ------------------
  286|  5.53k|  CheckWatchdogLimits();
  287|  5.53k|  watchdog_spinlock_.clear();
  288|  5.53k|}
_ZN8fuzztest8internal21InstallSignalHandlersEP8_IO_FILE:
  397|      2|void InstallSignalHandlers(FILE* out) {
  398|      2|  if (signal_out != nullptr) {
  ------------------
  |  Branch (398:7): [True: 0, False: 2]
  ------------------
  399|       |    // Already installed. Noop.
  400|      0|    return;
  401|      0|  }
  402|      2|  signal_out = out;
  403|       |
  404|       |#if defined(ADDRESS_SANITIZER) || defined(MEMORY_SANITIZER)
  405|       |  // An ASan failure might come without a signal.
  406|       |  // Eg a divide by zero is intercepted by ASan and it terminates the process
  407|       |  // after printing its output. This handler helps us print our output
  408|       |  // afterwards.
  409|       |  __sanitizer_set_death_callback(
  410|       |      [](auto...) { Runtime::instance().PrintReport(&signal_out_sink); });
  411|       |#endif
  412|       |
  413|     12|  for (OldSignalHandler& h : crash_handlers) {
  ------------------
  |  Branch (413:28): [True: 12, False: 2]
  ------------------
  414|     12|    SetNewSigAction(h.signum, &HandleCrash, &h.action);
  415|     12|  }
  416|       |
  417|      6|  for (OldSignalHandler& h : termination_handlers) {
  ------------------
  |  Branch (417:28): [True: 6, False: 2]
  ------------------
  418|      6|    SetNewSigAction(h.signum, &HandleTermination, nullptr);
  419|      6|  }
  420|      2|}
_ZN8fuzztest8internal18FuzzTestFuzzerImplC2ERKNS0_8FuzzTestENSt3__110unique_ptrINS0_20UntypedFixtureDriverENS5_14default_deleteIS7_EEEE:
  443|      2|    : test_(test),
  444|      2|      fixture_driver_(std::move(fixture_driver)),
  445|      2|      params_domain_(fixture_driver_->GetDomains()),
  446|      2|      execution_coverage_(internal::GetExecutionCoverage()),
  447|      2|      corpus_coverage_(execution_coverage_ != nullptr
  ------------------
  |  Branch (447:24): [True: 0, False: 2]
  ------------------
  448|      2|                           ? execution_coverage_->GetCounterMap().size()
  449|      2|                           : 0) {
  450|      2|  FUZZTEST_INTERNAL_CHECK_PRECONDITION(fixture_driver_ != nullptr,
  ------------------
  |  |   42|      2|  ((P) ? (void)0                                     \
  |  |  ------------------
  |  |  |  Branch (42:4): [True: 2, False: 0]
  |  |  ------------------
  |  |   43|      2|       : ::fuzztest::internal::Abort(                \
  |  |   44|      0|             __FILE__, __LINE__,                     \
  |  |   45|      0|             absl::StrCat("Failed precondition (", #P, "): ", __VA_ARGS__)))
  ------------------
  451|      2|                                       "Invalid fixture driver!");
  452|      2|  stats_.start_time = absl::Now();
  453|      2|  const char* corpus_out_dir_chars = getenv("FUZZTEST_TESTSUITE_OUT_DIR");
  454|      2|  if (corpus_out_dir_chars) corpus_out_dir_ = corpus_out_dir_chars;
  ------------------
  |  Branch (454:7): [True: 0, False: 2]
  ------------------
  455|       |
  456|      2|  std::vector<double> weights = {100.};
  457|      2|  corpus_distribution_ =
  458|      2|      absl::discrete_distribution<>(weights.begin(), weights.end());
  459|      2|}
_ZN8fuzztest8internal18FuzzTestFuzzerImpl8TryParseENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
  466|  9.06k|    absl::string_view data) {
  467|  9.06k|  auto ir_value = IRObject::FromString(data);
  468|  9.06k|  if (!ir_value) {
  ------------------
  |  Branch (468:7): [True: 1.52k, False: 7.53k]
  ------------------
  469|  1.52k|    absl::FPrintF(GetStderr(), "[!] Unexpected file format.\n");
  470|  1.52k|    return std::nullopt;
  471|  1.52k|  }
  472|  7.53k|  auto corpus_value = params_domain_.ParseCorpus(*ir_value);
  473|  7.53k|  if (!corpus_value) {
  ------------------
  |  Branch (473:7): [True: 2.00k, False: 5.53k]
  ------------------
  474|  2.00k|    absl::FPrintF(GetStderr(), "[!] Unexpected intermediate representation.\n");
  475|  2.00k|    return std::nullopt;
  476|  2.00k|  }
  477|       |
  478|  5.53k|  absl::Status is_valid = params_domain_.ValidateCorpusValue(*corpus_value);
  479|  5.53k|  if (!is_valid.ok()) {
  ------------------
  |  Branch (479:7): [True: 0, False: 5.53k]
  ------------------
  480|      0|    absl::FPrintF(GetStderr(), "[!] Invalid corpus value: %s\n",
  481|      0|                  is_valid.ToString());
  482|      0|    return std::nullopt;
  483|      0|  }
  484|  5.53k|  return corpus_value;
  485|  5.53k|}
_ZN8fuzztest8internal18FuzzTestFuzzerImpl10ShouldStopEv:
  775|  9.06k|bool FuzzTestFuzzerImpl::ShouldStop() {
  776|  9.06k|  if (runs_limit_.has_value() && stats_.runs >= *runs_limit_) return true;
  ------------------
  |  Branch (776:7): [True: 0, False: 9.06k]
  |  Branch (776:34): [True: 0, False: 0]
  ------------------
  777|  9.06k|  if (time_limit_ != absl::InfiniteFuture() && absl::Now() > time_limit_)
  ------------------
  |  Branch (777:7): [True: 0, False: 9.06k]
  |  Branch (777:48): [True: 0, False: 0]
  ------------------
  778|      0|    return true;
  779|  9.06k|  return runtime_.termination_requested();
  780|  9.06k|}
_ZN8fuzztest8internal18FuzzTestFuzzerImpl11RunOneInputERKNS1_5InputE:
  905|  5.53k|    const Input& input) {
  906|  5.53k|  ++stats_.runs;
  907|  5.53k|  auto untyped_args = params_domain_.GetValue(input.args);
  908|  5.53k|  Runtime::Args debug_args{input.args, params_domain_};
  909|  5.53k|  runtime_.SetCurrentArgs(&debug_args);
  910|       |
  911|       |  // Reset and observe the coverage map and start tracing in
  912|       |  // the tightest scope possible. In particular, we can't include the call
  913|       |  // to GetValue in the scope as it will run user code.
  914|  5.53k|  if (execution_coverage_ != nullptr) {
  ------------------
  |  Branch (914:7): [True: 0, False: 5.53k]
  ------------------
  915|      0|    execution_coverage_->ResetState();
  916|      0|  }
  917|  5.53k|  absl::Time start = absl::Now();
  918|  5.53k|  runtime_.OnTestIterationStart(start);
  919|       |  // Set tracing after absl::Now(), otherwise it will make
  920|       |  // FuzzingModeTest.MinimizesDuplicatedCorpustest flaky because
  921|       |  // randomness in absl::Now() being traced by cmp coverage.
  922|  5.53k|  if (execution_coverage_ != nullptr) {
  ------------------
  |  Branch (922:7): [True: 0, False: 5.53k]
  ------------------
  923|      0|    execution_coverage_->SetIsTracing(true);
  924|      0|  }
  925|       |
  926|  5.53k|  fixture_driver_->SetUpIteration();
  927|  5.53k|  fixture_driver_->Test(std::move(untyped_args));
  928|  5.53k|  fixture_driver_->TearDownIteration();
  929|  5.53k|  if (execution_coverage_ != nullptr) {
  ------------------
  |  Branch (929:7): [True: 0, False: 5.53k]
  ------------------
  930|      0|    execution_coverage_->SetIsTracing(false);
  931|      0|  }
  932|  5.53k|  const absl::Duration run_time = absl::Now() - start;
  933|       |
  934|  5.53k|  bool new_coverage = false;
  935|  5.53k|  if (execution_coverage_ != nullptr) {
  ------------------
  |  Branch (935:7): [True: 0, False: 5.53k]
  ------------------
  936|      0|    new_coverage = corpus_coverage_.Update(execution_coverage_);
  937|      0|    stats_.max_stack_used =
  938|      0|        std::max(stats_.max_stack_used, execution_coverage_->MaxStackUsed());
  939|      0|  }
  940|       |
  941|  5.53k|  runtime_.OnTestIterationEnd();
  942|  5.53k|  runtime_.UnsetCurrentArgs();
  943|  5.53k|  return {new_coverage, run_time};
  944|  5.53k|}
runtime.cc:_ZN8fuzztest8internalL15SetNewSigActionEiPFviP9siginfo_tPvEP9sigaction:
  380|     18|                            struct sigaction* old_sigact) {
  381|     18|  struct sigaction new_sigact = {};
  382|     18|  sigemptyset(&new_sigact.sa_mask);
  383|     18|  new_sigact.sa_sigaction = handler;
  384|       |
  385|       |  // We make use of the SA_ONSTACK flag so that signal handlers are executed on
  386|       |  // a separate stack. This is needed to properly handle cases where stack space
  387|       |  // is limited and the delivery of a signal needs to be properly handled.
  388|     18|  new_sigact.sa_flags = SA_SIGINFO | SA_ONSTACK;
  389|       |
  390|     18|  if (sigaction(signum, &new_sigact, old_sigact) == -1) {
  ------------------
  |  Branch (390:7): [True: 0, False: 18]
  ------------------
  391|      0|    fprintf(GetStderr(), "Error installing signal handler: %s\n",
  392|       |            strerror(errno));
  393|      0|    exit(1);
  394|      0|  }
  395|     18|}

_ZN8fuzztest8internal8FuzzTestC2ENS0_13BasicTestInfoEN4absl12lts_2024011612AnyInvocableIKFNSt3__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:
  117|      8|  static Runtime& instance() {
  118|      8|    static auto* runtime = new Runtime();
  119|      8|    return *runtime;
  120|      8|  }
_ZNK8fuzztest8internal7Runtime21termination_requestedEv:
  141|  9.06k|  bool termination_requested() const {
  142|  9.06k|    return termination_requested_.load(std::memory_order_relaxed);
  143|  9.06k|  }
_ZN8fuzztest8internal7Runtime10SetRunModeENS_7RunModeE:
  147|      4|  void SetRunMode(RunMode run_mode) { run_mode_ = run_mode; }
_ZNK8fuzztest8internal7Runtime8run_modeEv:
  148|      2|  RunMode run_mode() const { return run_mode_; }
_ZN8fuzztest8internal7Runtime14EnableReporterEPKNS0_12RuntimeStatsEPFN4absl12lts_202401164TimeEvE:
  150|      2|  void EnableReporter(const RuntimeStats* stats, absl::Time (*clock_fn)()) {
  151|      2|    reporter_enabled_ = true;
  152|      2|    stats_ = stats;
  153|      2|    clock_fn_ = clock_fn;
  154|       |    // In case we have not installed them yet, do so now.
  155|      2|    InstallSignalHandlers(GetStderr());
  156|      2|  }
_ZN8fuzztest8internal7Runtime14SetCurrentTestEPKNS0_8FuzzTestEPKNS0_13ConfigurationE:
  165|  9.06k|                      const Configuration* configuration) {
  166|  9.06k|    current_test_ = test;
  167|  9.06k|    current_configuration_ = configuration;
  168|  9.06k|  }
_ZN8fuzztest8internal7Runtime20OnTestIterationStartERKN4absl12lts_202401164TimeE:
  169|  5.53k|  void OnTestIterationStart(const absl::Time& start_time) {
  170|  5.53k|    current_iteration_start_time_ = start_time;
  171|  5.53k|    test_iteration_started_ = true;
  172|  5.53k|  }
_ZN8fuzztest8internal7Runtime14SetCurrentArgsEPNS1_4ArgsE:
  175|  5.53k|  void SetCurrentArgs(Args* args) { current_args_ = args; }
_ZN8fuzztest8internal7Runtime16UnsetCurrentArgsEv:
  176|  5.53k|  void UnsetCurrentArgs() { current_args_ = nullptr; }
_ZN8fuzztest8internal7RuntimeC2Ev:
  184|      2|  Runtime() = default;

_ZN8fuzztest8internal23GetFromEnvOrMakeSeedSeqERNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEENS1_17basic_string_viewIcS4_EE:
   63|      2|                                      absl::string_view env_var) {
   64|      2|  const std::vector<uint32_t> seed_material =
   65|      2|      GetFromEnvOrMakeSeedMaterial(env_var);
   66|      2|  const std::string encoded_seed_material = EncodeSeedMaterial(seed_material);
   67|      2|  out << env_var << "=" << encoded_seed_material << '\n';
   68|      2|  return std::seed_seq(seed_material.begin(), seed_material.end());
   69|      2|}
_ZN8fuzztest8internal18EncodeSeedMaterialEN4absl12lts_202401164SpanIKjEE:
   71|      2|std::string EncodeSeedMaterial(absl::Span<const uint32_t> seed_material) {
   72|      2|  return absl::WebSafeBase64Escape(
   73|      2|      absl::string_view(reinterpret_cast<const char*>(seed_material.data()),
   74|      2|                        seed_material.size() * sizeof(uint32_t)));
   75|      2|}
seed_seq.cc:_ZN8fuzztest8internal12_GLOBAL__N_128GetFromEnvOrMakeSeedMaterialENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
   47|      2|std::vector<uint32_t> GetFromEnvOrMakeSeedMaterial(absl::string_view env_var) {
   48|      2|  const char* encoded_seed_material = std::getenv(env_var.data());
   49|      2|  if (encoded_seed_material == nullptr) {
  ------------------
  |  Branch (49:7): [True: 2, False: 0]
  ------------------
   50|      2|    return MakeSeedMaterial();
   51|      2|  }
   52|      0|  std::optional<std::vector<uint32_t>> seed_material =
   53|      0|      DecodeSeedMaterial(encoded_seed_material);
   54|      0|  FUZZTEST_INTERNAL_CHECK_PRECONDITION(
  ------------------
  |  |   42|      0|  ((P) ? (void)0                                     \
  |  |  ------------------
  |  |  |  Branch (42:4): [True: 0, False: 0]
  |  |  ------------------
  |  |   43|      0|       : ::fuzztest::internal::Abort(                \
  |  |   44|      0|             __FILE__, __LINE__,                     \
  |  |   45|      0|             absl::StrCat("Failed precondition (", #P, "): ", __VA_ARGS__)))
  ------------------
   55|      0|      seed_material.has_value(),
   56|      0|      "Failed to decode seed material from the environment variable ", env_var);
   57|      0|  return *std::move(seed_material);
   58|      2|}
seed_seq.cc:_ZN8fuzztest8internal12_GLOBAL__N_116MakeSeedMaterialEv:
   37|      2|std::vector<uint32_t> MakeSeedMaterial() {
   38|      2|  absl::BitGen gen;
   39|      2|  static constexpr int kNumberOfEntropyBits = 256;
   40|      2|  std::vector<uint32_t> seed_material(kNumberOfEntropyBits /
   41|      2|                                      (8 * sizeof(uint32_t)));
   42|      2|  std::generate(seed_material.begin(), seed_material.end(),
   43|      2|                [&gen] { return absl::Uniform<uint32_t>(gen); });
   44|      2|  return seed_material;
   45|      2|}
seed_seq.cc:_ZZN8fuzztest8internal12_GLOBAL__N_116MakeSeedMaterialEvENK3$_0clEv:
   43|     16|                [&gen] { return absl::Uniform<uint32_t>(gen); });

_ZN8fuzztest8internal8IRObject10FromStringENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
  331|  9.06k|std::optional<IRObject> IRObject::FromString(absl::string_view str) {
  332|  9.06k|  IRObject object;
  333|  9.06k|  if (IsInBinaryFormat(str)) {
  ------------------
  |  Branch (333:7): [True: 5.49k, False: 3.56k]
  ------------------
  334|  5.49k|    BinaryParseBuf buf = {str.data(), str.size()};
  335|  5.49k|    buf.Advance(kBinaryHeader.size());
  336|  5.49k|    if (!BinaryParse(object, buf, /*recursion_depth=*/0) || !buf.empty())
  ------------------
  |  Branch (336:9): [True: 33, False: 5.46k]
  |  Branch (336:61): [True: 1, False: 5.46k]
  ------------------
  337|     34|      return std::nullopt;
  338|  5.49k|  } else {
  339|  3.56k|    if (ReadToken(str) != kHeader) return std::nullopt;
  ------------------
  |  Branch (339:9): [True: 84, False: 3.48k]
  ------------------
  340|  3.48k|    if (!ParseImpl(object, str, /*recursion_depth=*/0) ||
  ------------------
  |  Branch (340:9): [True: 1.25k, False: 2.22k]
  |  Branch (340:9): [True: 1.40k, False: 2.07k]
  ------------------
  341|  2.22k|        !ReadToken(str).empty())
  ------------------
  |  Branch (341:9): [True: 152, False: 2.07k]
  ------------------
  342|  1.40k|      return std::nullopt;
  343|  3.48k|  }
  344|  7.53k|  return object;
  345|  9.06k|}
serialization.cc:_ZN8fuzztest8internal12_GLOBAL__N_116IsInBinaryFormatENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
  302|  9.06k|bool IsInBinaryFormat(absl::string_view str) {
  303|       |  // Not using absl::string_view or std::memcmp because they could be
  304|       |  // instrumented and using them could pollute coverage.
  305|  9.06k|  return str.size() >= kBinaryHeader.size() &&
  ------------------
  |  Branch (305:10): [True: 8.99k, False: 62]
  ------------------
  306|  8.99k|         __builtin_memcmp(str.data(), kBinaryHeader.data(),
  ------------------
  |  Branch (306:10): [True: 5.49k, False: 3.50k]
  ------------------
  307|  8.99k|                          kBinaryHeader.size()) == 0;
  308|  9.06k|}
serialization.cc:_ZN8fuzztest8internal12_GLOBAL__N_114BinaryParseBuf7AdvanceEm:
  242|  40.3k|  inline void Advance(size_t s) {
  243|  40.3k|    if (s > size) s = size;
  ------------------
  |  Branch (243:9): [True: 0, False: 40.3k]
  ------------------
  244|  40.3k|    str += s;
  245|  40.3k|    size -= s;
  246|  40.3k|  }
serialization.cc:_ZN8fuzztest8internal12_GLOBAL__N_111BinaryParseERNS0_8IRObjectERNS1_14BinaryParseBufEi:
  249|  15.7k|bool BinaryParse(IRObject& obj, BinaryParseBuf& buf, int recursion_depth) {
  250|  15.7k|  if (recursion_depth > kMaxParseRecursionDepth) return false;
  ------------------
  |  Branch (250:7): [True: 0, False: 15.7k]
  ------------------
  251|  15.7k|  if (buf.empty()) return false;
  ------------------
  |  Branch (251:7): [True: 0, False: 15.7k]
  ------------------
  252|  15.7k|  const auto h = static_cast<BinaryFormatHeader>(buf.str[0]);
  253|  15.7k|  buf.Advance(1);
  254|  15.7k|  switch (h) {
  ------------------
  |  Branch (254:11): [True: 15.7k, False: 24]
  ------------------
  255|  2.13k|    case BinaryFormatHeader::kEmpty: {
  ------------------
  |  Branch (255:5): [True: 2.13k, False: 13.6k]
  ------------------
  256|  2.13k|      return true;
  257|      0|    }
  258|  1.63k|    case BinaryFormatHeader::kUInt64: {
  ------------------
  |  Branch (258:5): [True: 1.63k, False: 14.1k]
  ------------------
  259|  1.63k|      if (buf.size < sizeof(uint64_t)) return false;
  ------------------
  |  Branch (259:11): [True: 2, False: 1.63k]
  ------------------
  260|  1.63k|      auto& t = obj.value.emplace<uint64_t>();
  261|  1.63k|      std::memcpy(&t, buf.str, sizeof(uint64_t));
  262|  1.63k|      buf.Advance(sizeof(uint64_t));
  263|  1.63k|      return true;
  264|  1.63k|    }
  265|      1|    case BinaryFormatHeader::kDouble: {
  ------------------
  |  Branch (265:5): [True: 1, False: 15.7k]
  ------------------
  266|      1|      if (buf.size < sizeof(double)) return false;
  ------------------
  |  Branch (266:11): [True: 0, False: 1]
  ------------------
  267|      1|      auto& t = obj.value.emplace<double>();
  268|      1|      std::memcpy(&t, buf.str, sizeof(t));
  269|      1|      buf.Advance(sizeof(double));
  270|      1|      return true;
  271|      1|    }
  272|  5.46k|    case BinaryFormatHeader::kString: {
  ------------------
  |  Branch (272:5): [True: 5.46k, False: 10.2k]
  ------------------
  273|  5.46k|      if (buf.size < sizeof(uint64_t)) return false;
  ------------------
  |  Branch (273:11): [True: 1, False: 5.46k]
  ------------------
  274|  5.46k|      uint64_t str_size;
  275|  5.46k|      std::memcpy(&str_size, buf.str, sizeof(str_size));
  276|  5.46k|      buf.Advance(sizeof(uint64_t));
  277|  5.46k|      if (buf.size < str_size) return false;
  ------------------
  |  Branch (277:11): [True: 2, False: 5.46k]
  ------------------
  278|  5.46k|      obj.value.emplace<std::string>() = {buf.str,
  279|  5.46k|                                          static_cast<size_t>(str_size)};
  280|  5.46k|      buf.Advance(str_size);
  281|  5.46k|      return true;
  282|  5.46k|    }
  283|  6.49k|    case BinaryFormatHeader::kObject: {
  ------------------
  |  Branch (283:5): [True: 6.49k, False: 9.26k]
  ------------------
  284|  6.49k|      if (buf.size < sizeof(uint64_t)) return false;
  ------------------
  |  Branch (284:11): [True: 3, False: 6.49k]
  ------------------
  285|  6.49k|      uint64_t vec_size;
  286|  6.49k|      std::memcpy(&vec_size, buf.str, sizeof(vec_size));
  287|  6.49k|      buf.Advance(sizeof(vec_size));
  288|       |      // This could happen for malformed inputs.
  289|  6.49k|      if (vec_size > buf.size) return false;
  ------------------
  |  Branch (289:11): [True: 1, False: 6.49k]
  ------------------
  290|  6.49k|      auto& v = obj.value.emplace<std::vector<IRObject>>();
  291|  6.49k|      v.reserve(vec_size);
  292|  16.4k|      for (uint64_t i = 0; i < vec_size; ++i) {
  ------------------
  |  Branch (292:28): [True: 10.2k, False: 6.16k]
  ------------------
  293|  10.2k|        if (!BinaryParse(v.emplace_back(), buf, recursion_depth + 1))
  ------------------
  |  Branch (293:13): [True: 331, False: 9.93k]
  ------------------
  294|    331|          return false;
  295|  10.2k|      }
  296|  6.16k|      return true;
  297|  6.49k|    }
  298|  15.7k|  }
  299|     24|  return false;
  300|  15.7k|}
serialization.cc:_ZNK8fuzztest8internal12_GLOBAL__N_114BinaryParseBuf5emptyEv:
  241|  21.2k|  inline bool empty() const { return size == 0; }
serialization.cc:_ZN8fuzztest8internal12_GLOBAL__N_19ReadTokenERNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
   78|   170k|absl::string_view ReadToken(absl::string_view& in) {
   79|   197k|  while (!in.empty() && std::isspace(in[0])) in.remove_prefix(1);
  ------------------
  |  Branch (79:10): [True: 195k, False: 2.90k]
  |  Branch (79:25): [True: 27.5k, False: 167k]
  ------------------
   80|   170k|  if (in.empty()) return in;
  ------------------
  |  Branch (80:7): [True: 2.90k, False: 167k]
  ------------------
   81|   167k|  size_t end = 1;
   82|   167k|  const auto is_literal = [](char c) {
   83|   167k|    return std::isalnum(c) != 0 || c == '+' || c == '-' || c == '.';
   84|   167k|  };
   85|   167k|  if (is_literal(in[0])) {
  ------------------
  |  Branch (85:7): [True: 85.9k, False: 81.5k]
  ------------------
   86|  48.8M|    while (end < in.size() && is_literal(in[end])) ++end;
  ------------------
  |  Branch (86:12): [True: 48.8M, False: 2.82k]
  |  Branch (86:31): [True: 48.7M, False: 83.1k]
  ------------------
   87|  85.9k|  } else if (in[0] == '"') {
  ------------------
  |  Branch (87:14): [True: 542, False: 81.0k]
  ------------------
   88|   910k|    while (end < in.size() && in[end] != '"') ++end;
  ------------------
  |  Branch (88:12): [True: 910k, False: 32]
  |  Branch (88:31): [True: 909k, False: 510]
  ------------------
   89|    542|    if (end < in.size()) ++end;
  ------------------
  |  Branch (89:9): [True: 510, False: 32]
  ------------------
   90|    542|  }
   91|   167k|  absl::string_view res = in.substr(0, end);
   92|   167k|  in.remove_prefix(end);
   93|   167k|  return res;
   94|   170k|}
serialization.cc:_ZZN8fuzztest8internal12_GLOBAL__N_19ReadTokenERNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEENK3$_0clEc:
   82|  49.0M|  const auto is_literal = [](char c) {
   83|  49.0M|    return std::isalnum(c) != 0 || c == '+' || c == '-' || c == '.';
  ------------------
  |  Branch (83:12): [True: 48.7M, False: 300k]
  |  Branch (83:36): [True: 1.06k, False: 299k]
  |  Branch (83:48): [True: 124k, False: 174k]
  |  Branch (83:60): [True: 10.1k, False: 164k]
  ------------------
   84|  49.0M|  };
serialization.cc:_ZN8fuzztest8internal12_GLOBAL__N_19ParseImplERNS0_8IRObjectERNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEi:
  136|  31.2k|bool ParseImpl(IRObject& obj, absl::string_view& str, int recursion_depth) {
  137|  31.2k|  if (recursion_depth > kMaxParseRecursionDepth) return false;
  ------------------
  |  Branch (137:7): [True: 0, False: 31.2k]
  ------------------
  138|  31.2k|  absl::string_view key = ReadToken(str);
  139|  31.2k|  if (key.empty() || key == "}") {
  ------------------
  |  Branch (139:7): [True: 30, False: 31.1k]
  |  Branch (139:22): [True: 430, False: 30.7k]
  ------------------
  140|       |    // The object is empty. Put the token back and return.
  141|    460|    str = absl::string_view(key.data(), str.data() + str.size() - key.data());
  142|    460|    return true;
  143|    460|  }
  144|       |
  145|  30.7k|  if (key == "sub") {
  ------------------
  |  Branch (145:7): [True: 3.19k, False: 27.5k]
  ------------------
  146|  3.19k|    auto& v = obj.value.emplace<std::vector<IRObject>>();
  147|  27.7k|    do {
  148|  27.7k|      if (ReadToken(str) != "{") return false;
  ------------------
  |  Branch (148:11): [True: 57, False: 27.7k]
  ------------------
  149|  27.7k|      if (!ParseImpl(v.emplace_back(), str, recursion_depth + 1)) return false;
  ------------------
  |  Branch (149:11): [True: 2.13k, False: 25.5k]
  ------------------
  150|  25.5k|      if (ReadToken(str) != "}") return false;
  ------------------
  |  Branch (150:11): [True: 575, False: 25.0k]
  ------------------
  151|  25.0k|      key = ReadToken(str);
  152|  25.0k|    } while (key == "sub");
  ------------------
  |  Branch (152:14): [True: 24.5k, False: 432]
  ------------------
  153|       |    // We are done reading this repeated sub.
  154|       |    // Put the token back for the caller.
  155|    432|    str = absl::string_view(key.data(), str.data() + str.size() - key.data());
  156|    432|    return true;
  157|  27.5k|  } else {
  158|  27.5k|    if (ReadToken(str) != ":") return false;
  ------------------
  |  Branch (158:9): [True: 28, False: 27.5k]
  ------------------
  159|  27.5k|    auto value = ReadToken(str);
  160|  27.5k|    auto& v = obj.value;
  161|  27.5k|    if (key == "i") {
  ------------------
  |  Branch (161:9): [True: 1.30k, False: 26.2k]
  ------------------
  162|  1.30k|      return ReadScalar(v.emplace<uint64_t>(), value);
  163|  26.2k|    } else if (key == "d") {
  ------------------
  |  Branch (163:16): [True: 25.7k, False: 516]
  ------------------
  164|  25.7k|      return ReadScalar(v.emplace<double>(), value);
  165|  25.7k|    } else if (key == "s") {
  ------------------
  |  Branch (165:16): [True: 514, False: 2]
  ------------------
  166|    514|      return ReadScalar(v.emplace<std::string>(), value);
  167|    514|    } else {
  168|       |      // Unrecognized key
  169|      2|      return false;
  170|      2|    }
  171|  27.5k|  }
  172|  30.7k|}
serialization.cc:_ZN8fuzztest8internal12_GLOBAL__N_110ReadScalarERmNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   96|  1.30k|bool ReadScalar(uint64_t& out, absl::string_view value) {
   97|  1.30k|  return absl::SimpleAtoi(value, &out);
   98|  1.30k|}
serialization.cc:_ZN8fuzztest8internal12_GLOBAL__N_110ReadScalarERdNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
  100|  25.7k|bool ReadScalar(double& out, absl::string_view value) {
  101|  25.7k|  return absl::SimpleAtod(value, &out);
  102|  25.7k|}
serialization.cc:_ZN8fuzztest8internal12_GLOBAL__N_110ReadScalarERNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS2_17basic_string_viewIcS5_EE:
  104|    514|bool ReadScalar(std::string& out, absl::string_view value) {
  105|    514|  if (value.empty() || value[0] != '"') return false;
  ------------------
  |  Branch (105:7): [True: 4, False: 510]
  |  Branch (105:24): [True: 0, False: 510]
  ------------------
  106|    510|  value.remove_prefix(1);
  107|       |
  108|    510|  if (value.empty() || value.back() != '"') return false;
  ------------------
  |  Branch (108:7): [True: 0, False: 510]
  |  Branch (108:24): [True: 0, False: 510]
  ------------------
  109|    510|  value.remove_suffix(1);
  110|       |
  111|   320k|  while (!value.empty()) {
  ------------------
  |  Branch (111:10): [True: 320k, False: 510]
  ------------------
  112|   320k|    if (value[0] != '\\') {
  ------------------
  |  Branch (112:9): [True: 320k, False: 0]
  ------------------
  113|   320k|      out += value[0];
  114|   320k|      value.remove_prefix(1);
  115|   320k|    } else {
  116|      0|      uint32_t v = 0;
  117|       |
  118|      0|      if (value.size() < 4) return false;
  ------------------
  |  Branch (118:11): [True: 0, False: 0]
  ------------------
  119|      0|      for (int i = 1; i < 4; ++i) {
  ------------------
  |  Branch (119:23): [True: 0, False: 0]
  ------------------
  120|      0|        if (value[i] < '0' || value[i] > '7') {
  ------------------
  |  Branch (120:13): [True: 0, False: 0]
  |  Branch (120:31): [True: 0, False: 0]
  ------------------
  121|      0|          return false;
  122|      0|        }
  123|      0|        v = 8 * v + value[i] - '0';
  124|      0|      }
  125|      0|      if (v > 255) return false;
  ------------------
  |  Branch (125:11): [True: 0, False: 0]
  ------------------
  126|       |
  127|      0|      out += static_cast<char>(v);
  128|      0|      value.remove_prefix(4);
  129|      0|    }
  130|   320k|  }
  131|    510|  return true;
  132|    510|}

_ZNK8fuzztest8internal8IRObject8ToCorpusINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEENS3_8optionalIT_EEv:
  219|  7.53k|  std::optional<T> ToCorpus() const {
  220|       |    if constexpr (std::is_const_v<T>) {
  221|       |      return ToCorpus<std::remove_const_t<T>>();
  222|       |    } else if constexpr (is_monostate_v<T>) {
  223|       |      if (std::holds_alternative<std::monostate>(value)) return T{};
  224|       |      return std::nullopt;
  225|       |    } else if constexpr (std::is_same_v<T, IRObject>) {
  226|       |      return *this;
  227|       |    } else if constexpr (std::is_constructible_v<IRObject, T>) {
  228|       |      if (auto v = GetScalar<T>()) {
  229|       |        return static_cast<T>(*v);
  230|       |      }
  231|       |      return std::nullopt;
  232|       |    } else if constexpr (is_variant_v<T>) {
  233|       |      auto elems = Subs();
  234|       |      if (!elems || elems->size() != 2) return std::nullopt;
  235|       |      auto index = (*elems)[0].ToCorpus<size_t>();
  236|       |      if (!index || *index >= std::variant_size_v<T>) return std::nullopt;
  237|       |      return Switch<std::variant_size_v<T>>(
  238|       |          *index, [&](auto I) -> std::optional<T> {
  239|       |            auto inner =
  240|       |                (*elems)[1].ToCorpus<std::variant_alternative_t<I, T>>();
  241|       |            if (inner) return T(std::in_place_index<I>, *std::move(inner));
  242|       |            return std::nullopt;
  243|       |          });
  244|       |    } else if constexpr (std::is_same_v<T, absl::int128> ||
  245|       |                         std::is_same_v<T, absl::uint128>) {
  246|       |      if (auto res = ToCorpus<std::pair<uint64_t, uint64_t>>()) {
  247|       |        return static_cast<T>(absl::MakeUint128(res->first, res->second));
  248|       |      }
  249|       |      return std::nullopt;
  250|       |    } else if constexpr (is_protocol_buffer_v<T>) {
  251|       |      const std::string* v = std::get_if<std::string>(&value);
  252|       |      T out;
  253|       |      if (v && out.ParseFromString(*v)) return out;
  254|       |      return std::nullopt;
  255|       |    } else if constexpr (is_dynamic_container_v<T>) {
  256|       |      if constexpr (is_bytevector_v<T>) {
  257|       |        const std::string* v = std::get_if<std::string>(&value);
  258|       |        if (v) {
  259|       |          T out;
  260|       |          out.resize(v->size());
  261|       |          std::memcpy(out.data(), v->data(), v->size());
  262|       |          return out;
  263|       |        }
  264|       |      }
  265|       |
  266|       |      auto elems = Subs();
  267|       |      if (!elems) return std::nullopt;
  268|       |
  269|       |      T out;
  270|       |      for (const auto& elem : *elems) {
  271|       |        if (auto inner = elem.ToCorpus<typename T::value_type>()) {
  272|       |          out.insert(out.end(), *std::move(inner));
  273|       |        } else {
  274|       |          return std::nullopt;
  275|       |        }
  276|       |      }
  277|       |      return out;
  278|  7.53k|    } else {
  279|       |      // Must be a tuple like object.
  280|  7.53k|      auto elems = Subs();
  281|  7.53k|      if (!elems || elems->size() != std::tuple_size_v<T>) return std::nullopt;
  ------------------
  |  Branch (281:11): [True: 1.85k, False: 5.67k]
  |  Branch (281:21): [True: 129, False: 5.54k]
  ------------------
  282|  5.54k|      auto it = elems->begin();
  283|  5.54k|      auto parts = ApplyIndex<std::tuple_size_v<T>>([&](auto... I) {
  284|  5.54k|        return std::tuple{it++->ToCorpus<std::tuple_element_t<I, T>>()...};
  285|  5.54k|      });
  286|  5.54k|      return std::apply(
  287|  5.54k|          [&](auto&... part) -> std::optional<T> {
  288|  5.54k|            if ((!part || ...)) return std::nullopt;
  289|  5.54k|            return T{*std::move(part)...};
  290|  5.54k|          },
  291|  5.54k|          parts);
  292|  7.53k|    }
  293|  7.53k|  }
_ZNK8fuzztest8internal8IRObject4SubsEv:
  130|  7.53k|  std::optional<absl::Span<const IRObject>> Subs() const {
  131|  7.53k|    if (const auto* i = std::get_if<std::vector<IRObject>>(&value)) {
  ------------------
  |  Branch (131:21): [True: 5.67k, False: 1.86k]
  ------------------
  132|  5.67k|      return *i;
  133|  5.67k|    }
  134|       |    // The empty vector is serialized the same way as the monostate: nothing.
  135|       |    // Handle that case too.
  136|  1.86k|    if (std::holds_alternative<std::monostate>(value)) {
  ------------------
  |  Branch (136:9): [True: 2, False: 1.85k]
  ------------------
  137|      2|      return absl::Span<const IRObject>{};
  138|      2|    }
  139|  1.85k|    return std::nullopt;
  140|  1.86k|  }
_ZZNK8fuzztest8internal8IRObject8ToCorpusINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEENS3_8optionalIT_EEvENKUlDpT_E_clIJNS3_17integral_constantImLm0EEEEEEDaSG_:
  283|  5.54k|      auto parts = ApplyIndex<std::tuple_size_v<T>>([&](auto... I) {
  284|  5.54k|        return std::tuple{it++->ToCorpus<std::tuple_element_t<I, T>>()...};
  285|  5.54k|      });
_ZNK8fuzztest8internal8IRObject8ToCorpusINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEENS3_8optionalIT_EEv:
  219|  5.54k|  std::optional<T> ToCorpus() const {
  220|       |    if constexpr (std::is_const_v<T>) {
  221|       |      return ToCorpus<std::remove_const_t<T>>();
  222|       |    } else if constexpr (is_monostate_v<T>) {
  223|       |      if (std::holds_alternative<std::monostate>(value)) return T{};
  224|       |      return std::nullopt;
  225|       |    } else if constexpr (std::is_same_v<T, IRObject>) {
  226|       |      return *this;
  227|  5.54k|    } else if constexpr (std::is_constructible_v<IRObject, T>) {
  228|  5.54k|      if (auto v = GetScalar<T>()) {
  ------------------
  |  Branch (228:16): [True: 5.53k, False: 19]
  ------------------
  229|  5.53k|        return static_cast<T>(*v);
  230|  5.53k|      }
  231|     19|      return std::nullopt;
  232|       |    } else if constexpr (is_variant_v<T>) {
  233|       |      auto elems = Subs();
  234|       |      if (!elems || elems->size() != 2) return std::nullopt;
  235|       |      auto index = (*elems)[0].ToCorpus<size_t>();
  236|       |      if (!index || *index >= std::variant_size_v<T>) return std::nullopt;
  237|       |      return Switch<std::variant_size_v<T>>(
  238|       |          *index, [&](auto I) -> std::optional<T> {
  239|       |            auto inner =
  240|       |                (*elems)[1].ToCorpus<std::variant_alternative_t<I, T>>();
  241|       |            if (inner) return T(std::in_place_index<I>, *std::move(inner));
  242|       |            return std::nullopt;
  243|       |          });
  244|       |    } else if constexpr (std::is_same_v<T, absl::int128> ||
  245|       |                         std::is_same_v<T, absl::uint128>) {
  246|       |      if (auto res = ToCorpus<std::pair<uint64_t, uint64_t>>()) {
  247|       |        return static_cast<T>(absl::MakeUint128(res->first, res->second));
  248|       |      }
  249|       |      return std::nullopt;
  250|       |    } else if constexpr (is_protocol_buffer_v<T>) {
  251|       |      const std::string* v = std::get_if<std::string>(&value);
  252|       |      T out;
  253|       |      if (v && out.ParseFromString(*v)) return out;
  254|       |      return std::nullopt;
  255|       |    } else if constexpr (is_dynamic_container_v<T>) {
  256|       |      if constexpr (is_bytevector_v<T>) {
  257|       |        const std::string* v = std::get_if<std::string>(&value);
  258|       |        if (v) {
  259|       |          T out;
  260|       |          out.resize(v->size());
  261|       |          std::memcpy(out.data(), v->data(), v->size());
  262|       |          return out;
  263|       |        }
  264|       |      }
  265|       |
  266|       |      auto elems = Subs();
  267|       |      if (!elems) return std::nullopt;
  268|       |
  269|       |      T out;
  270|       |      for (const auto& elem : *elems) {
  271|       |        if (auto inner = elem.ToCorpus<typename T::value_type>()) {
  272|       |          out.insert(out.end(), *std::move(inner));
  273|       |        } else {
  274|       |          return std::nullopt;
  275|       |        }
  276|       |      }
  277|       |      return out;
  278|       |    } else {
  279|       |      // Must be a tuple like object.
  280|       |      auto elems = Subs();
  281|       |      if (!elems || elems->size() != std::tuple_size_v<T>) return std::nullopt;
  282|       |      auto it = elems->begin();
  283|       |      auto parts = ApplyIndex<std::tuple_size_v<T>>([&](auto... I) {
  284|       |        return std::tuple{it++->ToCorpus<std::tuple_element_t<I, T>>()...};
  285|       |      });
  286|       |      return std::apply(
  287|       |          [&](auto&... part) -> std::optional<T> {
  288|       |            if ((!part || ...)) return std::nullopt;
  289|       |            return T{*std::move(part)...};
  290|       |          },
  291|       |          parts);
  292|       |    }
  293|  5.54k|  }
_ZNK8fuzztest8internal8IRObject9GetScalarINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEDav:
   90|  5.54k|  auto GetScalar() const {
   91|       |    if constexpr (std::is_enum_v<T>) {
   92|       |      auto inner = GetScalar<std::underlying_type_t<T>>();
   93|       |      return inner ? std::optional(static_cast<T>(*inner)) : std::nullopt;
   94|       |    } else if constexpr (std::is_integral_v<T>) {
   95|       |      const uint64_t* i = std::get_if<uint64_t>(&value);
   96|       |      return i != nullptr ? std::optional(static_cast<T>(*i)) : std::nullopt;
   97|       |    } else if constexpr (std::is_same_v<float, T> ||
   98|       |                         std::is_same_v<double, T>) {
   99|       |      const double* i = std::get_if<double>(&value);
  100|       |      return i != nullptr ? std::optional(static_cast<T>(*i)) : std::nullopt;
  101|  5.54k|    } else if constexpr (std::is_same_v<std::string, T>) {
  102|  5.54k|      std::optional<absl::string_view> out;
  103|  5.54k|      if (const auto* s = std::get_if<std::string>(&value)) {
  ------------------
  |  Branch (103:23): [True: 5.53k, False: 19]
  ------------------
  104|  5.53k|        out = *s;
  105|  5.53k|      }
  106|  5.54k|      return out;
  107|  5.54k|    }
  108|  5.54k|  }
_ZZNK8fuzztest8internal8IRObject8ToCorpusINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEENS3_8optionalIT_EEvENKUlDpRT_E_clIJNSC_ISA_EEEEENSC_ISB_EESH_:
  287|  5.54k|          [&](auto&... part) -> std::optional<T> {
  288|  5.54k|            if ((!part || ...)) return std::nullopt;
  ------------------
  |  Branch (288:18): [True: 19, False: 5.53k]
  ------------------
  289|  5.53k|            return T{*std::move(part)...};
  290|  5.54k|          },
_ZN8fuzztest8internal8IRObjectC2Ev:
   76|  47.0k|  IRObject() = default;

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

_ZN7testing7MessagelsIKcEERS0_RKPT_:
  182|     42|  inline Message& operator<<(T* const& pointer) {  // NOLINT
  183|     42|    if (pointer == nullptr) {
  ------------------
  |  Branch (183:9): [True: 0, False: 42]
  ------------------
  184|      0|      *ss_ << "(null)";
  185|     42|    } else {
  186|     42|      *ss_ << pointer;
  187|     42|    }
  188|     42|    return *this;
  189|     42|  }
_ZN7testing8internal18StreamableToStringIiEENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKT_:
  243|      6|std::string StreamableToString(const T& streamable) {
  244|      6|  return (Message() << streamable).GetString();
  245|      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|     42|  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|     42|    using ::operator<<;
  148|     42|    *ss_ << val;
  149|     42|    return *this;
  150|     42|  }
_ZN7testing7MessagelsIcEERS0_RKT_:
  132|    828|  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|    828|    using ::operator<<;
  148|    828|    *ss_ << val;
  149|    828|    return *this;
  150|    828|  }
_ZN7testing8internal18StreamableToStringIPcEENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERKT_:
  243|     28|std::string StreamableToString(const T& streamable) {
  244|     28|  return (Message() << streamable).GetString();
  245|     28|}
_ZN7testing7MessagelsIcEERS0_RKPT_:
  182|     28|  inline Message& operator<<(T* const& pointer) {  // NOLINT
  183|     28|    if (pointer == nullptr) {
  ------------------
  |  Branch (183:9): [True: 0, False: 28]
  ------------------
  184|      0|      *ss_ << "(null)";
  185|     28|    } else {
  186|     28|      *ss_ << pointer;
  187|     28|    }
  188|     28|    return *this;
  189|     28|  }

_ZNK7testing8TestInfo15test_suite_nameEv:
  541|      6|  const char* test_suite_name() const { return test_suite_name_.c_str(); }
_ZNK7testing8TestInfo4nameEv:
  549|     10|  const char* name() const { return name_.c_str(); }
_ZN7testing8UnitTest4implEv:
 1267|     50|  internal::UnitTestImpl* impl() { return impl_; }
_ZNK7testing9TestSuite14test_info_listEv:
  762|      2|  const std::vector<TestInfo*>& test_info_list() const {
  763|      2|    return test_info_list_;
  764|      2|  }
_ZN7testing10TestResult19set_start_timestampEl:
  468|      2|  void set_start_timestamp(TimeInMillis start) { start_timestamp_ = start; }
_ZNK7testing8TestInfo4fileEv:
  566|      4|  const char* file() const { return location_.file.c_str(); }
_ZNK7testing8TestInfo4lineEv:
  569|      4|  int line() const { return location_.line; }
_ZN7testing9TestSuite13ShouldRunTestEPKNS_8TestInfoE:
  839|      8|  static bool ShouldRunTest(const TestInfo* test_info) {
  840|      8|    return test_info->should_run();
  841|      8|  }
_ZN7testing9TestSuite17RunSetUpTestSuiteEv:
  793|      2|  void RunSetUpTestSuite() {
  794|      2|    if (set_up_tc_ != nullptr) {
  ------------------
  |  Branch (794:9): [True: 0, False: 2]
  ------------------
  795|      0|      (*set_up_tc_)();
  796|      0|    }
  797|      2|  }
_ZNK7testing9TestSuite18ad_hoc_test_resultEv:
  752|      4|  const TestResult& ad_hoc_test_result() const { return ad_hoc_test_result_; }
_ZN7testing8TestInfo15ClearTestResultEPS0_:
  639|      4|  static void ClearTestResult(TestInfo* test_info) {
  640|      4|    test_info->result_.Clear();
  641|      4|  }
_ZNK7testing9TestSuite4nameEv:
  695|      6|  const char* name() const { return name_.c_str(); }
_ZNK7testing9TestSuite10type_paramEv:
  699|      2|  const char* type_param() const {
  700|      2|    if (type_param_ != nullptr) return type_param_->c_str();
  ------------------
  |  Branch (700:9): [True: 0, False: 2]
  ------------------
  701|      2|    return nullptr;
  702|      2|  }
_ZNK7testing9TestSuite10should_runEv:
  705|      6|  bool should_run() const { return should_run_; }
_ZNK7testing8TestInfo10should_runEv:
  590|      8|  bool should_run() const { return should_run_; }
_ZNK7testing8TestInfo10type_paramEv:
  553|      4|  const char* type_param() const {
  554|      4|    if (type_param_ != nullptr) return type_param_->c_str();
  ------------------
  |  Branch (554:9): [True: 0, False: 4]
  ------------------
  555|      4|    return nullptr;
  556|      4|  }
_ZNK7testing8UnitTest4implEv:
 1268|      4|  const internal::UnitTestImpl* impl() const { return impl_; }
_ZN7testing9TestSuite20ClearTestSuiteResultEPS0_:
  781|      2|  static void ClearTestSuiteResult(TestSuite* test_suite) {
  782|      2|    test_suite->ClearResult();
  783|      2|  }
_ZN7testing9TestSuite14set_should_runEb:
  771|      6|  void set_should_run(bool should) { should_run_ = should; }
_ZN7testing9TestSuite14test_info_listEv:
  759|     10|  std::vector<TestInfo*>& test_info_list() { return test_info_list_; }
_ZN7testing17TestEventListener16OnTestSuiteStartERKNS_9TestSuiteE:
  946|      2|  virtual void OnTestSuiteStart(const TestSuite& /*test_suite*/) {}

_ZN7testing8internal8FilePathC2ERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
   74|      2|  explicit FilePath(const std::string& pathname) : pathname_(pathname) {
   75|      2|    Normalize();
   76|      2|  }
_ZNK7testing8internal8FilePath7IsEmptyEv:
  118|      6|  bool IsEmpty() const { return pathname_.empty(); }
_ZN7testing8internal8FilePathC2Ev:
   71|      2|  FilePath() : pathname_("") {}
_ZN7testing8internal8FilePath3SetERKS1_:
   83|      2|  void Set(const FilePath& rhs) { pathname_ = rhs.pathname_; }

_ZN7testing8internal6RandomC2Ej:
  859|      2|  explicit Random(uint32_t seed) : state_(seed) {}
_ZN7testing8internal9GetTypeIdINS_4TestEEEPKvv:
  419|      4|TypeId GetTypeId() {
  420|       |  // The compiler is required to allocate a different
  421|       |  // TypeIdHelper<T>::dummy_ variable for each T used to instantiate
  422|       |  // the template.  Therefore, the address of dummy_ is guaranteed to
  423|       |  // be unique.
  424|      4|  return &(TypeIdHelper<T>::dummy_);
  425|      4|}

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

_ZN7testing8internal7ToUpperEc:
 1971|    828|inline char ToUpper(char ch) {
 1972|    828|  return static_cast<char>(toupper(static_cast<unsigned char>(ch)));
 1973|    828|}
_ZN7testing8internal5posix6GetEnvEPKc:
 2122|     62|inline const char* GetEnv(const char* name) {
 2123|       |#if defined(GTEST_OS_WINDOWS_MOBILE) || defined(GTEST_OS_WINDOWS_PHONE) || \
 2124|       |    defined(GTEST_OS_ESP8266) || defined(GTEST_OS_XTENSA) ||               \
 2125|       |    defined(GTEST_OS_QURT)
 2126|       |  // We are on an embedded platform, which has no environment variables.
 2127|       |  static_cast<void>(name);  // To prevent 'unused argument' warning.
 2128|       |  return nullptr;
 2129|       |#elif defined(__BORLANDC__) || defined(__SunOS_5_8) || defined(__SunOS_5_9)
 2130|       |  // Environment variables which we programmatically clear will be set to the
 2131|       |  // empty string rather than unset (NULL).  Handle that case.
 2132|       |  const char* const env = getenv(name);
 2133|       |  return (env != nullptr && env[0] != '\0') ? env : nullptr;
 2134|       |#else
 2135|     62|  return getenv(name);
 2136|     62|#endif
 2137|     62|}
_ZN7testing8internal5posix10StrCaseCmpEPKcS3_:
 2059|      2|inline int StrCaseCmp(const char* s1, const char* s2) {
 2060|      2|  return strcasecmp(s1, s2);
 2061|      2|}
_ZN7testing8internal5MutexC2Ev:
 1706|     12|  Mutex() {
 1707|     12|    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, nullptr));
  ------------------
  |  | 1092|     12|  if (const int gtest_error = (posix_call))    \
  |  |  ------------------
  |  |  |  Branch (1092:17): [True: 0, False: 12]
  |  |  ------------------
  |  | 1093|     12|  GTEST_LOG_(FATAL) << #posix_call << "failed with error " << gtest_error
  |  |  ------------------
  |  |  |  | 1054|      0|  ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \
  |  |  |  | 1055|      0|                                __FILE__, __LINE__)                    \
  |  |  |  | 1056|      0|      .GetStream()
  |  |  ------------------
  ------------------
 1708|     12|    has_owner_ = false;
 1709|     12|  }
_ZN7testing8internal5posix6IsATTYEi:
 2065|      2|inline int IsATTY(int fd) {
 2066|       |  // DoIsATTY might change errno (for example ENOTTY in case you redirect stdout
 2067|       |  // to a file on Linux), which is unexpected, so save the previous value, and
 2068|       |  // restore it after the call.
 2069|      2|  int savedErrno = errno;
 2070|      2|  int isAttyValue = DoIsATTY(fd);
 2071|      2|  errno = savedErrno;
 2072|       |
 2073|      2|  return isAttyValue;
 2074|      2|}
_ZN7testing8internal5posix8DoIsATTYEi:
 2058|      2|inline int DoIsATTY(int fd) { return isatty(fd); }
_ZN7testing8internal5posix6FileNoEP8_IO_FILE:
 2021|      2|inline int FileNo(FILE* file) { return fileno(file); }
_ZN7testing8internal11ThreadLocalIPNS_31TestPartResultReporterInterfaceEEC2ERKS3_:
 1761|      2|      : key_(CreateKey()),
 1762|      2|        default_factory_(new InstanceValueHolderFactory(value)) {}
_ZN7testing8internal11ThreadLocalIPNS_31TestPartResultReporterInterfaceEE9CreateKeyEv:
 1793|      2|  static pthread_key_t CreateKey() {
 1794|      2|    pthread_key_t key;
 1795|       |    // When a thread exits, DeleteThreadLocalValue() will be called on
 1796|       |    // the object managed for that thread.
 1797|      2|    GTEST_CHECK_POSIX_SUCCESS_(
  ------------------
  |  | 1092|      2|  if (const int gtest_error = (posix_call))    \
  |  |  ------------------
  |  |  |  Branch (1092:17): [True: 0, False: 2]
  |  |  ------------------
  |  | 1093|      2|  GTEST_LOG_(FATAL) << #posix_call << "failed with error " << gtest_error
  |  |  ------------------
  |  |  |  | 1054|      0|  ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \
  |  |  |  | 1055|      0|                                __FILE__, __LINE__)                    \
  |  |  |  | 1056|      0|      .GetStream()
  |  |  ------------------
  ------------------
 1798|      2|        pthread_key_create(&key, &DeleteThreadLocalValue));
 1799|      2|    return key;
 1800|      2|  }
_ZN7testing8internal11ThreadLocalIPNS_31TestPartResultReporterInterfaceEE26InstanceValueHolderFactoryC2ERKS3_:
 1839|      2|    explicit InstanceValueHolderFactory(const T& value) : value_(value) {}
_ZN7testing8internal11ThreadLocalIPNS_31TestPartResultReporterInterfaceEE18ValueHolderFactoryC2Ev:
 1817|      2|    ValueHolderFactory() = default;
_ZN7testing8internal11ThreadLocalINSt3__16vectorINS0_9TraceInfoENS2_9allocatorIS4_EEEEEC2Ev:
 1759|      2|      : key_(CreateKey()), default_factory_(new DefaultValueHolderFactory()) {}
_ZN7testing8internal11ThreadLocalINSt3__16vectorINS0_9TraceInfoENS2_9allocatorIS4_EEEEE9CreateKeyEv:
 1793|      2|  static pthread_key_t CreateKey() {
 1794|      2|    pthread_key_t key;
 1795|       |    // When a thread exits, DeleteThreadLocalValue() will be called on
 1796|       |    // the object managed for that thread.
 1797|      2|    GTEST_CHECK_POSIX_SUCCESS_(
  ------------------
  |  | 1092|      2|  if (const int gtest_error = (posix_call))    \
  |  |  ------------------
  |  |  |  Branch (1092:17): [True: 0, False: 2]
  |  |  ------------------
  |  | 1093|      2|  GTEST_LOG_(FATAL) << #posix_call << "failed with error " << gtest_error
  |  |  ------------------
  |  |  |  | 1054|      0|  ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \
  |  |  |  | 1055|      0|                                __FILE__, __LINE__)                    \
  |  |  |  | 1056|      0|      .GetStream()
  |  |  ------------------
  ------------------
 1798|      2|        pthread_key_create(&key, &DeleteThreadLocalValue));
 1799|      2|    return key;
 1800|      2|  }
_ZN7testing8internal11ThreadLocalINSt3__16vectorINS0_9TraceInfoENS2_9allocatorIS4_EEEEE25DefaultValueHolderFactoryC2Ev:
 1828|      2|    DefaultValueHolderFactory() = default;
_ZN7testing8internal11ThreadLocalINSt3__16vectorINS0_9TraceInfoENS2_9allocatorIS4_EEEEE18ValueHolderFactoryC2Ev:
 1817|      2|    ValueHolderFactory() = default;

_ZN7testing8internal29ParseInternalRunDeathTestFlagEv:
 1531|      2|InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag() {
 1532|      2|  if (GTEST_FLAG_GET(internal_run_death_test).empty()) return nullptr;
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  |  Branch (1532:7): [True: 2, False: 0]
  ------------------
 1533|       |
 1534|       |  // GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we
 1535|       |  // can use it here.
 1536|      0|  int line = -1;
 1537|      0|  int index = -1;
 1538|      0|  ::std::vector< ::std::string> fields;
 1539|      0|  SplitString(GTEST_FLAG_GET(internal_run_death_test), '|', &fields);
  ------------------
  |  | 2293|      0|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
 1540|      0|  int write_fd = -1;
 1541|       |
 1542|       |#ifdef GTEST_OS_WINDOWS
 1543|       |
 1544|       |  unsigned int parent_process_id = 0;
 1545|       |  size_t write_handle_as_size_t = 0;
 1546|       |  size_t event_handle_as_size_t = 0;
 1547|       |
 1548|       |  if (fields.size() != 6 || !ParseNaturalNumber(fields[1], &line) ||
 1549|       |      !ParseNaturalNumber(fields[2], &index) ||
 1550|       |      !ParseNaturalNumber(fields[3], &parent_process_id) ||
 1551|       |      !ParseNaturalNumber(fields[4], &write_handle_as_size_t) ||
 1552|       |      !ParseNaturalNumber(fields[5], &event_handle_as_size_t)) {
 1553|       |    DeathTestAbort("Bad --gtest_internal_run_death_test flag: " +
 1554|       |                   GTEST_FLAG_GET(internal_run_death_test));
 1555|       |  }
 1556|       |  write_fd = GetStatusFileDescriptor(parent_process_id, write_handle_as_size_t,
 1557|       |                                     event_handle_as_size_t);
 1558|       |
 1559|       |#elif defined(GTEST_OS_FUCHSIA)
 1560|       |
 1561|       |  if (fields.size() != 3 || !ParseNaturalNumber(fields[1], &line) ||
 1562|       |      !ParseNaturalNumber(fields[2], &index)) {
 1563|       |    DeathTestAbort("Bad --gtest_internal_run_death_test flag: " +
 1564|       |                   GTEST_FLAG_GET(internal_run_death_test));
 1565|       |  }
 1566|       |
 1567|       |#else
 1568|       |
 1569|      0|  if (fields.size() != 4 || !ParseNaturalNumber(fields[1], &line) ||
  ------------------
  |  Branch (1569:7): [True: 0, False: 0]
  |  Branch (1569:29): [True: 0, False: 0]
  ------------------
 1570|      0|      !ParseNaturalNumber(fields[2], &index) ||
  ------------------
  |  Branch (1570:7): [True: 0, False: 0]
  ------------------
 1571|      0|      !ParseNaturalNumber(fields[3], &write_fd)) {
  ------------------
  |  Branch (1571:7): [True: 0, False: 0]
  ------------------
 1572|      0|    DeathTestAbort("Bad --gtest_internal_run_death_test flag: " +
 1573|      0|                   GTEST_FLAG_GET(internal_run_death_test));
  ------------------
  |  | 2293|      0|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
 1574|      0|  }
 1575|       |
 1576|      0|#endif  // GTEST_OS_WINDOWS
 1577|       |
 1578|      0|  return new InternalRunDeathTestFlag(fields[0], line, index, write_fd);
 1579|      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:
  966|     36|inline UnitTestImpl* GetUnitTestImpl() {
  967|     36|  return UnitTest::GetInstance()->impl();
  968|     36|}
_ZN7testing8internal12UnitTestImpl17current_test_infoEv:
  766|      2|  TestInfo* current_test_info() { return current_test_info_; }
_ZN7testing8internal12UnitTestImpl9listenersEv:
  608|     12|  TestEventListeners* listeners() { return &listeners_; }
_ZN7testing8internal12UnitTestImpl33ignored_parameterized_test_suitesEv:
  701|      2|  std::set<std::string>* ignored_parameterized_test_suites() {
  702|      2|    return &ignored_parameterized_test_suites_;
  703|      2|  }
_ZN7testing8internal14GTestFlagSaverC2Ev:
  143|      2|  GTestFlagSaver() {
  144|      2|    also_run_disabled_tests_ = GTEST_FLAG_GET(also_run_disabled_tests);
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  145|      2|    break_on_failure_ = GTEST_FLAG_GET(break_on_failure);
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  146|      2|    catch_exceptions_ = GTEST_FLAG_GET(catch_exceptions);
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  147|      2|    color_ = GTEST_FLAG_GET(color);
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  148|      2|    death_test_style_ = GTEST_FLAG_GET(death_test_style);
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  149|      2|    death_test_use_fork_ = GTEST_FLAG_GET(death_test_use_fork);
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  150|      2|    fail_fast_ = GTEST_FLAG_GET(fail_fast);
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  151|      2|    filter_ = GTEST_FLAG_GET(filter);
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  152|      2|    internal_run_death_test_ = GTEST_FLAG_GET(internal_run_death_test);
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  153|      2|    list_tests_ = GTEST_FLAG_GET(list_tests);
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  154|      2|    output_ = GTEST_FLAG_GET(output);
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  155|      2|    brief_ = GTEST_FLAG_GET(brief);
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  156|      2|    print_time_ = GTEST_FLAG_GET(print_time);
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  157|      2|    print_utf8_ = GTEST_FLAG_GET(print_utf8);
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  158|      2|    random_seed_ = GTEST_FLAG_GET(random_seed);
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  159|      2|    repeat_ = GTEST_FLAG_GET(repeat);
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  160|      2|    recreate_environments_when_repeating_ =
  161|      2|        GTEST_FLAG_GET(recreate_environments_when_repeating);
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  162|      2|    shuffle_ = GTEST_FLAG_GET(shuffle);
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  163|      2|    stack_trace_depth_ = GTEST_FLAG_GET(stack_trace_depth);
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  164|      2|    stream_result_to_ = GTEST_FLAG_GET(stream_result_to);
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  165|      2|    throw_on_failure_ = GTEST_FLAG_GET(throw_on_failure);
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  166|      2|  }
_ZNK7testing8internal12UnitTestImpl18current_test_suiteEv:
  765|      2|  const TestSuite* current_test_suite() const { return current_test_suite_; }
_ZN7testing8internal12UnitTestImpl11AddTestInfoEPFvvES3_PNS_8TestInfoE:
  674|      4|                   TestInfo* test_info) {
  675|      4|#if GTEST_HAS_FILE_SYSTEM
  676|       |    // In order to support thread-safe death tests, we need to
  677|       |    // remember the original working directory when the test program
  678|       |    // was first invoked.  We cannot do this in RUN_ALL_TESTS(), as
  679|       |    // the user may have changed the current directory before calling
  680|       |    // RUN_ALL_TESTS().  Therefore we capture the current directory in
  681|       |    // AddTestInfo(), which is called to register a TEST or TEST_F
  682|       |    // before main() is reached.
  683|      4|    if (original_working_dir_.IsEmpty()) {
  ------------------
  |  Branch (683:9): [True: 2, False: 2]
  ------------------
  684|      2|      original_working_dir_.Set(FilePath::GetCurrentDir());
  685|      4|      GTEST_CHECK_(!original_working_dir_.IsEmpty())
  ------------------
  |  | 1079|      2|  GTEST_AMBIGUOUS_ELSE_BLOCKER_               \
  |  |  ------------------
  |  |  |  |  712|      4|  switch (0)                          \
  |  |  |  |  713|      4|  case 0:                             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (713:3): [True: 2, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  714|      2|  default:  // NOLINT
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (714:3): [True: 0, False: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1080|      2|  if (::testing::internal::IsTrue(condition)) \
  |  |  ------------------
  |  |  |  Branch (1080:7): [True: 2, False: 0]
  |  |  ------------------
  |  | 1081|      2|    ;                                         \
  |  | 1082|      2|  else                                        \
  |  | 1083|      2|    GTEST_LOG_(FATAL) << "Condition " #condition " failed. "
  |  |  ------------------
  |  |  |  | 1054|      0|  ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \
  |  |  |  | 1055|      0|                                __FILE__, __LINE__)                    \
  |  |  |  | 1056|      0|      .GetStream()
  |  |  ------------------
  ------------------
  686|      4|          << "Failed to get the current working directory.";
  687|      2|    }
  688|      4|#endif  // GTEST_HAS_FILE_SYSTEM
  689|       |
  690|      4|    GetTestSuite(test_info->test_suite_name(), test_info->type_param(),
  691|      4|                 set_up_tc, tear_down_tc)
  692|      4|        ->AddTestInfo(test_info);
  693|      4|  }
_ZN7testing8internal12UnitTestImpl21set_current_test_infoEPNS_8TestInfoE:
  720|      2|  void set_current_test_info(TestInfo* a_current_test_info) {
  721|      2|    current_test_info_ = a_current_test_info;
  722|      2|  }
_ZN7testing8internal12UnitTestImpl22set_current_test_suiteEPNS_9TestSuiteE:
  713|      2|  void set_current_test_suite(TestSuite* a_current_test_suite) {
  714|      2|    current_test_suite_ = a_current_test_suite;
  715|      2|  }
_ZN7testing8internal12UnitTestImpl19GetMutableSuiteCaseEi:
  602|      2|  TestSuite* GetMutableSuiteCase(int i) {
  603|      2|    const int index = GetElementOr(test_suite_indices_, i, -1);
  604|      2|    return index < 0 ? nullptr : test_suites_[static_cast<size_t>(index)];
  ------------------
  |  Branch (604:12): [True: 0, False: 2]
  ------------------
  605|      2|  }
_ZN7testing8internal12UnitTestImpl20set_catch_exceptionsEb:
  842|      2|  void set_catch_exceptions(bool value) { catch_exceptions_ = value; }
_ZN7testing8internal12UnitTestImpl34InitDeathTestSubprocessControlInfoEv:
  782|      2|  void InitDeathTestSubprocessControlInfo() {
  783|      2|    internal_run_death_test_flag_.reset(ParseInternalRunDeathTestFlag());
  784|      2|  }
_ZN7testing8internal21GetRandomSeedFromFlagEi:
  113|      2|inline int GetRandomSeedFromFlag(int32_t random_seed_flag) {
  114|      2|  const unsigned int raw_seed =
  115|      2|      (random_seed_flag == 0) ? static_cast<unsigned int>(GetTimeInMillis())
  ------------------
  |  Branch (115:7): [True: 2, False: 0]
  ------------------
  116|      2|                              : static_cast<unsigned int>(random_seed_flag);
  117|       |
  118|       |  // Normalizes the actual seed to range [1, kMaxRandomSeed] such that
  119|       |  // it's easy to type.
  120|      2|  const int normalized_seed =
  121|      2|      static_cast<int>((raw_seed - 1U) %
  122|      2|                       static_cast<unsigned int>(kMaxRandomSeed)) +
  123|      2|      1;
  124|      2|  return normalized_seed;
  125|      2|}
_ZN7testing8internal12UnitTestImpl23ClearNonAdHocTestResultEv:
  739|      2|  void ClearNonAdHocTestResult() {
  740|      2|    ForEach(test_suites_, TestSuite::ClearTestSuiteResult);
  741|      2|  }
_ZN7testing8internal18OsStackTraceGetterC2Ev:
  439|      2|  OsStackTraceGetter() = default;
_ZN7testing8internal27OsStackTraceGetterInterfaceC2Ev:
  410|      2|  OsStackTraceGetterInterface() = default;
_ZN7testing8internal12GetElementOrIiEET_RKNSt3__16vectorIS2_NS3_9allocatorIS2_EEEEiS2_:
  294|      4|inline E GetElementOr(const std::vector<E>& v, int i, E default_value) {
  295|      4|  return (i < 0 || i >= static_cast<int>(v.size())) ? default_value
  ------------------
  |  Branch (295:11): [True: 0, False: 4]
  |  Branch (295:20): [True: 0, False: 4]
  ------------------
  296|      4|                                                    : v[static_cast<size_t>(i)];
  297|      4|}
_ZN7testing8internal7ForEachINSt3__16vectorIPNS_9TestSuiteENS2_9allocatorIS5_EEEEPFvS5_EEEvRKT_T0_:
  287|      2|void ForEach(const Container& c, Functor functor) {
  288|      2|  std::for_each(c.begin(), c.end(), functor);
  289|      2|}
_ZN7testing8internal7CountIfINSt3__16vectorIPNS_9TestSuiteENS2_9allocatorIS5_EEEEPFbPKS4_EEEiRKT_T0_:
  275|      2|inline int CountIf(const Container& c, Predicate predicate) {
  276|       |  // Implemented as an explicit loop since std::count_if() in libCstd on
  277|       |  // Solaris has a non-standard signature.
  278|      2|  int count = 0;
  279|      4|  for (auto it = c.begin(); it != c.end(); ++it) {
  ------------------
  |  Branch (279:29): [True: 2, False: 2]
  ------------------
  280|      2|    if (predicate(*it)) ++count;
  ------------------
  |  Branch (280:9): [True: 2, False: 0]
  ------------------
  281|      2|  }
  282|      2|  return count;
  283|      2|}
_ZN7testing8internal7CountIfINSt3__16vectorINS_14TestPartResultENS2_9allocatorIS4_EEEEPFbRKS4_EEEiRKT_T0_:
  275|     14|inline int CountIf(const Container& c, Predicate predicate) {
  276|       |  // Implemented as an explicit loop since std::count_if() in libCstd on
  277|       |  // Solaris has a non-standard signature.
  278|     14|  int count = 0;
  279|     14|  for (auto it = c.begin(); it != c.end(); ++it) {
  ------------------
  |  Branch (279:29): [True: 0, False: 14]
  ------------------
  280|      0|    if (predicate(*it)) ++count;
  ------------------
  |  Branch (280:9): [True: 0, False: 0]
  ------------------
  281|      0|  }
  282|     14|  return count;
  283|     14|}
_ZNK7testing8internal12UnitTestImpl16catch_exceptionsEv:
  835|     10|  bool catch_exceptions() const { return catch_exceptions_; }
_ZN7testing8internal7CountIfINSt3__16vectorIPNS_8TestInfoENS2_9allocatorIS5_EEEEPFbPKS4_EEEiRKT_T0_:
  275|      4|inline int CountIf(const Container& c, Predicate predicate) {
  276|       |  // Implemented as an explicit loop since std::count_if() in libCstd on
  277|       |  // Solaris has a non-standard signature.
  278|      4|  int count = 0;
  279|     12|  for (auto it = c.begin(); it != c.end(); ++it) {
  ------------------
  |  Branch (279:29): [True: 8, False: 4]
  ------------------
  280|      8|    if (predicate(*it)) ++count;
  ------------------
  |  Branch (280:9): [True: 4, False: 4]
  ------------------
  281|      8|  }
  282|      4|  return count;
  283|      4|}
_ZN7testing8internal7ForEachINSt3__16vectorIPNS_8TestInfoENS2_9allocatorIS5_EEEEPFvS5_EEEvRKT_T0_:
  287|      2|void ForEach(const Container& c, Functor functor) {
  288|      2|  std::for_each(c.begin(), c.end(), functor);
  289|      2|}
_ZN7testing8internal7ForEachINSt3__16vectorIPNS_11EnvironmentENS2_9allocatorIS5_EEEEPFvS5_EEEvRKT_T0_:
  287|      2|void ForEach(const Container& c, Functor functor) {
  288|      2|  std::for_each(c.begin(), c.end(), functor);
  289|      2|}

_ZN7testing8internal16BoolFromGTestEnvEPKcb:
 1324|     24|bool BoolFromGTestEnv(const char* flag, bool default_value) {
 1325|       |#if defined(GTEST_GET_BOOL_FROM_ENV_)
 1326|       |  return GTEST_GET_BOOL_FROM_ENV_(flag, default_value);
 1327|       |#else
 1328|     24|  const std::string env_var = FlagToEnvVar(flag);
 1329|     24|  const char* const string_value = posix::GetEnv(env_var.c_str());
 1330|     24|  return string_value == nullptr ? default_value
  ------------------
  |  Branch (1330:10): [True: 24, False: 0]
  ------------------
 1331|     24|                                 : strcmp(string_value, "0") != 0;
 1332|     24|#endif  // defined(GTEST_GET_BOOL_FROM_ENV_)
 1333|     24|}
_ZN7testing8internal17Int32FromGTestEnvEPKci:
 1338|      6|int32_t Int32FromGTestEnv(const char* flag, int32_t default_value) {
 1339|       |#if defined(GTEST_GET_INT32_FROM_ENV_)
 1340|       |  return GTEST_GET_INT32_FROM_ENV_(flag, default_value);
 1341|       |#else
 1342|      6|  const std::string env_var = FlagToEnvVar(flag);
 1343|      6|  const char* const string_value = posix::GetEnv(env_var.c_str());
 1344|      6|  if (string_value == nullptr) {
  ------------------
  |  Branch (1344:7): [True: 6, False: 0]
  ------------------
 1345|       |    // The environment variable is not set.
 1346|      6|    return default_value;
 1347|      6|  }
 1348|       |
 1349|      0|  int32_t result = default_value;
 1350|      0|  if (!ParseInt32(Message() << "Environment variable " << env_var, string_value,
  ------------------
  |  Branch (1350:7): [True: 0, False: 0]
  ------------------
 1351|      0|                  &result)) {
 1352|      0|    printf("The default value %s is used.\n",
 1353|      0|           (Message() << default_value).GetString().c_str());
 1354|      0|    fflush(stdout);
 1355|      0|    return default_value;
 1356|      0|  }
 1357|       |
 1358|      0|  return result;
 1359|      0|#endif  // defined(GTEST_GET_INT32_FROM_ENV_)
 1360|      0|}
_ZN7testing8internal25OutputFlagAlsoCheckEnvVarEv:
 1370|      2|std::string OutputFlagAlsoCheckEnvVar() {
 1371|      2|  std::string default_value_for_output_flag = "";
 1372|      2|  const char* xml_output_file_env = posix::GetEnv("XML_OUTPUT_FILE");
 1373|      2|  if (nullptr != xml_output_file_env) {
  ------------------
  |  Branch (1373:7): [True: 0, False: 2]
  ------------------
 1374|      0|    default_value_for_output_flag = std::string("xml:") + xml_output_file_env;
 1375|      0|  }
 1376|      2|  return default_value_for_output_flag;
 1377|      2|}
_ZN7testing8internal18StringFromGTestEnvEPKcS2_:
 1381|     12|const char* StringFromGTestEnv(const char* flag, const char* default_value) {
 1382|       |#if defined(GTEST_GET_STRING_FROM_ENV_)
 1383|       |  return GTEST_GET_STRING_FROM_ENV_(flag, default_value);
 1384|       |#else
 1385|     12|  const std::string env_var = FlagToEnvVar(flag);
 1386|     12|  const char* const value = posix::GetEnv(env_var.c_str());
 1387|     12|  return value == nullptr ? default_value : value;
  ------------------
  |  Branch (1387:10): [True: 12, False: 0]
  ------------------
 1388|     12|#endif  // defined(GTEST_GET_STRING_FROM_ENV_)
 1389|     12|}
gtest-all.cc:_ZN7testing8internalL12FlagToEnvVarEPKc:
 1267|     42|static std::string FlagToEnvVar(const char* flag) {
 1268|     42|  const std::string full_flag =
 1269|     42|      (Message() << GTEST_FLAG_PREFIX_ << flag).GetString();
  ------------------
  |  |  331|     42|#define GTEST_FLAG_PREFIX_ "gtest_"
  ------------------
 1270|       |
 1271|     42|  Message env_var;
 1272|    870|  for (size_t i = 0; i != full_flag.length(); i++) {
  ------------------
  |  Branch (1272:22): [True: 828, False: 42]
  ------------------
 1273|    828|    env_var << ToUpper(full_flag.c_str()[i]);
 1274|    828|  }
 1275|       |
 1276|     42|  return env_var.GetString();
 1277|     42|}

_ZN7testing8internal33GetIgnoredParameterizedTestSuitesEv:
  502|      2|std::set<std::string>* GetIgnoredParameterizedTestSuites() {
  503|      2|  return UnitTest::GetInstance()->impl()->ignored_parameterized_test_suites();
  504|      2|}
_ZN7testing8internal34TypeParameterizedTestSuiteRegistry22CheckForInstantiationsEv:
  585|      2|void TypeParameterizedTestSuiteRegistry::CheckForInstantiations() {
  586|      2|  const auto& ignored = *GetIgnoredParameterizedTestSuites();
  587|      2|  for (const auto& testcase : suites_) {
  ------------------
  |  Branch (587:29): [True: 0, False: 2]
  ------------------
  588|      0|    if (testcase.second.instantiated) continue;
  ------------------
  |  Branch (588:9): [True: 0, False: 0]
  ------------------
  589|      0|    if (ignored.find(testcase.first) != ignored.end()) continue;
  ------------------
  |  Branch (589:9): [True: 0, False: 0]
  ------------------
  590|       |
  591|      0|    std::string message =
  592|      0|        "Type parameterized test suite " + testcase.first +
  593|      0|        " is defined via REGISTER_TYPED_TEST_SUITE_P, but never instantiated "
  594|      0|        "via INSTANTIATE_TYPED_TEST_SUITE_P. None of the test cases will run."
  595|      0|        "\n\n"
  596|      0|        "Ideally, TYPED_TEST_P definitions should only ever be included as "
  597|      0|        "part of binaries that intend to use them. (As opposed to, for "
  598|      0|        "example, being placed in a library that may be linked in to get other "
  599|      0|        "utilities.)"
  600|      0|        "\n\n"
  601|      0|        "To suppress this error for this test suite, insert the following line "
  602|      0|        "(in a non-header) in the namespace it is defined in:"
  603|      0|        "\n\n"
  604|      0|        "GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(" +
  605|      0|        testcase.first + ");";
  606|       |
  607|      0|    std::string full_name =
  608|      0|        "UninstantiatedTypeParameterizedTestSuite<" + testcase.first + ">";
  609|      0|    RegisterTest(  //
  610|      0|        "GoogleTestVerification", full_name.c_str(),
  611|      0|        nullptr,  // No type parameter.
  612|      0|        nullptr,  // No value parameter.
  613|      0|        testcase.second.code_location.file.c_str(),
  614|      0|        testcase.second.code_location.line, [message, testcase] {
  615|      0|          return new FailureTest(testcase.second.code_location, message,
  616|      0|                                 kErrorOnUninstantiatedTypeParameterizedTest);
  617|      0|        });
  618|      0|  }
  619|      2|}
_ZN7testing8internal8GetArgvsEv:
  624|      4|::std::vector<std::string> GetArgvs() {
  625|       |#if defined(GTEST_CUSTOM_GET_ARGVS_)
  626|       |  // GTEST_CUSTOM_GET_ARGVS_() may return a container of std::string or
  627|       |  // ::string. This code converts it to the appropriate type.
  628|       |  const auto& custom = GTEST_CUSTOM_GET_ARGVS_();
  629|       |  return ::std::vector<std::string>(custom.begin(), custom.end());
  630|       |#else   // defined(GTEST_CUSTOM_GET_ARGVS_)
  631|      4|  return g_argvs;
  632|      4|#endif  // defined(GTEST_CUSTOM_GET_ARGVS_)
  633|      4|}
_ZN7testing8internal15UnitTestOptions15GetOutputFormatEv:
  654|      2|std::string UnitTestOptions::GetOutputFormat() {
  655|      2|  std::string s = GTEST_FLAG_GET(output);
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  656|      2|  const char* const gtest_output_flag = s.c_str();
  657|      2|  const char* const colon = strchr(gtest_output_flag, ':');
  658|      2|  return (colon == nullptr)
  ------------------
  |  Branch (658:10): [True: 2, False: 0]
  ------------------
  659|      2|             ? std::string(gtest_output_flag)
  660|      2|             : std::string(gtest_output_flag,
  661|      0|                           static_cast<size_t>(colon - gtest_output_flag));
  662|      2|}
_ZN7testing8internal13GetTestTypeIdEv:
  962|      4|TypeId GetTestTypeId() { return GetTypeId<Test>(); }
_ZN7testing8internal35DefaultGlobalTestPartResultReporterC2EPNS0_12UnitTestImplE:
 1025|      2|    : unit_test_(unit_test) {}
_ZN7testing8internal38DefaultPerThreadTestPartResultReporterC2EPNS0_12UnitTestImplE:
 1035|      2|    : unit_test_(unit_test) {}
_ZNK7testing8internal12UnitTestImpl22total_test_suite_countEv:
 1079|      2|int UnitTestImpl::total_test_suite_count() const {
 1080|      2|  return static_cast<int>(test_suites_.size());
 1081|      2|}
_ZNK7testing8internal12UnitTestImpl23test_suite_to_run_countEv:
 1085|      2|int UnitTestImpl::test_suite_to_run_count() const {
 1086|      2|  return CountIf(test_suites_, ShouldRunTestSuite);
 1087|      2|}
_ZNK7testing8internal12UnitTestImpl17test_to_run_countEv:
 1126|      2|int UnitTestImpl::test_to_run_count() const {
 1127|      2|  return SumOverTestSuiteList(test_suites_, &TestSuite::test_to_run_count);
 1128|      2|}
_ZN7testing8internal15GetTimeInMillisEv:
 1174|      8|TimeInMillis GetTimeInMillis() {
 1175|      8|  return std::chrono::duration_cast<std::chrono::milliseconds>(
 1176|      8|             std::chrono::system_clock::now() -
 1177|      8|             std::chrono::system_clock::from_time_t(0))
 1178|      8|      .count();
 1179|      8|}
_ZN7testing8internal6String13CStringEqualsEPKcS3_:
 1224|      2|bool String::CStringEquals(const char* lhs, const char* rhs) {
 1225|      2|  if (lhs == nullptr) return rhs == nullptr;
  ------------------
  |  Branch (1225:7): [True: 0, False: 2]
  ------------------
 1226|       |
 1227|      2|  if (rhs == nullptr) return false;
  ------------------
  |  Branch (1227:7): [True: 0, False: 2]
  ------------------
 1228|       |
 1229|      2|  return strcmp(lhs, rhs) == 0;
 1230|      2|}
_ZN7testing8internal11SplitStringERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEcPNS1_6vectorIS7_NS5_IS7_EEEE:
 1252|      8|                 ::std::vector< ::std::string>* dest) {
 1253|      8|  ::std::vector< ::std::string> parsed;
 1254|      8|  ::std::string::size_type pos = 0;
 1255|     12|  while (::testing::internal::AlwaysTrue()) {
  ------------------
  |  Branch (1255:10): [True: 12, False: 0]
  ------------------
 1256|     12|    const ::std::string::size_type colon = str.find(delimiter, pos);
 1257|     12|    if (colon == ::std::string::npos) {
  ------------------
  |  Branch (1257:9): [True: 8, False: 4]
  ------------------
 1258|      8|      parsed.push_back(str.substr(pos));
 1259|      8|      break;
 1260|      8|    } else {
 1261|      4|      parsed.push_back(str.substr(pos, colon - pos));
 1262|      4|      pos = colon + 1;
 1263|      4|    }
 1264|     12|  }
 1265|      8|  dest->swap(parsed);
 1266|      8|}
_ZN7testing7MessageC2Ev:
 1275|    118|Message::Message() : ss_(new ::std::stringstream) {
 1276|       |  // By default, we want there to be enough precision when printing
 1277|       |  // a double to a Message.
 1278|    118|  *ss_ << std::setprecision(std::numeric_limits<double>::digits10 + 2);
 1279|    118|}
_ZNK7testing7Message9GetStringEv:
 1301|    118|std::string Message::GetString() const {
 1302|    118|  return internal::StringStreamToString(ss_.get());
 1303|    118|}
_ZN7testing8internal6String28CaseInsensitiveCStringEqualsEPKcS3_:
 2131|      2|bool String::CaseInsensitiveCStringEquals(const char* lhs, const char* rhs) {
 2132|      2|  if (lhs == nullptr) return rhs == nullptr;
  ------------------
  |  Branch (2132:7): [True: 0, False: 2]
  ------------------
 2133|      2|  if (rhs == nullptr) return false;
  ------------------
  |  Branch (2133:7): [True: 0, False: 2]
  ------------------
 2134|      2|  return posix::StrCaseCmp(lhs, rhs) == 0;
 2135|      2|}
_ZN7testing8internal20StringStreamToStringEPNSt3__118basic_stringstreamIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 2216|    118|std::string StringStreamToString(::std::stringstream* ss) {
 2217|    118|  const ::std::string& str = ss->str();
 2218|    118|  const char* const start = str.c_str();
 2219|    118|  const char* const end = start + str.length();
 2220|       |
 2221|    118|  std::string result;
 2222|    118|  result.reserve(static_cast<size_t>(2 * (end - start)));
 2223|  2.83k|  for (const char* ch = start; ch != end; ++ch) {
  ------------------
  |  Branch (2223:32): [True: 2.71k, False: 118]
  ------------------
 2224|  2.71k|    if (*ch == '\0') {
  ------------------
  |  Branch (2224:9): [True: 0, False: 2.71k]
  ------------------
 2225|      0|      result += "\\0";  // Replaces NUL with "\\0";
 2226|  2.71k|    } else {
 2227|  2.71k|      result += *ch;
 2228|  2.71k|    }
 2229|  2.71k|  }
 2230|       |
 2231|    118|  return result;
 2232|    118|}
_ZN7testing10TestResultC2Ev:
 2254|      8|    : death_test_count_(0), start_timestamp_(0), elapsed_time_(0) {}
_ZN7testing10TestResult5ClearEv:
 2400|      6|void TestResult::Clear() {
 2401|      6|  test_part_results_.clear();
 2402|      6|  test_properties_.clear();
 2403|      6|  death_test_count_ = 0;
 2404|      6|  elapsed_time_ = 0;
 2405|      6|}
_ZNK7testing10TestResult7SkippedEv:
 2413|      8|bool TestResult::Skipped() const {
 2414|      8|  return !Failed() && CountIf(test_part_results_, TestPartSkipped) > 0;
  ------------------
  |  Branch (2414:10): [True: 8, False: 0]
  |  Branch (2414:23): [True: 0, False: 8]
  ------------------
 2415|      8|}
_ZNK7testing10TestResult6FailedEv:
 2418|     10|bool TestResult::Failed() const {
 2419|     10|  for (int i = 0; i < total_part_count(); ++i) {
  ------------------
  |  Branch (2419:19): [True: 0, False: 10]
  ------------------
 2420|      0|    if (GetTestPartResult(i).failed()) return true;
  ------------------
  |  Branch (2420:9): [True: 0, False: 0]
  ------------------
 2421|      0|  }
 2422|     10|  return false;
 2423|     10|}
_ZNK7testing10TestResult15HasFatalFailureEv:
 2431|      6|bool TestResult::HasFatalFailure() const {
 2432|      6|  return CountIf(test_part_results_, TestPartFatallyFailed) > 0;
 2433|      6|}
_ZNK7testing10TestResult16total_part_countEv:
 2447|     10|int TestResult::total_part_count() const {
 2448|     10|  return static_cast<int>(test_part_results_.size());
 2449|     10|}
_ZN7testing4TestC2Ev:
 2461|      2|Test::Test() : gtest_flag_saver_(new GTEST_FLAG_SAVER_) {}
  ------------------
  |  | 2291|      2|#define GTEST_FLAG_SAVER_ ::testing::internal::GTestFlagSaver
  ------------------
_ZN7testing4Test5SetUpEv:
 2471|      2|void Test::SetUp() {}
_ZN7testing4Test19HasSameFixtureClassEv:
 2504|      2|bool Test::HasSameFixtureClass() {
 2505|      2|  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
 2506|      2|  const TestSuite* const test_suite = impl->current_test_suite();
 2507|       |
 2508|       |  // Info about the first test in the current test suite.
 2509|      2|  const TestInfo* const first_test_info = test_suite->test_info_list()[0];
 2510|      2|  const internal::TypeId first_fixture_id = first_test_info->fixture_class_id_;
 2511|      2|  const char* const first_test_name = first_test_info->name();
 2512|       |
 2513|       |  // Info about the current test.
 2514|      2|  const TestInfo* const this_test_info = impl->current_test_info();
 2515|      2|  const internal::TypeId this_fixture_id = this_test_info->fixture_class_id_;
 2516|      2|  const char* const this_test_name = this_test_info->name();
 2517|       |
 2518|      2|  if (this_fixture_id != first_fixture_id) {
  ------------------
  |  Branch (2518:7): [True: 0, False: 2]
  ------------------
 2519|       |    // Is the first test defined using TEST?
 2520|      0|    const bool first_is_TEST = first_fixture_id == internal::GetTestTypeId();
 2521|       |    // Is this test defined using TEST?
 2522|      0|    const bool this_is_TEST = this_fixture_id == internal::GetTestTypeId();
 2523|       |
 2524|      0|    if (first_is_TEST || this_is_TEST) {
  ------------------
  |  Branch (2524:9): [True: 0, False: 0]
  |  Branch (2524:26): [True: 0, False: 0]
  ------------------
 2525|       |      // Both TEST and TEST_F appear in same test suite, which is incorrect.
 2526|       |      // Tell the user how to fix this.
 2527|       |
 2528|       |      // Gets the name of the TEST and the name of the TEST_F.  Note
 2529|       |      // that first_is_TEST and this_is_TEST cannot both be true, as
 2530|       |      // the fixture IDs are different for the two tests.
 2531|      0|      const char* const TEST_name =
 2532|      0|          first_is_TEST ? first_test_name : this_test_name;
  ------------------
  |  Branch (2532:11): [True: 0, False: 0]
  ------------------
 2533|      0|      const char* const TEST_F_name =
 2534|      0|          first_is_TEST ? this_test_name : first_test_name;
  ------------------
  |  Branch (2534:11): [True: 0, False: 0]
  ------------------
 2535|       |
 2536|      0|      ADD_FAILURE()
  ------------------
  |  | 1735|      0|#define ADD_FAILURE() GTEST_NONFATAL_FAILURE_("Failed")
  |  |  ------------------
  |  |  |  | 1339|      0|  GTEST_MESSAGE_(message, ::testing::TestPartResult::kNonFatalFailure)
  |  |  |  |  ------------------
  |  |  |  |  |  | 1333|      0|  GTEST_MESSAGE_AT_(__FILE__, __LINE__, message, result_type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1329|      0|  ::testing::internal::AssertHelper(result_type, file, line, message) = \
  |  |  |  |  |  |  |  | 1330|      0|      ::testing::Message()
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2537|      0|          << "All tests in the same test suite must use the same test fixture\n"
 2538|      0|          << "class, so mixing TEST_F and TEST in the same test suite is\n"
 2539|      0|          << "illegal.  In test suite " << this_test_info->test_suite_name()
 2540|      0|          << ",\n"
 2541|      0|          << "test " << TEST_F_name << " is defined using TEST_F but\n"
 2542|      0|          << "test " << TEST_name << " is defined using TEST.  You probably\n"
 2543|      0|          << "want to change the TEST to TEST_F or move it to another test\n"
 2544|      0|          << "case.";
 2545|      0|    } else {
 2546|       |      // Two fixture classes with the same name appear in two different
 2547|       |      // namespaces, which is not allowed. Tell the user how to fix this.
 2548|      0|      ADD_FAILURE()
  ------------------
  |  | 1735|      0|#define ADD_FAILURE() GTEST_NONFATAL_FAILURE_("Failed")
  |  |  ------------------
  |  |  |  | 1339|      0|  GTEST_MESSAGE_(message, ::testing::TestPartResult::kNonFatalFailure)
  |  |  |  |  ------------------
  |  |  |  |  |  | 1333|      0|  GTEST_MESSAGE_AT_(__FILE__, __LINE__, message, result_type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1329|      0|  ::testing::internal::AssertHelper(result_type, file, line, message) = \
  |  |  |  |  |  |  |  | 1330|      0|      ::testing::Message()
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2549|      0|          << "All tests in the same test suite must use the same test fixture\n"
 2550|      0|          << "class.  However, in test suite "
 2551|      0|          << this_test_info->test_suite_name() << ",\n"
 2552|      0|          << "you defined test " << first_test_name << " and test "
 2553|      0|          << this_test_name << "\n"
 2554|      0|          << "using two different test fixture classes.  This can happen if\n"
 2555|      0|          << "the two classes are from different namespaces or translation\n"
 2556|      0|          << "units and have the same name.  You should probably rename one\n"
 2557|      0|          << "of the classes to put the tests into different test suites.";
 2558|      0|    }
 2559|      0|    return false;
 2560|      0|  }
 2561|       |
 2562|      2|  return true;
 2563|      2|}
_ZN7testing4Test3RunEv:
 2677|      2|void Test::Run() {
 2678|      2|  if (!HasSameFixtureClass()) return;
  ------------------
  |  Branch (2678:7): [True: 0, False: 2]
  ------------------
 2679|       |
 2680|      2|  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
 2681|      2|  impl->os_stack_trace_getter()->UponLeavingGTest();
 2682|      2|  internal::HandleExceptionsInMethodIfSupported(this, &Test::SetUp, "SetUp()");
 2683|       |  // We will run the test only if SetUp() was successful and didn't call
 2684|       |  // GTEST_SKIP().
 2685|      2|  if (!HasFatalFailure() && !IsSkipped()) {
  ------------------
  |  Branch (2685:7): [True: 2, False: 0]
  |  Branch (2685:29): [True: 2, False: 0]
  ------------------
 2686|      2|    impl->os_stack_trace_getter()->UponLeavingGTest();
 2687|      2|    internal::HandleExceptionsInMethodIfSupported(this, &Test::TestBody,
 2688|      2|                                                  "the test body");
 2689|      2|  }
 2690|       |
 2691|       |  // However, we want to clean up as much as possible.  Hence we will
 2692|       |  // always call TearDown(), even if SetUp() or the test body has
 2693|       |  // failed.
 2694|      2|  impl->os_stack_trace_getter()->UponLeavingGTest();
 2695|      2|  internal::HandleExceptionsInMethodIfSupported(this, &Test::TearDown,
 2696|      2|                                                "TearDown()");
 2697|      2|}
_ZN7testing4Test15HasFatalFailureEv:
 2700|      6|bool Test::HasFatalFailure() {
 2701|      6|  return internal::GetUnitTestImpl()->current_test_result()->HasFatalFailure();
 2702|      6|}
_ZN7testing4Test9IsSkippedEv:
 2712|      6|bool Test::IsSkipped() {
 2713|      6|  return internal::GetUnitTestImpl()->current_test_result()->Skipped();
 2714|      6|}
_ZN7testing8TestInfoC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_PKcSB_NS_8internal12CodeLocationEPKvPNSC_15TestFactoryBaseE:
 2726|      4|    : test_suite_name_(a_test_suite_name),
 2727|       |      // begin()/end() is MSVC 17.3.3 ASAN crash workaround (GitHub issue #3997)
 2728|      4|      name_(a_name.begin(), a_name.end()),
 2729|      4|      type_param_(a_type_param ? new std::string(a_type_param) : nullptr),
  ------------------
  |  Branch (2729:19): [True: 0, False: 4]
  ------------------
 2730|      4|      value_param_(a_value_param ? new std::string(a_value_param) : nullptr),
  ------------------
  |  Branch (2730:20): [True: 0, False: 4]
  ------------------
 2731|      4|      location_(a_code_location),
 2732|      4|      fixture_class_id_(fixture_class_id),
 2733|      4|      should_run_(false),
 2734|      4|      is_disabled_(false),
 2735|      4|      matches_filter_(false),
 2736|      4|      is_in_another_shard_(false),
 2737|      4|      factory_(factory),
 2738|      4|      result_() {}
_ZN7testing8internal23MakeAndRegisterTestInfoEPKcS2_S2_S2_NS0_12CodeLocationEPKvPFvvES7_PNS0_15TestFactoryBaseE:
 2767|      4|    TearDownTestSuiteFunc tear_down_tc, TestFactoryBase* factory) {
 2768|      4|  TestInfo* const test_info =
 2769|      4|      new TestInfo(test_suite_name, name, type_param, value_param,
 2770|      4|                   code_location, fixture_class_id, factory);
 2771|      4|  GetUnitTestImpl()->AddTestInfo(set_up_tc, tear_down_tc, test_info);
 2772|      4|  return test_info;
 2773|      4|}
_ZN7testing8internal12UnitTestImpl26RegisterParameterizedTestsEv:
 2796|      2|void UnitTestImpl::RegisterParameterizedTests() {
 2797|      2|  if (!parameterized_tests_registered_) {
  ------------------
  |  Branch (2797:7): [True: 2, False: 0]
  ------------------
 2798|      2|    parameterized_test_registry_.RegisterTests();
 2799|      2|    type_parameterized_test_registry_.CheckForInstantiations();
 2800|      2|    parameterized_tests_registered_ = true;
 2801|      2|  }
 2802|      2|}
_ZN7testing8TestInfo3RunEv:
 2808|      2|void TestInfo::Run() {
 2809|      2|  TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
 2810|      2|  if (!should_run_) {
  ------------------
  |  Branch (2810:7): [True: 0, False: 2]
  ------------------
 2811|      0|    if (is_disabled_ && matches_filter_) repeater->OnTestDisabled(*this);
  ------------------
  |  Branch (2811:9): [True: 0, False: 0]
  |  Branch (2811:25): [True: 0, False: 0]
  ------------------
 2812|      0|    return;
 2813|      0|  }
 2814|       |
 2815|       |  // Tells UnitTest where to store test result.
 2816|      2|  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
 2817|      2|  impl->set_current_test_info(this);
 2818|       |
 2819|       |  // Notifies the unit test event listeners that a test is about to start.
 2820|      2|  repeater->OnTestStart(*this);
 2821|      2|  result_.set_start_timestamp(internal::GetTimeInMillis());
 2822|      2|  internal::Timer timer;
 2823|      2|  impl->os_stack_trace_getter()->UponLeavingGTest();
 2824|       |
 2825|       |  // Creates the test object.
 2826|      2|  Test* const test = internal::HandleExceptionsInMethodIfSupported(
 2827|      2|      factory_, &internal::TestFactoryBase::CreateTest,
 2828|      2|      "the test fixture's constructor");
 2829|       |
 2830|       |  // Runs the test if the constructor didn't generate a fatal failure or invoke
 2831|       |  // GTEST_SKIP().
 2832|       |  // Note that the object will not be null
 2833|      2|  if (!Test::HasFatalFailure() && !Test::IsSkipped()) {
  ------------------
  |  Branch (2833:7): [True: 2, False: 0]
  |  Branch (2833:35): [True: 2, False: 0]
  ------------------
 2834|       |    // This doesn't throw as all user code that can throw are wrapped into
 2835|       |    // exception handling code.
 2836|      2|    test->Run();
 2837|      2|  }
 2838|       |
 2839|      2|  if (test != nullptr) {
  ------------------
  |  Branch (2839:7): [True: 0, False: 2]
  ------------------
 2840|       |    // Deletes the test object.
 2841|      0|    impl->os_stack_trace_getter()->UponLeavingGTest();
 2842|      0|    internal::HandleExceptionsInMethodIfSupported(
 2843|      0|        test, &Test::DeleteSelf_, "the test fixture's destructor");
 2844|      0|  }
 2845|       |
 2846|      2|  result_.set_elapsed_time(timer.Elapsed());
 2847|       |
 2848|       |  // Notifies the unit test event listener that a test has just finished.
 2849|      2|  repeater->OnTestEnd(*this);
 2850|       |
 2851|       |  // Tells UnitTest to stop associating assertion results to this
 2852|       |  // test.
 2853|      2|  impl->set_current_test_info(nullptr);
 2854|      2|}
_ZNK7testing9TestSuite17test_to_run_countEv:
 2911|      4|int TestSuite::test_to_run_count() const {
 2912|      4|  return CountIf(test_info_list_, ShouldRunTest);
 2913|      4|}
_ZNK7testing9TestSuite16total_test_countEv:
 2916|      2|int TestSuite::total_test_count() const {
 2917|      2|  return static_cast<int>(test_info_list_.size());
 2918|      2|}
_ZN7testing9TestSuiteC2EPKcS2_PFvvES4_:
 2932|      2|    : name_(a_name),
 2933|      2|      type_param_(a_type_param ? new std::string(a_type_param) : nullptr),
  ------------------
  |  Branch (2933:19): [True: 0, False: 2]
  ------------------
 2934|      2|      set_up_tc_(set_up_tc),
 2935|      2|      tear_down_tc_(tear_down_tc),
 2936|      2|      should_run_(false),
 2937|      2|      start_timestamp_(0),
 2938|      2|      elapsed_time_(0) {}
_ZN7testing9TestSuite18GetMutableTestInfoEi:
 2955|      2|TestInfo* TestSuite::GetMutableTestInfo(int i) {
 2956|      2|  const int index = GetElementOr(test_indices_, i, -1);
 2957|      2|  return index < 0 ? nullptr : test_info_list_[static_cast<size_t>(index)];
  ------------------
  |  Branch (2957:10): [True: 0, False: 2]
  ------------------
 2958|      2|}
_ZN7testing9TestSuite11AddTestInfoEPNS_8TestInfoE:
 2962|      4|void TestSuite::AddTestInfo(TestInfo* test_info) {
 2963|      4|  test_info_list_.push_back(test_info);
 2964|      4|  test_indices_.push_back(static_cast<int>(test_indices_.size()));
 2965|      4|}
_ZN7testing9TestSuite3RunEv:
 2968|      2|void TestSuite::Run() {
 2969|      2|  if (!should_run_) return;
  ------------------
  |  Branch (2969:7): [True: 0, False: 2]
  ------------------
 2970|       |
 2971|      2|  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
 2972|      2|  impl->set_current_test_suite(this);
 2973|       |
 2974|      2|  TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
 2975|       |
 2976|       |  // Ensure our tests are in a deterministic order.
 2977|       |  //
 2978|       |  // We do this by sorting lexicographically on (file, line number), providing
 2979|       |  // an order matching what the user can see in the source code.
 2980|       |  //
 2981|       |  // In the common case the line number comparison shouldn't be necessary,
 2982|       |  // because the registrations made by the TEST macro are executed in order
 2983|       |  // within a translation unit. But this is not true of the manual registration
 2984|       |  // API, and in more exotic scenarios a single file may be part of multiple
 2985|       |  // translation units.
 2986|      2|  std::stable_sort(test_info_list_.begin(), test_info_list_.end(),
 2987|      2|                   [](const TestInfo* const a, const TestInfo* const b) {
 2988|      2|                     if (const int result = std::strcmp(a->file(), b->file())) {
 2989|      2|                       return result < 0;
 2990|      2|                     }
 2991|       |
 2992|      2|                     return a->line() < b->line();
 2993|      2|                   });
 2994|       |
 2995|       |  // Call both legacy and the new API
 2996|      2|  repeater->OnTestSuiteStart(*this);
 2997|       |//  Legacy API is deprecated but still available
 2998|      2|#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
 2999|      2|  repeater->OnTestCaseStart(*this);
 3000|      2|#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
 3001|       |
 3002|      2|  impl->os_stack_trace_getter()->UponLeavingGTest();
 3003|      2|  internal::HandleExceptionsInMethodIfSupported(
 3004|      2|      this, &TestSuite::RunSetUpTestSuite, "SetUpTestSuite()");
 3005|       |
 3006|      2|  const bool skip_all =
 3007|      2|      ad_hoc_test_result().Failed() || ad_hoc_test_result().Skipped();
  ------------------
  |  Branch (3007:7): [True: 0, False: 2]
  |  Branch (3007:40): [True: 0, False: 2]
  ------------------
 3008|       |
 3009|      2|  start_timestamp_ = internal::GetTimeInMillis();
 3010|      2|  internal::Timer timer;
 3011|      4|  for (int i = 0; i < total_test_count(); i++) {
  ------------------
  |  Branch (3011:19): [True: 2, False: 2]
  ------------------
 3012|      2|    if (skip_all) {
  ------------------
  |  Branch (3012:9): [True: 0, False: 2]
  ------------------
 3013|      0|      GetMutableTestInfo(i)->Skip();
 3014|      2|    } else {
 3015|      2|      GetMutableTestInfo(i)->Run();
 3016|      2|    }
 3017|      2|    if (GTEST_FLAG_GET(fail_fast) &&
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  |  |  |  Branch (2293:30): [True: 0, False: 2]
  |  |  ------------------
  ------------------
 3018|      0|        GetMutableTestInfo(i)->result()->Failed()) {
  ------------------
  |  Branch (3018:9): [True: 0, False: 0]
  ------------------
 3019|      0|      for (int j = i + 1; j < total_test_count(); j++) {
  ------------------
  |  Branch (3019:27): [True: 0, False: 0]
  ------------------
 3020|      0|        GetMutableTestInfo(j)->Skip();
 3021|      0|      }
 3022|      0|      break;
 3023|      0|    }
 3024|      2|  }
 3025|      2|  elapsed_time_ = timer.Elapsed();
 3026|       |
 3027|      2|  impl->os_stack_trace_getter()->UponLeavingGTest();
 3028|      2|  internal::HandleExceptionsInMethodIfSupported(
 3029|      2|      this, &TestSuite::RunTearDownTestSuite, "TearDownTestSuite()");
 3030|       |
 3031|       |  // Call both legacy and the new API
 3032|      2|  repeater->OnTestSuiteEnd(*this);
 3033|       |//  Legacy API is deprecated but still available
 3034|      2|#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
 3035|      2|  repeater->OnTestCaseEnd(*this);
 3036|      2|#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
 3037|       |
 3038|      2|  impl->set_current_test_suite(nullptr);
 3039|      2|}
_ZN7testing9TestSuite11ClearResultEv:
 3072|      2|void TestSuite::ClearResult() {
 3073|      2|  ad_hoc_test_result_.Clear();
 3074|      2|  ForEach(test_info_list_, TestInfo::ClearTestResult);
 3075|      2|}
_ZN7testing8internal14ShouldUseColorEb:
 3238|      2|bool ShouldUseColor(bool stdout_is_tty) {
 3239|      2|  std::string c = GTEST_FLAG_GET(color);
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
 3240|      2|  const char* const gtest_color = c.c_str();
 3241|       |
 3242|      2|  if (String::CaseInsensitiveCStringEquals(gtest_color, "auto")) {
  ------------------
  |  Branch (3242:7): [True: 2, False: 0]
  ------------------
 3243|       |#if defined(GTEST_OS_WINDOWS) && !defined(GTEST_OS_WINDOWS_MINGW)
 3244|       |    // On Windows the TERM variable is usually not set, but the
 3245|       |    // console there does support colors.
 3246|       |    return stdout_is_tty;
 3247|       |#else
 3248|       |    // On non-Windows platforms, we rely on the TERM variable.
 3249|      2|    const char* const term = posix::GetEnv("TERM");
 3250|      2|    const bool term_supports_color =
 3251|      2|        term != nullptr && (String::CStringEquals(term, "xterm") ||
  ------------------
  |  Branch (3251:9): [True: 0, False: 2]
  |  Branch (3251:29): [True: 0, False: 0]
  ------------------
 3252|      0|                            String::CStringEquals(term, "xterm-color") ||
  ------------------
  |  Branch (3252:29): [True: 0, False: 0]
  ------------------
 3253|      0|                            String::CStringEquals(term, "xterm-kitty") ||
  ------------------
  |  Branch (3253:29): [True: 0, False: 0]
  ------------------
 3254|      0|                            String::CStringEquals(term, "screen") ||
  ------------------
  |  Branch (3254:29): [True: 0, False: 0]
  ------------------
 3255|      0|                            String::CStringEquals(term, "tmux") ||
  ------------------
  |  Branch (3255:29): [True: 0, False: 0]
  ------------------
 3256|      0|                            String::CStringEquals(term, "rxvt-unicode") ||
  ------------------
  |  Branch (3256:29): [True: 0, False: 0]
  ------------------
 3257|      0|                            String::CStringEquals(term, "linux") ||
  ------------------
  |  Branch (3257:29): [True: 0, False: 0]
  ------------------
 3258|      0|                            String::CStringEquals(term, "cygwin") ||
  ------------------
  |  Branch (3258:29): [True: 0, False: 0]
  ------------------
 3259|      0|                            String::EndsWithCaseInsensitive(term, "-256color"));
  ------------------
  |  Branch (3259:29): [True: 0, False: 0]
  ------------------
 3260|      2|    return stdout_is_tty && term_supports_color;
  ------------------
  |  Branch (3260:12): [True: 0, False: 2]
  |  Branch (3260:29): [True: 0, False: 0]
  ------------------
 3261|      2|#endif  // GTEST_OS_WINDOWS
 3262|      2|  }
 3263|       |
 3264|      0|  return String::CaseInsensitiveCStringEquals(gtest_color, "yes") ||
  ------------------
  |  Branch (3264:10): [True: 0, False: 0]
  ------------------
 3265|      0|         String::CaseInsensitiveCStringEquals(gtest_color, "true") ||
  ------------------
  |  Branch (3265:10): [True: 0, False: 0]
  ------------------
 3266|      0|         String::CaseInsensitiveCStringEquals(gtest_color, "t") ||
  ------------------
  |  Branch (3266:10): [True: 0, False: 0]
  ------------------
 3267|      0|         String::CStringEquals(gtest_color, "1");
  ------------------
  |  Branch (3267:10): [True: 0, False: 0]
  ------------------
 3268|       |  // We take "yes", "true", "t", and "1" as meaning "yes".  If the
 3269|       |  // value is neither one of these nor "auto", we treat it as "no" to
 3270|       |  // be conservative.
 3271|      2|}
_ZN7testing8internal27PrettyUnitTestResultPrinter20OnTestIterationStartERKNS_8UnitTestEi:
 3394|      2|    const UnitTest& unit_test, int iteration) {
 3395|      2|  if (GTEST_FLAG_GET(repeat) != 1)
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  |  Branch (3395:7): [True: 0, False: 2]
  ------------------
 3396|      0|    printf("\nRepeating all tests (iteration %d) . . .\n\n", iteration + 1);
 3397|       |
 3398|      2|  std::string f = GTEST_FLAG_GET(filter);
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
 3399|      2|  const char* const filter = f.c_str();
 3400|       |
 3401|       |  // Prints the filter if it's not *.  This reminds the user that some
 3402|       |  // tests may be skipped.
 3403|      2|  if (!String::CStringEquals(filter, kUniversalFilter)) {
  ------------------
  |  Branch (3403:7): [True: 2, False: 0]
  ------------------
 3404|      2|    ColoredPrintf(GTestColor::kYellow, "Note: %s filter = %s\n", GTEST_NAME_,
  ------------------
  |  |  334|      2|#define GTEST_NAME_ "Google Test"
  ------------------
 3405|      2|                  filter);
 3406|      2|  }
 3407|       |
 3408|      2|  if (internal::ShouldShard(kTestTotalShards, kTestShardIndex, false)) {
  ------------------
  |  Branch (3408:7): [True: 0, False: 2]
  ------------------
 3409|      0|    const int32_t shard_index = Int32FromEnvOrDie(kTestShardIndex, -1);
 3410|      0|    ColoredPrintf(GTestColor::kYellow, "Note: This is test shard %d of %s.\n",
 3411|      0|                  static_cast<int>(shard_index) + 1,
 3412|      0|                  internal::posix::GetEnv(kTestTotalShards));
 3413|      0|  }
 3414|       |
 3415|      2|  if (GTEST_FLAG_GET(shuffle)) {
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  |  |  |  Branch (2293:30): [True: 0, False: 2]
  |  |  ------------------
  ------------------
 3416|      0|    ColoredPrintf(GTestColor::kYellow,
 3417|      0|                  "Note: Randomizing tests' orders with a seed of %d .\n",
 3418|      0|                  unit_test.random_seed());
 3419|      0|  }
 3420|       |
 3421|      2|  ColoredPrintf(GTestColor::kGreen, "[==========] ");
 3422|      2|  printf("Running %s from %s.\n",
 3423|      2|         FormatTestCount(unit_test.test_to_run_count()).c_str(),
 3424|      2|         FormatTestSuiteCount(unit_test.test_suite_to_run_count()).c_str());
 3425|       |  fflush(stdout);
 3426|      2|}
_ZN7testing8internal27PrettyUnitTestResultPrinter24OnEnvironmentsSetUpStartERKNS_8UnitTestE:
 3429|      2|    const UnitTest& /*unit_test*/) {
 3430|      2|  ColoredPrintf(GTestColor::kGreen, "[----------] ");
 3431|      2|  printf("Global test environment set-up.\n");
 3432|       |  fflush(stdout);
 3433|      2|}
_ZN7testing8internal27PrettyUnitTestResultPrinter15OnTestCaseStartERKNS_9TestSuiteE:
 3436|      2|void PrettyUnitTestResultPrinter::OnTestCaseStart(const TestCase& test_case) {
 3437|      2|  const std::string counts =
 3438|      2|      FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
 3439|      2|  ColoredPrintf(GTestColor::kGreen, "[----------] ");
 3440|      2|  printf("%s from %s", counts.c_str(), test_case.name());
 3441|      2|  if (test_case.type_param() == nullptr) {
  ------------------
  |  Branch (3441:7): [True: 2, False: 0]
  ------------------
 3442|      2|    printf("\n");
 3443|      2|  } else {
 3444|      0|    printf(", where %s = %s\n", kTypeParamLabel, test_case.type_param());
 3445|      0|  }
 3446|       |  fflush(stdout);
 3447|      2|}
_ZN7testing8internal27PrettyUnitTestResultPrinter11OnTestStartERKNS_8TestInfoE:
 3464|      2|void PrettyUnitTestResultPrinter::OnTestStart(const TestInfo& test_info) {
 3465|      2|  ColoredPrintf(GTestColor::kGreen, "[ RUN      ] ");
 3466|      2|  PrintTestName(test_info.test_suite_name(), test_info.name());
 3467|      2|  printf("\n");
 3468|       |  fflush(stdout);
 3469|      2|}
_ZN7testing8internal17TestEventRepeater6AppendEPNS_17TestEventListenerE:
 3815|      6|void TestEventRepeater::Append(TestEventListener* listener) {
 3816|      6|  listeners_.push_back(listener);
 3817|      6|}
_ZN7testing8internal17TestEventRepeater7ReleaseEPNS_17TestEventListenerE:
 3819|      2|TestEventListener* TestEventRepeater::Release(TestEventListener* listener) {
 3820|      2|  for (size_t i = 0; i < listeners_.size(); ++i) {
  ------------------
  |  Branch (3820:22): [True: 0, False: 2]
  ------------------
 3821|      0|    if (listeners_[i] == listener) {
  ------------------
  |  Branch (3821:9): [True: 0, False: 0]
  ------------------
 3822|      0|      listeners_.erase(listeners_.begin() + static_cast<int>(i));
 3823|      0|      return listener;
 3824|      0|    }
 3825|      0|  }
 3826|       |
 3827|      2|  return nullptr;
 3828|      2|}
_ZN7testing8internal17TestEventRepeater18OnTestProgramStartERKNS_8UnitTestE:
 3833|      2|  void TestEventRepeater::Name(const Type& parameter) { \
 3834|      2|    if (forwarding_enabled_) {                          \
  ------------------
  |  Branch (3834:9): [True: 2, False: 0]
  ------------------
 3835|      8|      for (size_t i = 0; i < listeners_.size(); i++) {  \
  ------------------
  |  Branch (3835:26): [True: 6, False: 2]
  ------------------
 3836|      6|        listeners_[i]->Name(parameter);                 \
 3837|      6|      }                                                 \
 3838|      2|    }                                                   \
 3839|      2|  }
_ZN7testing8internal17TestEventRepeater24OnEnvironmentsSetUpStartERKNS_8UnitTestE:
 3833|      2|  void TestEventRepeater::Name(const Type& parameter) { \
 3834|      2|    if (forwarding_enabled_) {                          \
  ------------------
  |  Branch (3834:9): [True: 2, False: 0]
  ------------------
 3835|      8|      for (size_t i = 0; i < listeners_.size(); i++) {  \
  ------------------
  |  Branch (3835:26): [True: 6, False: 2]
  ------------------
 3836|      6|        listeners_[i]->Name(parameter);                 \
 3837|      6|      }                                                 \
 3838|      2|    }                                                   \
 3839|      2|  }
_ZN7testing8internal17TestEventRepeater15OnTestCaseStartERKNS_9TestSuiteE:
 3833|      2|  void TestEventRepeater::Name(const Type& parameter) { \
 3834|      2|    if (forwarding_enabled_) {                          \
  ------------------
  |  Branch (3834:9): [True: 2, False: 0]
  ------------------
 3835|      8|      for (size_t i = 0; i < listeners_.size(); i++) {  \
  ------------------
  |  Branch (3835:26): [True: 6, False: 2]
  ------------------
 3836|      6|        listeners_[i]->Name(parameter);                 \
 3837|      6|      }                                                 \
 3838|      2|    }                                                   \
 3839|      2|  }
_ZN7testing8internal17TestEventRepeater16OnTestSuiteStartERKNS_9TestSuiteE:
 3833|      2|  void TestEventRepeater::Name(const Type& parameter) { \
 3834|      2|    if (forwarding_enabled_) {                          \
  ------------------
  |  Branch (3834:9): [True: 2, False: 0]
  ------------------
 3835|      8|      for (size_t i = 0; i < listeners_.size(); i++) {  \
  ------------------
  |  Branch (3835:26): [True: 6, False: 2]
  ------------------
 3836|      6|        listeners_[i]->Name(parameter);                 \
 3837|      6|      }                                                 \
 3838|      2|    }                                                   \
 3839|      2|  }
_ZN7testing8internal17TestEventRepeater11OnTestStartERKNS_8TestInfoE:
 3833|      2|  void TestEventRepeater::Name(const Type& parameter) { \
 3834|      2|    if (forwarding_enabled_) {                          \
  ------------------
  |  Branch (3834:9): [True: 2, False: 0]
  ------------------
 3835|      8|      for (size_t i = 0; i < listeners_.size(); i++) {  \
  ------------------
  |  Branch (3835:26): [True: 6, False: 2]
  ------------------
 3836|      6|        listeners_[i]->Name(parameter);                 \
 3837|      6|      }                                                 \
 3838|      2|    }                                                   \
 3839|      2|  }
_ZN7testing8internal17TestEventRepeater22OnEnvironmentsSetUpEndERKNS_8UnitTestE:
 3843|      2|  void TestEventRepeater::Name(const Type& parameter) { \
 3844|      2|    if (forwarding_enabled_) {                          \
  ------------------
  |  Branch (3844:9): [True: 2, False: 0]
  ------------------
 3845|      8|      for (size_t i = listeners_.size(); i != 0; i--) { \
  ------------------
  |  Branch (3845:42): [True: 6, False: 2]
  ------------------
 3846|      6|        listeners_[i - 1]->Name(parameter);             \
 3847|      6|      }                                                 \
 3848|      2|    }                                                   \
 3849|      2|  }
_ZN7testing8internal17TestEventRepeater20OnTestIterationStartERKNS_8UnitTestEi:
 3876|      2|                                             int iteration) {
 3877|      2|  if (forwarding_enabled_) {
  ------------------
  |  Branch (3877:7): [True: 2, False: 0]
  ------------------
 3878|      8|    for (size_t i = 0; i < listeners_.size(); i++) {
  ------------------
  |  Branch (3878:24): [True: 6, False: 2]
  ------------------
 3879|      6|      listeners_[i]->OnTestIterationStart(unit_test, iteration);
 3880|      6|    }
 3881|      2|  }
 3882|      2|}
_ZN7testing8internal18OsStackTraceGetter16UponLeavingGTestEv:
 5021|      8|void OsStackTraceGetter::UponLeavingGTest() GTEST_LOCK_EXCLUDED_(mutex_) {
 5022|       |#ifdef GTEST_HAS_ABSL
 5023|       |  void* caller_frame = nullptr;
 5024|       |  if (absl::GetStackTrace(&caller_frame, 1, 3) <= 0) {
 5025|       |    caller_frame = nullptr;
 5026|       |  }
 5027|       |
 5028|       |  MutexLock lock(&mutex_);
 5029|       |  caller_frame_ = caller_frame;
 5030|       |#endif  // GTEST_HAS_ABSL
 5031|      8|}
_ZN7testing18TestEventListenersC2Ev:
 5078|      2|    : repeater_(new internal::TestEventRepeater()),
 5079|      2|      default_result_printer_(nullptr),
 5080|      2|      default_xml_generator_(nullptr) {}
_ZN7testing18TestEventListeners6AppendEPNS_17TestEventListenerE:
 5088|      6|void TestEventListeners::Append(TestEventListener* listener) {
 5089|      6|  repeater_->Append(listener);
 5090|      6|}
_ZN7testing18TestEventListeners7ReleaseEPNS_17TestEventListenerE:
 5095|      2|TestEventListener* TestEventListeners::Release(TestEventListener* listener) {
 5096|      2|  if (listener == default_result_printer_)
  ------------------
  |  Branch (5096:7): [True: 2, False: 0]
  ------------------
 5097|      2|    default_result_printer_ = nullptr;
 5098|      0|  else if (listener == default_xml_generator_)
  ------------------
  |  Branch (5098:12): [True: 0, False: 0]
  ------------------
 5099|      0|    default_xml_generator_ = nullptr;
 5100|      2|  return repeater_->Release(listener);
 5101|      2|}
_ZN7testing18TestEventListeners8repeaterEv:
 5105|      6|TestEventListener* TestEventListeners::repeater() { return repeater_; }
_ZN7testing18TestEventListeners23SetDefaultResultPrinterEPNS_17TestEventListenerE:
 5112|      2|void TestEventListeners::SetDefaultResultPrinter(TestEventListener* listener) {
 5113|      2|  if (default_result_printer_ != listener) {
  ------------------
  |  Branch (5113:7): [True: 2, False: 0]
  ------------------
 5114|       |    // It is an error to pass this method a listener that is already in the
 5115|       |    // list.
 5116|      2|    delete Release(default_result_printer_);
 5117|      2|    default_result_printer_ = listener;
 5118|      2|    if (listener != nullptr) Append(listener);
  ------------------
  |  Branch (5118:9): [True: 2, False: 0]
  ------------------
 5119|      2|  }
 5120|      2|}
_ZN7testing8UnitTest11GetInstanceEv:
 5156|     48|UnitTest* UnitTest::GetInstance() {
 5157|       |  // CodeGear C++Builder insists on a public destructor for the
 5158|       |  // default implementation.  Use this implementation to keep good OO
 5159|       |  // design with private destructor.
 5160|       |
 5161|       |#if defined(__BORLANDC__)
 5162|       |  static UnitTest* const instance = new UnitTest;
 5163|       |  return instance;
 5164|       |#else
 5165|     48|  static UnitTest instance;
 5166|     48|  return &instance;
 5167|     48|#endif  // defined(__BORLANDC__)
 5168|     48|}
_ZNK7testing8UnitTest23test_suite_to_run_countEv:
 5187|      2|int UnitTest::test_suite_to_run_count() const {
 5188|      2|  return impl()->test_suite_to_run_count();
 5189|      2|}
_ZNK7testing8UnitTest17test_to_run_countEv:
 5239|      2|int UnitTest::test_to_run_count() const { return impl()->test_to_run_count(); }
_ZN7testing8UnitTest9listenersEv:
 5287|      8|TestEventListeners& UnitTest::listeners() { return *impl()->listeners(); }
_ZN7testing8UnitTest3RunEv:
 5399|      2|int UnitTest::Run() {
 5400|      2|#ifdef GTEST_HAS_DEATH_TEST
 5401|      2|  const bool in_death_test_child_process =
 5402|      2|      GTEST_FLAG_GET(internal_run_death_test).length() > 0;
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
 5403|       |
 5404|       |  // Google Test implements this protocol for catching that a test
 5405|       |  // program exits before returning control to Google Test:
 5406|       |  //
 5407|       |  //   1. Upon start, Google Test creates a file whose absolute path
 5408|       |  //      is specified by the environment variable
 5409|       |  //      TEST_PREMATURE_EXIT_FILE.
 5410|       |  //   2. When Google Test has finished its work, it deletes the file.
 5411|       |  //
 5412|       |  // This allows a test runner to set TEST_PREMATURE_EXIT_FILE before
 5413|       |  // running a Google-Test-based test program and check the existence
 5414|       |  // of the file at the end of the test execution to see if it has
 5415|       |  // exited prematurely.
 5416|       |
 5417|       |  // If we are in the child process of a death test, don't
 5418|       |  // create/delete the premature exit file, as doing so is unnecessary
 5419|       |  // and will confuse the parent process.  Otherwise, create/delete
 5420|       |  // the file upon entering/leaving this function.  If the program
 5421|       |  // somehow exits before this function has a chance to return, the
 5422|       |  // premature-exit file will be left undeleted, causing a test runner
 5423|       |  // that understands the premature-exit-file protocol to report the
 5424|       |  // test as having failed.
 5425|      2|  const internal::ScopedPrematureExitFile premature_exit_file(
 5426|      2|      in_death_test_child_process
  ------------------
  |  Branch (5426:7): [True: 0, False: 2]
  ------------------
 5427|      2|          ? nullptr
 5428|      2|          : internal::posix::GetEnv("TEST_PREMATURE_EXIT_FILE"));
 5429|       |#else
 5430|       |  const bool in_death_test_child_process = false;
 5431|       |#endif  // GTEST_HAS_DEATH_TEST
 5432|       |
 5433|       |  // Captures the value of GTEST_FLAG(catch_exceptions).  This value will be
 5434|       |  // used for the duration of the program.
 5435|      2|  impl()->set_catch_exceptions(GTEST_FLAG_GET(catch_exceptions));
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
 5436|       |
 5437|       |#ifdef GTEST_OS_WINDOWS
 5438|       |  // Either the user wants Google Test to catch exceptions thrown by the
 5439|       |  // tests or this is executing in the context of death test child
 5440|       |  // process. In either case the user does not want to see pop-up dialogs
 5441|       |  // about crashes - they are expected.
 5442|       |  if (impl()->catch_exceptions() || in_death_test_child_process) {
 5443|       |#if !defined(GTEST_OS_WINDOWS_MOBILE) && !defined(GTEST_OS_WINDOWS_PHONE) && \
 5444|       |    !defined(GTEST_OS_WINDOWS_RT)
 5445|       |    // SetErrorMode doesn't exist on CE.
 5446|       |    SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOALIGNMENTFAULTEXCEPT |
 5447|       |                 SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX);
 5448|       |#endif  // !GTEST_OS_WINDOWS_MOBILE
 5449|       |
 5450|       |#if (defined(_MSC_VER) || defined(GTEST_OS_WINDOWS_MINGW)) && \
 5451|       |    !defined(GTEST_OS_WINDOWS_MOBILE)
 5452|       |    // Death test children can be terminated with _abort().  On Windows,
 5453|       |    // _abort() can show a dialog with a warning message.  This forces the
 5454|       |    // abort message to go to stderr instead.
 5455|       |    _set_error_mode(_OUT_TO_STDERR);
 5456|       |#endif
 5457|       |
 5458|       |#if defined(_MSC_VER) && !defined(GTEST_OS_WINDOWS_MOBILE)
 5459|       |    // In the debug version, Visual Studio pops up a separate dialog
 5460|       |    // offering a choice to debug the aborted program. We need to suppress
 5461|       |    // this dialog or it will pop up for every EXPECT/ASSERT_DEATH statement
 5462|       |    // executed. Google Test will notify the user of any unexpected
 5463|       |    // failure via stderr.
 5464|       |    if (!GTEST_FLAG_GET(break_on_failure))
 5465|       |      _set_abort_behavior(
 5466|       |          0x0,                                    // Clear the following flags:
 5467|       |          _WRITE_ABORT_MSG | _CALL_REPORTFAULT);  // pop-up window, core dump.
 5468|       |
 5469|       |    // In debug mode, the Windows CRT can crash with an assertion over invalid
 5470|       |    // input (e.g. passing an invalid file descriptor).  The default handling
 5471|       |    // for these assertions is to pop up a dialog and wait for user input.
 5472|       |    // Instead ask the CRT to dump such assertions to stderr non-interactively.
 5473|       |    if (!IsDebuggerPresent()) {
 5474|       |      (void)_CrtSetReportMode(_CRT_ASSERT,
 5475|       |                              _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
 5476|       |      (void)_CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
 5477|       |    }
 5478|       |#endif
 5479|       |  }
 5480|       |#else
 5481|      2|  (void)in_death_test_child_process;  // Needed inside the #if block above
 5482|      2|#endif  // GTEST_OS_WINDOWS
 5483|       |
 5484|      2|  return internal::HandleExceptionsInMethodIfSupported(
  ------------------
  |  Branch (5484:10): [True: 0, False: 2]
  ------------------
 5485|      2|             impl(), &internal::UnitTestImpl::RunAllTests,
 5486|      2|             "auxiliary test code (environments or event listeners)")
 5487|      2|             ? 0
 5488|      2|             : 1;
 5489|      2|}
_ZN7testing8UnitTestC2Ev:
 5535|      2|UnitTest::UnitTest() { impl_ = new internal::UnitTestImpl(this); }
_ZN7testing8internal12UnitTestImplC2EPNS_8UnitTestE:
 5557|      2|    : parent_(parent),
 5558|       |      GTEST_DISABLE_MSC_WARNINGS_PUSH_(4355 /* using this in initializer */)
 5559|      2|          default_global_test_part_result_reporter_(this),
 5560|      2|      default_per_thread_test_part_result_reporter_(this),
 5561|       |      GTEST_DISABLE_MSC_WARNINGS_POP_() global_test_part_result_reporter_(
 5562|      2|          &default_global_test_part_result_reporter_),
 5563|      2|      per_thread_test_part_result_reporter_(
 5564|      2|          &default_per_thread_test_part_result_reporter_),
 5565|      2|      parameterized_test_registry_(),
 5566|      2|      parameterized_tests_registered_(false),
 5567|      2|      last_death_test_suite_(-1),
 5568|      2|      current_test_suite_(nullptr),
 5569|      2|      current_test_info_(nullptr),
 5570|      2|      ad_hoc_test_result_(),
 5571|      2|      os_stack_trace_getter_(nullptr),
 5572|      2|      post_flag_parse_init_performed_(false),
 5573|      2|      random_seed_(0),  // Will be overridden by the flag before first use.
 5574|      2|      random_(0),       // Will be reseeded before first use.
 5575|      2|      start_timestamp_(0),
 5576|      2|      elapsed_time_(0),
 5577|       |#ifdef GTEST_HAS_DEATH_TEST
 5578|      2|      death_test_factory_(new DefaultDeathTestFactory),
 5579|       |#endif
 5580|       |      // Will be overridden by the flag before first use.
 5581|      2|      catch_exceptions_(false) {
 5582|      2|  listeners()->SetDefaultResultPrinter(new PrettyUnitTestResultPrinter);
 5583|      2|}
_ZN7testing8internal12UnitTestImpl32SuppressTestEventsIfInSubprocessEv:
 5620|      2|void UnitTestImpl::SuppressTestEventsIfInSubprocess() {
 5621|      2|  if (internal_run_death_test_flag_ != nullptr)
  ------------------
  |  Branch (5621:7): [True: 0, False: 2]
  ------------------
 5622|      0|    listeners()->SuppressEventForwarding(true);
 5623|      2|}
_ZN7testing8internal12UnitTestImpl18ConfigureXmlOutputEv:
 5628|      2|void UnitTestImpl::ConfigureXmlOutput() {
 5629|      2|  const std::string& output_format = UnitTestOptions::GetOutputFormat();
 5630|      2|#if GTEST_HAS_FILE_SYSTEM
 5631|      2|  if (output_format == "xml") {
  ------------------
  |  Branch (5631:7): [True: 0, False: 2]
  ------------------
 5632|      0|    listeners()->SetDefaultXmlGenerator(new XmlUnitTestResultPrinter(
 5633|      0|        UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
 5634|      2|  } else if (output_format == "json") {
  ------------------
  |  Branch (5634:14): [True: 0, False: 2]
  ------------------
 5635|      0|    listeners()->SetDefaultXmlGenerator(new JsonUnitTestResultPrinter(
 5636|      0|        UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
 5637|      2|  } else if (!output_format.empty()) {
  ------------------
  |  Branch (5637:14): [True: 0, False: 2]
  ------------------
 5638|      0|    GTEST_LOG_(WARNING) << "WARNING: unrecognized output format \""
  ------------------
  |  | 1054|      0|  ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \
  |  | 1055|      0|                                __FILE__, __LINE__)                    \
  |  | 1056|      0|      .GetStream()
  ------------------
 5639|      0|                        << output_format << "\" ignored.";
 5640|      0|  }
 5641|       |#else
 5642|       |  if (!output_format.empty()) {
 5643|       |    GTEST_LOG_(ERROR) << "ERROR: alternative output formats require "
 5644|       |                      << "GTEST_HAS_FILE_SYSTEM to be enabled";
 5645|       |  }
 5646|       |#endif  // GTEST_HAS_FILE_SYSTEM
 5647|      2|}
_ZN7testing8internal12UnitTestImpl24ConfigureStreamingOutputEv:
 5652|      2|void UnitTestImpl::ConfigureStreamingOutput() {
 5653|      2|  const std::string& target = GTEST_FLAG_GET(stream_result_to);
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
 5654|      2|  if (!target.empty()) {
  ------------------
  |  Branch (5654:7): [True: 0, False: 2]
  ------------------
 5655|      0|    const size_t pos = target.find(':');
 5656|      0|    if (pos != std::string::npos) {
  ------------------
  |  Branch (5656:9): [True: 0, False: 0]
  ------------------
 5657|      0|      listeners()->Append(
 5658|      0|          new StreamingListener(target.substr(0, pos), target.substr(pos + 1)));
 5659|      0|    } else {
 5660|      0|      GTEST_LOG_(WARNING) << "unrecognized streaming target \"" << target
  ------------------
  |  | 1054|      0|  ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \
  |  | 1055|      0|                                __FILE__, __LINE__)                    \
  |  | 1056|      0|      .GetStream()
  ------------------
 5661|      0|                          << "\" ignored.";
 5662|      0|    }
 5663|      0|  }
 5664|      2|}
_ZN7testing8internal12UnitTestImpl19PostFlagParsingInitEv:
 5672|      4|void UnitTestImpl::PostFlagParsingInit() {
 5673|       |  // Ensures that this function does not execute more than once.
 5674|      4|  if (!post_flag_parse_init_performed_) {
  ------------------
  |  Branch (5674:7): [True: 2, False: 2]
  ------------------
 5675|      2|    post_flag_parse_init_performed_ = true;
 5676|       |
 5677|       |#if defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_)
 5678|       |    // Register to send notifications about key process state changes.
 5679|       |    listeners()->Append(new GTEST_CUSTOM_TEST_EVENT_LISTENER_());
 5680|       |#endif  // defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_)
 5681|       |
 5682|      2|#ifdef GTEST_HAS_DEATH_TEST
 5683|      2|    InitDeathTestSubprocessControlInfo();
 5684|      2|    SuppressTestEventsIfInSubprocess();
 5685|      2|#endif  // GTEST_HAS_DEATH_TEST
 5686|       |
 5687|       |    // Registers parameterized tests. This makes parameterized tests
 5688|       |    // available to the UnitTest reflection API without running
 5689|       |    // RUN_ALL_TESTS.
 5690|      2|    RegisterParameterizedTests();
 5691|       |
 5692|       |    // Configures listeners for XML output. This makes it possible for users
 5693|       |    // to shut down the default XML output before invoking RUN_ALL_TESTS.
 5694|      2|    ConfigureXmlOutput();
 5695|       |
 5696|      2|    if (GTEST_FLAG_GET(brief)) {
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  |  |  |  Branch (2293:30): [True: 0, False: 2]
  |  |  ------------------
  ------------------
 5697|      0|      listeners()->SetDefaultResultPrinter(new BriefUnitTestResultPrinter);
 5698|      0|    }
 5699|       |
 5700|      2|#if GTEST_CAN_STREAM_RESULTS_
 5701|       |    // Configures listeners for streaming test results to the specified server.
 5702|      2|    ConfigureStreamingOutput();
 5703|      2|#endif  // GTEST_CAN_STREAM_RESULTS_
 5704|       |
 5705|       |#ifdef GTEST_HAS_ABSL
 5706|       |    if (GTEST_FLAG_GET(install_failure_signal_handler)) {
 5707|       |      absl::FailureSignalHandlerOptions options;
 5708|       |      absl::InstallFailureSignalHandler(options);
 5709|       |    }
 5710|       |#endif  // GTEST_HAS_ABSL
 5711|      2|  }
 5712|      4|}
_ZN7testing8internal12UnitTestImpl12GetTestSuiteEPKcS3_PFvvES5_:
 5752|      4|    internal::TearDownTestSuiteFunc tear_down_tc) {
 5753|       |  // Can we find a TestSuite with the given name?
 5754|      4|  const auto test_suite =
 5755|      4|      std::find_if(test_suites_.rbegin(), test_suites_.rend(),
 5756|      4|                   TestSuiteNameIs(test_suite_name));
 5757|       |
 5758|      4|  if (test_suite != test_suites_.rend()) return *test_suite;
  ------------------
  |  Branch (5758:7): [True: 2, False: 2]
  ------------------
 5759|       |
 5760|       |  // No.  Let's create one.
 5761|      2|  auto* const new_test_suite =
 5762|      2|      new TestSuite(test_suite_name, type_param, set_up_tc, tear_down_tc);
 5763|       |
 5764|      2|  const UnitTestFilter death_test_suite_filter(kDeathTestSuiteFilter);
 5765|       |  // Is this a death test suite?
 5766|      2|  if (death_test_suite_filter.MatchesName(test_suite_name)) {
  ------------------
  |  Branch (5766:7): [True: 0, False: 2]
  ------------------
 5767|       |    // Yes.  Inserts the test suite after the last death test suite
 5768|       |    // defined so far.  This only works when the test suites haven't
 5769|       |    // been shuffled.  Otherwise we may end up running a death test
 5770|       |    // after a non-death test.
 5771|      0|    ++last_death_test_suite_;
 5772|      0|    test_suites_.insert(test_suites_.begin() + last_death_test_suite_,
 5773|      0|                        new_test_suite);
 5774|      2|  } else {
 5775|       |    // No.  Appends to the end of the list.
 5776|      2|    test_suites_.push_back(new_test_suite);
 5777|      2|  }
 5778|       |
 5779|      2|  test_suite_indices_.push_back(static_cast<int>(test_suite_indices_.size()));
 5780|      2|  return new_test_suite;
 5781|      4|}
_ZN7testing8internal12UnitTestImpl11RunAllTestsEv:
 5797|      2|bool UnitTestImpl::RunAllTests() {
 5798|       |  // True if and only if Google Test is initialized before RUN_ALL_TESTS() is
 5799|       |  // called.
 5800|      2|  const bool gtest_is_initialized_before_run_all_tests = GTestIsInitialized();
 5801|       |
 5802|       |  // Do not run any test if the --help flag was specified.
 5803|      2|  if (g_help_flag) return true;
  ------------------
  |  Branch (5803:7): [True: 0, False: 2]
  ------------------
 5804|       |
 5805|       |  // Repeats the call to the post-flag parsing initialization in case the
 5806|       |  // user didn't call InitGoogleTest.
 5807|      2|  PostFlagParsingInit();
 5808|       |
 5809|      2|#if GTEST_HAS_FILE_SYSTEM
 5810|       |  // Even if sharding is not on, test runners may want to use the
 5811|       |  // GTEST_SHARD_STATUS_FILE to query whether the test supports the sharding
 5812|       |  // protocol.
 5813|      2|  internal::WriteToShardStatusFileIfNeeded();
 5814|      2|#endif  // GTEST_HAS_FILE_SYSTEM
 5815|       |
 5816|       |  // True if and only if we are in a subprocess for running a thread-safe-style
 5817|       |  // death test.
 5818|      2|  bool in_subprocess_for_death_test = false;
 5819|       |
 5820|      2|#ifdef GTEST_HAS_DEATH_TEST
 5821|      2|  in_subprocess_for_death_test = (internal_run_death_test_flag_ != nullptr);
 5822|       |#if defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_)
 5823|       |  if (in_subprocess_for_death_test) {
 5824|       |    GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_();
 5825|       |  }
 5826|       |#endif  // defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_)
 5827|      2|#endif  // GTEST_HAS_DEATH_TEST
 5828|       |
 5829|      2|  const bool should_shard = ShouldShard(kTestTotalShards, kTestShardIndex,
 5830|      2|                                        in_subprocess_for_death_test);
 5831|       |
 5832|       |  // Compares the full test names with the filter to decide which
 5833|       |  // tests to run.
 5834|      2|  const bool has_tests_to_run =
 5835|      2|      FilterTests(should_shard ? HONOR_SHARDING_PROTOCOL
  ------------------
  |  Branch (5835:19): [True: 0, False: 2]
  ------------------
 5836|      2|                               : IGNORE_SHARDING_PROTOCOL) > 0;
 5837|       |
 5838|       |  // Lists the tests and exits if the --gtest_list_tests flag was specified.
 5839|      2|  if (GTEST_FLAG_GET(list_tests)) {
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  |  |  |  Branch (2293:30): [True: 0, False: 2]
  |  |  ------------------
  ------------------
 5840|       |    // This must be called *after* FilterTests() has been called.
 5841|      0|    ListTestsMatchingFilter();
 5842|      0|    return true;
 5843|      0|  }
 5844|       |
 5845|      2|  random_seed_ = GetRandomSeedFromFlag(GTEST_FLAG_GET(random_seed));
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
 5846|       |
 5847|       |  // True if and only if at least one test has failed.
 5848|      2|  bool failed = false;
 5849|       |
 5850|      2|  TestEventListener* repeater = listeners()->repeater();
 5851|       |
 5852|      2|  start_timestamp_ = GetTimeInMillis();
 5853|      2|  repeater->OnTestProgramStart(*parent_);
 5854|       |
 5855|       |  // How many times to repeat the tests?  We don't want to repeat them
 5856|       |  // when we are inside the subprocess of a death test.
 5857|      2|  const int repeat = in_subprocess_for_death_test ? 1 : GTEST_FLAG_GET(repeat);
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  |  Branch (5857:22): [True: 0, False: 2]
  ------------------
 5858|       |
 5859|       |  // Repeats forever if the repeat count is negative.
 5860|      2|  const bool gtest_repeat_forever = repeat < 0;
 5861|       |
 5862|       |  // Should test environments be set up and torn down for each repeat, or only
 5863|       |  // set up on the first and torn down on the last iteration? If there is no
 5864|       |  // "last" iteration because the tests will repeat forever, always recreate the
 5865|       |  // environments to avoid leaks in case one of the environments is using
 5866|       |  // resources that are external to this process. Without this check there would
 5867|       |  // be no way to clean up those external resources automatically.
 5868|      2|  const bool recreate_environments_when_repeating =
 5869|      2|      GTEST_FLAG_GET(recreate_environments_when_repeating) ||
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  |  |  |  Branch (2293:30): [True: 0, False: 2]
  |  |  ------------------
  ------------------
 5870|      2|      gtest_repeat_forever;
  ------------------
  |  Branch (5870:7): [True: 0, False: 2]
  ------------------
 5871|       |
 5872|      4|  for (int i = 0; gtest_repeat_forever || i != repeat; i++) {
  ------------------
  |  Branch (5872:19): [True: 2, False: 2]
  |  Branch (5872:43): [True: 2, False: 0]
  ------------------
 5873|       |    // We want to preserve failures generated by ad-hoc test
 5874|       |    // assertions executed before RUN_ALL_TESTS().
 5875|      2|    ClearNonAdHocTestResult();
 5876|       |
 5877|      2|    Timer timer;
 5878|       |
 5879|       |    // Shuffles test suites and tests if requested.
 5880|      2|    if (has_tests_to_run && GTEST_FLAG_GET(shuffle)) {
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  |  |  |  Branch (2293:30): [True: 0, False: 2]
  |  |  ------------------
  ------------------
  |  Branch (5880:9): [True: 2, False: 0]
  ------------------
 5881|      0|      random()->Reseed(static_cast<uint32_t>(random_seed_));
 5882|       |      // This should be done before calling OnTestIterationStart(),
 5883|       |      // such that a test event listener can see the actual test order
 5884|       |      // in the event.
 5885|      0|      ShuffleTests();
 5886|      0|    }
 5887|       |
 5888|       |    // Tells the unit test event listeners that the tests are about to start.
 5889|      2|    repeater->OnTestIterationStart(*parent_, i);
 5890|       |
 5891|       |    // Runs each test suite if there is at least one test to run.
 5892|      2|    if (has_tests_to_run) {
  ------------------
  |  Branch (5892:9): [True: 2, False: 0]
  ------------------
 5893|       |      // Sets up all environments beforehand. If test environments aren't
 5894|       |      // recreated for each iteration, only do so on the first iteration.
 5895|      2|      if (i == 0 || recreate_environments_when_repeating) {
  ------------------
  |  Branch (5895:11): [True: 2, False: 0]
  |  Branch (5895:21): [True: 0, False: 0]
  ------------------
 5896|      2|        repeater->OnEnvironmentsSetUpStart(*parent_);
 5897|      2|        ForEach(environments_, SetUpEnvironment);
 5898|      2|        repeater->OnEnvironmentsSetUpEnd(*parent_);
 5899|      2|      }
 5900|       |
 5901|       |      // Runs the tests only if there was no fatal failure or skip triggered
 5902|       |      // during global set-up.
 5903|      2|      if (Test::IsSkipped()) {
  ------------------
  |  Branch (5903:11): [True: 0, False: 2]
  ------------------
 5904|       |        // Emit diagnostics when global set-up calls skip, as it will not be
 5905|       |        // emitted by default.
 5906|      0|        TestResult& test_result =
 5907|      0|            *internal::GetUnitTestImpl()->current_test_result();
 5908|      0|        for (int j = 0; j < test_result.total_part_count(); ++j) {
  ------------------
  |  Branch (5908:25): [True: 0, False: 0]
  ------------------
 5909|      0|          const TestPartResult& test_part_result =
 5910|      0|              test_result.GetTestPartResult(j);
 5911|      0|          if (test_part_result.type() == TestPartResult::kSkip) {
  ------------------
  |  Branch (5911:15): [True: 0, False: 0]
  ------------------
 5912|      0|            const std::string& result = test_part_result.message();
 5913|      0|            printf("%s\n", result.c_str());
 5914|      0|          }
 5915|      0|        }
 5916|      0|        fflush(stdout);
 5917|      2|      } else if (!Test::HasFatalFailure()) {
  ------------------
  |  Branch (5917:18): [True: 2, False: 0]
  ------------------
 5918|      4|        for (int test_index = 0; test_index < total_test_suite_count();
  ------------------
  |  Branch (5918:34): [True: 2, False: 2]
  ------------------
 5919|      2|             test_index++) {
 5920|      2|          GetMutableSuiteCase(test_index)->Run();
 5921|      2|          if (GTEST_FLAG_GET(fail_fast) &&
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  |  |  |  Branch (2293:30): [True: 0, False: 2]
  |  |  ------------------
  ------------------
 5922|      0|              GetMutableSuiteCase(test_index)->Failed()) {
  ------------------
  |  Branch (5922:15): [True: 0, False: 0]
  ------------------
 5923|      0|            for (int j = test_index + 1; j < total_test_suite_count(); j++) {
  ------------------
  |  Branch (5923:42): [True: 0, False: 0]
  ------------------
 5924|      0|              GetMutableSuiteCase(j)->Skip();
 5925|      0|            }
 5926|      0|            break;
 5927|      0|          }
 5928|      2|        }
 5929|      2|      } else if (Test::HasFatalFailure()) {
  ------------------
  |  Branch (5929:18): [True: 0, False: 0]
  ------------------
 5930|       |        // If there was a fatal failure during the global setup then we know we
 5931|       |        // aren't going to run any tests. Explicitly mark all of the tests as
 5932|       |        // skipped to make this obvious in the output.
 5933|      0|        for (int test_index = 0; test_index < total_test_suite_count();
  ------------------
  |  Branch (5933:34): [True: 0, False: 0]
  ------------------
 5934|      0|             test_index++) {
 5935|      0|          GetMutableSuiteCase(test_index)->Skip();
 5936|      0|        }
 5937|      0|      }
 5938|       |
 5939|       |      // Tears down all environments in reverse order afterwards. If test
 5940|       |      // environments aren't recreated for each iteration, only do so on the
 5941|       |      // last iteration.
 5942|      2|      if (i == repeat - 1 || recreate_environments_when_repeating) {
  ------------------
  |  Branch (5942:11): [True: 2, False: 0]
  |  Branch (5942:30): [True: 0, False: 0]
  ------------------
 5943|      0|        repeater->OnEnvironmentsTearDownStart(*parent_);
 5944|      0|        std::for_each(environments_.rbegin(), environments_.rend(),
 5945|      0|                      TearDownEnvironment);
 5946|      0|        repeater->OnEnvironmentsTearDownEnd(*parent_);
 5947|      0|      }
 5948|      2|    }
 5949|       |
 5950|      2|    elapsed_time_ = timer.Elapsed();
 5951|       |
 5952|       |    // Tells the unit test event listener that the tests have just finished.
 5953|      2|    repeater->OnTestIterationEnd(*parent_, i);
 5954|       |
 5955|       |    // Gets the result and clears it.
 5956|      2|    if (!Passed()) {
  ------------------
  |  Branch (5956:9): [True: 0, False: 2]
  ------------------
 5957|      0|      failed = true;
 5958|      0|    }
 5959|       |
 5960|       |    // Restores the original test order after the iteration.  This
 5961|       |    // allows the user to quickly repro a failure that happens in the
 5962|       |    // N-th iteration without repeating the first (N - 1) iterations.
 5963|       |    // This is not enclosed in "if (GTEST_FLAG(shuffle)) { ... }", in
 5964|       |    // case the user somehow changes the value of the flag somewhere
 5965|       |    // (it's always safe to unshuffle the tests).
 5966|      2|    UnshuffleTests();
 5967|       |
 5968|      2|    if (GTEST_FLAG_GET(shuffle)) {
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  |  |  |  Branch (2293:30): [True: 0, False: 2]
  |  |  ------------------
  ------------------
 5969|       |      // Picks a new random seed for each iteration.
 5970|      0|      random_seed_ = GetNextRandomSeed(random_seed_);
 5971|      0|    }
 5972|      2|  }
 5973|       |
 5974|      2|  repeater->OnTestProgramEnd(*parent_);
 5975|       |
 5976|      2|  if (!gtest_is_initialized_before_run_all_tests) {
  ------------------
  |  Branch (5976:7): [True: 0, False: 2]
  ------------------
 5977|      0|    ColoredPrintf(
 5978|      0|        GTestColor::kRed,
 5979|      0|        "\nIMPORTANT NOTICE - DO NOT IGNORE:\n"
 5980|      0|        "This test program did NOT call " GTEST_INIT_GOOGLE_TEST_NAME_
 5981|      0|        "() before calling RUN_ALL_TESTS(). This is INVALID. Soon " GTEST_NAME_
 5982|      0|        " will start to enforce the valid usage. "
 5983|      0|        "Please fix it ASAP, or IT WILL START TO FAIL.\n");  // NOLINT
 5984|      0|  }
 5985|       |
 5986|      2|  return !failed;
 5987|      2|}
_ZN7testing8internal30WriteToShardStatusFileIfNeededEv:
 5994|      2|void WriteToShardStatusFileIfNeeded() {
 5995|      2|  const char* const test_shard_file = posix::GetEnv(kTestShardStatusFile);
 5996|      2|  if (test_shard_file != nullptr) {
  ------------------
  |  Branch (5996:7): [True: 0, False: 2]
  ------------------
 5997|      0|    FILE* const file = posix::FOpen(test_shard_file, "w");
 5998|      0|    if (file == nullptr) {
  ------------------
  |  Branch (5998:9): [True: 0, False: 0]
  ------------------
 5999|      0|      ColoredPrintf(GTestColor::kRed,
 6000|      0|                    "Could not write to the test shard status file \"%s\" "
 6001|      0|                    "specified by the %s environment variable.\n",
 6002|      0|                    test_shard_file, kTestShardStatusFile);
 6003|      0|      fflush(stdout);
 6004|      0|      exit(EXIT_FAILURE);
 6005|      0|    }
 6006|      0|    fclose(file);
 6007|      0|  }
 6008|      2|}
_ZN7testing8internal11ShouldShardEPKcS2_b:
 6018|      4|                 bool in_subprocess_for_death_test) {
 6019|      4|  if (in_subprocess_for_death_test) {
  ------------------
  |  Branch (6019:7): [True: 0, False: 4]
  ------------------
 6020|      0|    return false;
 6021|      0|  }
 6022|       |
 6023|      4|  const int32_t total_shards = Int32FromEnvOrDie(total_shards_env, -1);
 6024|      4|  const int32_t shard_index = Int32FromEnvOrDie(shard_index_env, -1);
 6025|       |
 6026|      4|  if (total_shards == -1 && shard_index == -1) {
  ------------------
  |  Branch (6026:7): [True: 4, False: 0]
  |  Branch (6026:29): [True: 4, False: 0]
  ------------------
 6027|      4|    return false;
 6028|      4|  } else if (total_shards == -1 && shard_index != -1) {
  ------------------
  |  Branch (6028:14): [True: 0, False: 0]
  |  Branch (6028:36): [True: 0, False: 0]
  ------------------
 6029|      0|    const Message msg = Message() << "Invalid environment variables: you have "
 6030|      0|                                  << kTestShardIndex << " = " << shard_index
 6031|      0|                                  << ", but have left " << kTestTotalShards
 6032|      0|                                  << " unset.\n";
 6033|      0|    ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str());
 6034|      0|    fflush(stdout);
 6035|      0|    exit(EXIT_FAILURE);
 6036|      0|  } else if (total_shards != -1 && shard_index == -1) {
  ------------------
  |  Branch (6036:14): [True: 0, False: 0]
  |  Branch (6036:36): [True: 0, False: 0]
  ------------------
 6037|      0|    const Message msg = Message()
 6038|      0|                        << "Invalid environment variables: you have "
 6039|      0|                        << kTestTotalShards << " = " << total_shards
 6040|      0|                        << ", but have left " << kTestShardIndex << " unset.\n";
 6041|      0|    ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str());
 6042|      0|    fflush(stdout);
 6043|      0|    exit(EXIT_FAILURE);
 6044|      0|  } else if (shard_index < 0 || shard_index >= total_shards) {
  ------------------
  |  Branch (6044:14): [True: 0, False: 0]
  |  Branch (6044:33): [True: 0, False: 0]
  ------------------
 6045|      0|    const Message msg =
 6046|      0|        Message() << "Invalid environment variables: we require 0 <= "
 6047|      0|                  << kTestShardIndex << " < " << kTestTotalShards
 6048|      0|                  << ", but you have " << kTestShardIndex << "=" << shard_index
 6049|      0|                  << ", " << kTestTotalShards << "=" << total_shards << ".\n";
 6050|      0|    ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str());
 6051|      0|    fflush(stdout);
 6052|      0|    exit(EXIT_FAILURE);
 6053|      0|  }
 6054|       |
 6055|      0|  return total_shards > 1;
 6056|      4|}
_ZN7testing8internal17Int32FromEnvOrDieEPKci:
 6061|      8|int32_t Int32FromEnvOrDie(const char* var, int32_t default_val) {
 6062|      8|  const char* str_val = posix::GetEnv(var);
 6063|      8|  if (str_val == nullptr) {
  ------------------
  |  Branch (6063:7): [True: 8, False: 0]
  ------------------
 6064|      8|    return default_val;
 6065|      8|  }
 6066|       |
 6067|      0|  int32_t result;
 6068|      0|  if (!ParseInt32(Message() << "The value of environment variable " << var,
  ------------------
  |  Branch (6068:7): [True: 0, False: 0]
  ------------------
 6069|      0|                  str_val, &result)) {
 6070|      0|    exit(EXIT_FAILURE);
 6071|      0|  }
 6072|      0|  return result;
 6073|      0|}
_ZN7testing8internal12UnitTestImpl11FilterTestsENS1_18ReactionToShardingE:
 6090|      2|int UnitTestImpl::FilterTests(ReactionToSharding shard_tests) {
 6091|      2|  const int32_t total_shards = shard_tests == HONOR_SHARDING_PROTOCOL
  ------------------
  |  Branch (6091:32): [True: 0, False: 2]
  ------------------
 6092|      2|                                   ? Int32FromEnvOrDie(kTestTotalShards, -1)
 6093|      2|                                   : -1;
 6094|      2|  const int32_t shard_index = shard_tests == HONOR_SHARDING_PROTOCOL
  ------------------
  |  Branch (6094:31): [True: 0, False: 2]
  ------------------
 6095|      2|                                  ? Int32FromEnvOrDie(kTestShardIndex, -1)
 6096|      2|                                  : -1;
 6097|       |
 6098|      2|  const PositiveAndNegativeUnitTestFilter gtest_flag_filter(
 6099|      2|      GTEST_FLAG_GET(filter));
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
 6100|      2|  const UnitTestFilter disable_test_filter(kDisableTestFilter);
 6101|       |  // num_runnable_tests are the number of tests that will
 6102|       |  // run across all shards (i.e., match filter and are not disabled).
 6103|       |  // num_selected_tests are the number of tests to be run on
 6104|       |  // this shard.
 6105|      2|  int num_runnable_tests = 0;
 6106|      2|  int num_selected_tests = 0;
 6107|      2|  for (auto* test_suite : test_suites_) {
  ------------------
  |  Branch (6107:25): [True: 2, False: 2]
  ------------------
 6108|      2|    const std::string& test_suite_name = test_suite->name();
 6109|      2|    test_suite->set_should_run(false);
 6110|       |
 6111|      6|    for (size_t j = 0; j < test_suite->test_info_list().size(); j++) {
  ------------------
  |  Branch (6111:24): [True: 4, False: 2]
  ------------------
 6112|      4|      TestInfo* const test_info = test_suite->test_info_list()[j];
 6113|      4|      const std::string test_name(test_info->name());
 6114|       |      // A test is disabled if test suite name or test name matches
 6115|       |      // kDisableTestFilter.
 6116|      4|      const bool is_disabled =
 6117|      4|          disable_test_filter.MatchesName(test_suite_name) ||
  ------------------
  |  Branch (6117:11): [True: 0, False: 4]
  ------------------
 6118|      4|          disable_test_filter.MatchesName(test_name);
  ------------------
  |  Branch (6118:11): [True: 0, False: 4]
  ------------------
 6119|      4|      test_info->is_disabled_ = is_disabled;
 6120|       |
 6121|      4|      const bool matches_filter =
 6122|      4|          gtest_flag_filter.MatchesTest(test_suite_name, test_name);
 6123|      4|      test_info->matches_filter_ = matches_filter;
 6124|       |
 6125|      4|      const bool is_runnable =
 6126|      4|          (GTEST_FLAG_GET(also_run_disabled_tests) || !is_disabled) &&
  ------------------
  |  | 2293|      4|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      4|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  |  |  |  Branch (2293:30): [True: 0, False: 4]
  |  |  ------------------
  ------------------
  |  Branch (6126:55): [True: 4, False: 0]
  ------------------
 6127|      4|          matches_filter;
  ------------------
  |  Branch (6127:11): [True: 2, False: 2]
  ------------------
 6128|       |
 6129|      4|      const bool is_in_another_shard =
 6130|      4|          shard_tests != IGNORE_SHARDING_PROTOCOL &&
  ------------------
  |  Branch (6130:11): [True: 0, False: 4]
  ------------------
 6131|      0|          !ShouldRunTestOnShard(total_shards, shard_index, num_runnable_tests);
  ------------------
  |  Branch (6131:11): [True: 0, False: 0]
  ------------------
 6132|      4|      test_info->is_in_another_shard_ = is_in_another_shard;
 6133|      4|      const bool is_selected = is_runnable && !is_in_another_shard;
  ------------------
  |  Branch (6133:32): [True: 2, False: 2]
  |  Branch (6133:47): [True: 2, False: 0]
  ------------------
 6134|       |
 6135|      4|      num_runnable_tests += is_runnable;
 6136|      4|      num_selected_tests += is_selected;
 6137|       |
 6138|      4|      test_info->should_run_ = is_selected;
 6139|      4|      test_suite->set_should_run(test_suite->should_run() || is_selected);
  ------------------
  |  Branch (6139:34): [True: 0, False: 4]
  |  Branch (6139:62): [True: 2, False: 2]
  ------------------
 6140|      4|    }
 6141|      2|  }
 6142|      2|  return num_selected_tests;
 6143|      2|}
_ZN7testing8internal12UnitTestImpl21os_stack_trace_getterEv:
 6238|      8|OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
 6239|      8|  if (os_stack_trace_getter_ == nullptr) {
  ------------------
  |  Branch (6239:7): [True: 2, False: 6]
  ------------------
 6240|       |#ifdef GTEST_OS_STACK_TRACE_GETTER_
 6241|       |    os_stack_trace_getter_ = new GTEST_OS_STACK_TRACE_GETTER_;
 6242|       |#else
 6243|      2|    os_stack_trace_getter_ = new OsStackTraceGetter;
 6244|      2|#endif  // GTEST_OS_STACK_TRACE_GETTER_
 6245|      2|  }
 6246|       |
 6247|      8|  return os_stack_trace_getter_;
 6248|      8|}
_ZN7testing8internal12UnitTestImpl19current_test_resultEv:
 6251|     12|TestResult* UnitTestImpl::current_test_result() {
 6252|     12|  if (current_test_info_ != nullptr) {
  ------------------
  |  Branch (6252:7): [True: 8, False: 4]
  ------------------
 6253|      8|    return &current_test_info_->result_;
 6254|      8|  }
 6255|      4|  if (current_test_suite_ != nullptr) {
  ------------------
  |  Branch (6255:7): [True: 0, False: 4]
  ------------------
 6256|      0|    return &current_test_suite_->ad_hoc_test_result_;
 6257|      0|  }
 6258|      4|  return &ad_hoc_test_result_;
 6259|      4|}
_ZN7testing8internal6IsTrueEb:
 6310|     22|bool IsTrue(bool condition) { return condition; }
_ZN7testing8internal10AlwaysTrueEv:
 6312|     12|bool AlwaysTrue() {
 6313|     12|#if GTEST_HAS_EXCEPTIONS
 6314|       |  // This condition is always false so AlwaysTrue() never actually throws,
 6315|       |  // but it makes the compiler think that it may throw.
 6316|     12|  if (IsTrue(false)) throw ClassUniqueToAlwaysTrue();
  ------------------
  |  Branch (6316:7): [True: 0, False: 12]
  ------------------
 6317|     12|#endif  // GTEST_HAS_EXCEPTIONS
 6318|     12|  return true;
 6319|     12|}
_ZN7testing8internal10SkipPrefixEPKcPS2_:
 6324|     65|bool SkipPrefix(const char* prefix, const char** pstr) {
 6325|     65|  const size_t prefix_len = strlen(prefix);
 6326|     65|  if (strncmp(*pstr, prefix, prefix_len) == 0) {
  ------------------
  |  Branch (6326:7): [True: 13, False: 52]
  ------------------
 6327|     13|    *pstr += prefix_len;
 6328|     13|    return true;
 6329|     13|  }
 6330|     52|  return false;
 6331|     65|}
_ZN7testing8internal9ParseFlagEPKcS2_Pi:
 6392|     39|bool ParseFlag(const char* str, const char* flag_name, int32_t* value) {
 6393|       |  // Gets the value of the flag as a string.
 6394|     39|  const char* const value_str = ParseFlagValue(str, flag_name, false);
 6395|       |
 6396|       |  // Aborts if the parsing failed.
 6397|     39|  if (value_str == nullptr) return false;
  ------------------
  |  Branch (6397:7): [True: 39, False: 0]
  ------------------
 6398|       |
 6399|       |  // Sets *value to the value of the flag.
 6400|      0|  return ParseInt32(Message() << "The value of flag --" << flag_name, value_str,
 6401|      0|                    value);
 6402|     39|}
_ZN7testing8internal24ParseGoogleTestFlagsOnlyEPiPPc:
 6685|      2|void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
 6686|       |#ifdef GTEST_HAS_ABSL
 6687|       |  if (*argc <= 0) return;
 6688|       |
 6689|       |  std::vector<char*> positional_args;
 6690|       |  std::vector<absl::UnrecognizedFlag> unrecognized_flags;
 6691|       |  absl::ParseAbseilFlagsOnly(*argc, argv, positional_args, unrecognized_flags);
 6692|       |  absl::flat_hash_set<absl::string_view> unrecognized;
 6693|       |  for (const auto& flag : unrecognized_flags) {
 6694|       |    unrecognized.insert(flag.flag_name);
 6695|       |  }
 6696|       |  absl::flat_hash_set<char*> positional;
 6697|       |  for (const auto& arg : positional_args) {
 6698|       |    positional.insert(arg);
 6699|       |  }
 6700|       |
 6701|       |  int out_pos = 1;
 6702|       |  int in_pos = 1;
 6703|       |  for (; in_pos < *argc; ++in_pos) {
 6704|       |    char* arg = argv[in_pos];
 6705|       |    absl::string_view arg_str(arg);
 6706|       |    if (absl::ConsumePrefix(&arg_str, "--")) {
 6707|       |      // Flag-like argument. If the flag was unrecognized, keep it.
 6708|       |      // If it was a GoogleTest flag, remove it.
 6709|       |      if (unrecognized.contains(arg_str)) {
 6710|       |        argv[out_pos++] = argv[in_pos];
 6711|       |        continue;
 6712|       |      }
 6713|       |    }
 6714|       |
 6715|       |    if (arg_str.empty()) {
 6716|       |      ++in_pos;
 6717|       |      break;  // '--' indicates that the rest of the arguments are positional
 6718|       |    }
 6719|       |
 6720|       |    // Probably a positional argument. If it is in fact positional, keep it.
 6721|       |    // If it was a value for the flag argument, remove it.
 6722|       |    if (positional.contains(arg)) {
 6723|       |      argv[out_pos++] = arg;
 6724|       |    }
 6725|       |  }
 6726|       |
 6727|       |  // The rest are positional args for sure.
 6728|       |  while (in_pos < *argc) {
 6729|       |    argv[out_pos++] = argv[in_pos++];
 6730|       |  }
 6731|       |
 6732|       |  *argc = out_pos;
 6733|       |  argv[out_pos] = nullptr;
 6734|       |#else
 6735|      2|  ParseGoogleTestFlagsOnlyImpl(argc, argv);
 6736|      2|#endif
 6737|       |
 6738|       |  // Fix the value of *_NSGetArgc() on macOS, but if and only if
 6739|       |  // *_NSGetArgv() == argv
 6740|       |  // Only applicable to char** version of argv
 6741|       |#ifdef GTEST_OS_MAC
 6742|       |#ifndef GTEST_OS_IOS
 6743|       |  if (*_NSGetArgv() == argv) {
 6744|       |    *_NSGetArgc() = *argc;
 6745|       |  }
 6746|       |#endif
 6747|       |#endif
 6748|      2|}
_ZN7testing14InitGoogleTestEPiPPc:
 6794|      2|void InitGoogleTest(int* argc, char** argv) {
 6795|       |#if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
 6796|       |  GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(argc, argv);
 6797|       |#else   // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
 6798|      2|  internal::InitGoogleTestImpl(argc, argv);
 6799|      2|#endif  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
 6800|      2|}
gtest-all.cc:_ZN7testingL18GetDefaultFailFastEv:
  239|      2|static bool GetDefaultFailFast() {
  240|      2|  const char* const testbridge_test_runner_fail_fast =
  241|      2|      internal::posix::GetEnv("TESTBRIDGE_TEST_RUNNER_FAIL_FAST");
  242|      2|  if (testbridge_test_runner_fail_fast != nullptr) {
  ------------------
  |  Branch (242:7): [True: 0, False: 2]
  ------------------
  243|      0|    return strcmp(testbridge_test_runner_fail_fast, "1") == 0;
  244|      0|  }
  245|      2|  return false;
  246|      2|}
gtest-all.cc:_ZN7testingL16GetDefaultFilterEv:
  228|      2|static const char* GetDefaultFilter() {
  229|      2|  const char* const testbridge_test_only =
  230|      2|      internal::posix::GetEnv("TESTBRIDGE_TEST_ONLY");
  231|      2|  if (testbridge_test_only != nullptr) {
  ------------------
  |  Branch (231:7): [True: 0, False: 2]
  ------------------
  232|      0|    return testbridge_test_only;
  233|      0|  }
  234|      2|  return kUniversalFilter;
  235|      2|}
gtest-all.cc:_ZN7testing8internal12_GLOBAL__N_114UnitTestFilterC2ERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
  762|      6|  explicit UnitTestFilter(const std::string& filter) {
  763|       |    // By design "" filter matches "" string.
  764|      6|    std::vector<std::string> all_patterns;
  765|      6|    SplitString(filter, ':', &all_patterns);
  766|      6|    const auto exact_match_patterns_begin = std::partition(
  767|      6|        all_patterns.begin(), all_patterns.end(), &IsGlobPattern);
  768|       |
  769|      6|    glob_patterns_.reserve(static_cast<size_t>(
  770|      6|        std::distance(all_patterns.begin(), exact_match_patterns_begin)));
  771|      6|    std::move(all_patterns.begin(), exact_match_patterns_begin,
  772|      6|              std::inserter(glob_patterns_, glob_patterns_.begin()));
  773|      6|    std::move(
  774|      6|        exact_match_patterns_begin, all_patterns.end(),
  775|      6|        std::inserter(exact_match_patterns_, exact_match_patterns_.begin()));
  776|      6|  }
gtest-all.cc:_ZN7testing8internal12_GLOBAL__N_113IsGlobPatternERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
  752|     10|bool IsGlobPattern(const std::string& pattern) {
  753|     10|  return std::any_of(pattern.begin(), pattern.end(),
  754|     10|                     [](const char c) { return c == '?' || c == '*'; });
  755|     10|}
gtest-all.cc:_ZZN7testing8internal12_GLOBAL__N_113IsGlobPatternERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEENK3$_0clEc:
  754|     72|                     [](const char c) { return c == '?' || c == '*'; });
  ------------------
  |  Branch (754:48): [True: 0, False: 72]
  |  Branch (754:60): [True: 8, False: 64]
  ------------------
gtest-all.cc:_ZNK7testing8internal12_GLOBAL__N_114UnitTestFilter11MatchesNameERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
  780|     16|  bool MatchesName(const std::string& name) const {
  781|     16|    return exact_match_patterns_.count(name) > 0 ||
  ------------------
  |  Branch (781:12): [True: 2, False: 14]
  ------------------
  782|     14|           std::any_of(glob_patterns_.begin(), glob_patterns_.end(),
  ------------------
  |  Branch (782:12): [True: 0, False: 14]
  ------------------
  783|     14|                       [&name](const std::string& pattern) {
  784|     14|                         return PatternMatchesString(
  785|     14|                             name, pattern.c_str(),
  786|     14|                             pattern.c_str() + pattern.size());
  787|     14|                       });
  788|     16|  }
gtest-all.cc:_ZZNK7testing8internal12_GLOBAL__N_114UnitTestFilter11MatchesNameERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEENKUlSB_E_clESB_:
  783|     20|                       [&name](const std::string& pattern) {
  784|     20|                         return PatternMatchesString(
  785|     20|                             name, pattern.c_str(),
  786|     20|                             pattern.c_str() + pattern.size());
  787|     20|                       });
gtest-all.cc:_ZN7testing8internalL20PatternMatchesStringERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPKcSB_:
  704|     20|                                 const char* pattern, const char* pattern_end) {
  705|     20|  const char* name = name_str.c_str();
  706|     20|  const char* const name_begin = name;
  707|     20|  const char* const name_end = name + name_str.size();
  708|       |
  709|     20|  const char* pattern_next = pattern;
  710|     20|  const char* name_next = name;
  711|       |
  712|    300|  while (pattern < pattern_end || name < name_end) {
  ------------------
  |  Branch (712:10): [True: 300, False: 0]
  |  Branch (712:35): [True: 0, False: 0]
  ------------------
  713|    300|    if (pattern < pattern_end) {
  ------------------
  |  Branch (713:9): [True: 300, False: 0]
  ------------------
  714|    300|      switch (*pattern) {
  715|    154|        default:  // Match an ordinary character.
  ------------------
  |  Branch (715:9): [True: 154, False: 146]
  ------------------
  716|    154|          if (name < name_end && *name == *pattern) {
  ------------------
  |  Branch (716:15): [True: 142, False: 12]
  |  Branch (716:34): [True: 0, False: 142]
  ------------------
  717|      0|            ++pattern;
  718|      0|            ++name;
  719|      0|            continue;
  720|      0|          }
  721|    154|          break;
  722|    154|        case '?':  // Match any single character.
  ------------------
  |  Branch (722:9): [True: 0, False: 300]
  ------------------
  723|      0|          if (name < name_end) {
  ------------------
  |  Branch (723:15): [True: 0, False: 0]
  ------------------
  724|      0|            ++pattern;
  725|      0|            ++name;
  726|      0|            continue;
  727|      0|          }
  728|      0|          break;
  729|    146|        case '*':
  ------------------
  |  Branch (729:9): [True: 146, False: 154]
  ------------------
  730|       |          // Match zero or more characters. Start by skipping over the wildcard
  731|       |          // and matching zero characters from name. If that fails, restart and
  732|       |          // match one more character than the last attempt.
  733|    146|          pattern_next = pattern;
  734|    146|          name_next = name + 1;
  735|    146|          ++pattern;
  736|    146|          continue;
  737|    300|      }
  738|    300|    }
  739|       |    // Failed to match a character. Restart if possible.
  740|    154|    if (name_begin < name_next && name_next <= name_end) {
  ------------------
  |  Branch (740:9): [True: 146, False: 8]
  |  Branch (740:35): [True: 134, False: 12]
  ------------------
  741|    134|      pattern = pattern_next;
  742|    134|      name = name_next;
  743|    134|      continue;
  744|    134|    }
  745|     20|    return false;
  746|    154|  }
  747|      0|  return true;
  748|     20|}
gtest-all.cc:_ZN7testing8internal12_GLOBAL__N_133PositiveAndNegativeUnitTestFilterC2ERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
  802|      2|  explicit PositiveAndNegativeUnitTestFilter(const std::string& filter) {
  803|      2|    std::vector<std::string> positive_and_negative_filters;
  804|       |
  805|       |    // NOTE: `SplitString` always returns a non-empty container.
  806|      2|    SplitString(filter, '-', &positive_and_negative_filters);
  807|      2|    const auto& positive_filter = positive_and_negative_filters.front();
  808|       |
  809|      2|    if (positive_and_negative_filters.size() > 1) {
  ------------------
  |  Branch (809:9): [True: 0, False: 2]
  ------------------
  810|      0|      positive_filter_ = UnitTestFilter(
  811|      0|          positive_filter.empty() ? kUniversalFilter : positive_filter);
  ------------------
  |  Branch (811:11): [True: 0, False: 0]
  ------------------
  812|       |
  813|       |      // TODO(b/214626361): Fail on multiple '-' characters
  814|       |      // For the moment to preserve old behavior we concatenate the rest of the
  815|       |      // string parts with `-` as separator to generate the negative filter.
  816|      0|      auto negative_filter_string = positive_and_negative_filters[1];
  817|      0|      for (std::size_t i = 2; i < positive_and_negative_filters.size(); i++)
  ------------------
  |  Branch (817:31): [True: 0, False: 0]
  ------------------
  818|      0|        negative_filter_string =
  819|      0|            negative_filter_string + '-' + positive_and_negative_filters[i];
  820|      0|      negative_filter_ = UnitTestFilter(negative_filter_string);
  821|      2|    } else {
  822|       |      // In case we don't have a negative filter and positive filter is ""
  823|       |      // we do not use kUniversalFilter by design as opposed to when we have a
  824|       |      // negative filter.
  825|      2|      positive_filter_ = UnitTestFilter(positive_filter);
  826|      2|    }
  827|      2|  }
gtest-all.cc:_ZN7testing8internal12_GLOBAL__N_114UnitTestFilterC2Ev:
  759|      4|  UnitTestFilter() = default;
gtest-all.cc:_ZNK7testing8internal12_GLOBAL__N_133PositiveAndNegativeUnitTestFilter11MatchesTestERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEESB_:
  833|      4|                   const std::string& test_name) const {
  834|      4|    return MatchesName(test_suite_name + "." + test_name);
  835|      4|  }
gtest-all.cc:_ZNK7testing8internal12_GLOBAL__N_133PositiveAndNegativeUnitTestFilter11MatchesNameERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
  839|      4|  bool MatchesName(const std::string& name) const {
  840|      4|    return positive_filter_.MatchesName(name) &&
  ------------------
  |  Branch (840:12): [True: 2, False: 2]
  ------------------
  841|      2|           !negative_filter_.MatchesName(name);
  ------------------
  |  Branch (841:12): [True: 2, False: 0]
  ------------------
  842|      4|  }
gtest-all.cc:_ZN7testing8internalL18ShouldRunTestSuiteEPKNS_9TestSuiteE:
  445|      2|static bool ShouldRunTestSuite(const TestSuite* test_suite) {
  446|      2|  return test_suite->should_run();
  447|      2|}
gtest-all.cc:_ZN7testing8internalL20SumOverTestSuiteListERKNSt3__16vectorIPNS_9TestSuiteENS1_9allocatorIS4_EEEEMS3_KFivE:
  425|      2|                                int (TestSuite::*method)() const) {
  426|      2|  int sum = 0;
  427|      4|  for (size_t i = 0; i < case_list.size(); i++) {
  ------------------
  |  Branch (427:22): [True: 2, False: 2]
  ------------------
  428|      2|    sum += (case_list[i]->*method)();
  429|      2|  }
  430|      2|  return sum;
  431|      2|}
_ZN7testing8internal5TimerC2Ev:
 1151|      6|  Timer() : start_(clock::now()) {}
gtest-all.cc:_ZN7testing8internalL13ColoredPrintfENS0_12_GLOBAL__N_110GTestColorEPKcz:
 3279|     10|static void ColoredPrintf(GTestColor color, const char* fmt, ...) {
 3280|     10|  va_list args;
 3281|     10|  va_start(args, fmt);
 3282|       |
 3283|     10|  static const bool in_color_mode =
 3284|     10|#if GTEST_HAS_FILE_SYSTEM
 3285|     10|      ShouldUseColor(posix::IsATTY(posix::FileNo(stdout)) != 0);
 3286|       |#else
 3287|       |      false;
 3288|       |#endif  // GTEST_HAS_FILE_SYSTEM
 3289|       |
 3290|     10|  const bool use_color = in_color_mode && (color != GTestColor::kDefault);
  ------------------
  |  Branch (3290:26): [True: 0, False: 10]
  |  Branch (3290:43): [True: 0, False: 0]
  ------------------
 3291|       |
 3292|     10|  if (!use_color) {
  ------------------
  |  Branch (3292:7): [True: 10, False: 0]
  ------------------
 3293|     10|    vprintf(fmt, args);
 3294|     10|    va_end(args);
 3295|     10|    return;
 3296|     10|  }
 3297|       |
 3298|       |#if defined(GTEST_OS_WINDOWS) && !defined(GTEST_OS_WINDOWS_MOBILE) &&    \
 3299|       |    !defined(GTEST_OS_WINDOWS_PHONE) && !defined(GTEST_OS_WINDOWS_RT) && \
 3300|       |    !defined(GTEST_OS_WINDOWS_MINGW)
 3301|       |  const HANDLE stdout_handle = GetStdHandle(STD_OUTPUT_HANDLE);
 3302|       |
 3303|       |  // Gets the current text color.
 3304|       |  CONSOLE_SCREEN_BUFFER_INFO buffer_info;
 3305|       |  GetConsoleScreenBufferInfo(stdout_handle, &buffer_info);
 3306|       |  const WORD old_color_attrs = buffer_info.wAttributes;
 3307|       |  const WORD new_color = GetNewColor(color, old_color_attrs);
 3308|       |
 3309|       |  // We need to flush the stream buffers into the console before each
 3310|       |  // SetConsoleTextAttribute call lest it affect the text that is already
 3311|       |  // printed but has not yet reached the console.
 3312|       |  fflush(stdout);
 3313|       |  SetConsoleTextAttribute(stdout_handle, new_color);
 3314|       |
 3315|       |  vprintf(fmt, args);
 3316|       |
 3317|       |  fflush(stdout);
 3318|       |  // Restores the text color.
 3319|       |  SetConsoleTextAttribute(stdout_handle, old_color_attrs);
 3320|       |#else
 3321|      0|  printf("\033[0;3%sm", GetAnsiColorCode(color));
 3322|      0|  vprintf(fmt, args);
 3323|      0|  printf("\033[m");  // Resets the terminal to default.
 3324|      0|#endif  // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE
 3325|       |  va_end(args);
 3326|      0|}
gtest-all.cc:_ZN7testingL15FormatTestCountEi:
 3101|      2|static std::string FormatTestCount(int test_count) {
 3102|      2|  return FormatCountableNoun(test_count, "test", "tests");
 3103|      2|}
gtest-all.cc:_ZN7testingL20FormatTestSuiteCountEi:
 3106|      2|static std::string FormatTestSuiteCount(int test_suite_count) {
 3107|      2|  return FormatCountableNoun(test_suite_count, "test suite", "test suites");
 3108|      2|}
gtest-all.cc:_ZN7testingL19FormatCountableNounEiPKcS1_:
 3095|      6|                                       const char* plural_form) {
 3096|      6|  return internal::StreamableToString(count) + " " +
 3097|      6|         (count == 1 ? singular_form : plural_form);
  ------------------
  |  Branch (3097:11): [True: 6, False: 0]
  ------------------
 3098|      6|}
_ZN7testing8internal27PrettyUnitTestResultPrinter13PrintTestNameEPKcS3_:
 3355|      2|  static void PrintTestName(const char* test_suite, const char* test) {
 3356|      2|    printf("%s.%s", test_suite, test);
 3357|      2|  }
_ZN7testing8internal17TestEventRepeaterC2Ev:
 3767|      2|  TestEventRepeater() : forwarding_enabled_(true) {}
_ZN7testing8internal23ScopedPrematureExitFileC2EPKc:
 5039|      2|      : premature_exit_filepath_(
 5040|      2|            premature_exit_filepath ? premature_exit_filepath : "") {
  ------------------
  |  Branch (5040:13): [True: 0, False: 2]
  ------------------
 5041|       |    // If a path to the premature-exit file is specified...
 5042|      2|    if (!premature_exit_filepath_.empty()) {
  ------------------
  |  Branch (5042:9): [True: 0, False: 2]
  ------------------
 5043|       |      // create the file with a single "0" character in it.  I/O
 5044|       |      // errors are ignored as there's nothing better we can do and we
 5045|       |      // don't want to fail the test because of this.
 5046|      0|      FILE* pfile = posix::FOpen(premature_exit_filepath_.c_str(), "w");
 5047|      0|      fwrite("0", 1, 1, pfile);
 5048|      0|      fclose(pfile);
 5049|      0|    }
 5050|      2|  }
_ZN7testing8internal27PrettyUnitTestResultPrinterC2Ev:
 3354|      2|  PrettyUnitTestResultPrinter() = default;
_ZN7testing8internal15TestSuiteNameIsC2ERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
 5725|      4|  explicit TestSuiteNameIs(const std::string& name) : name_(name) {}
gtest-all.cc:_ZN7testing8internalL18GTestIsInitializedEv:
  419|      4|static bool GTestIsInitialized() { return !GetArgvs().empty(); }
gtest-all.cc:_ZN7testing8internalL14ParseFlagValueEPKcS2_b:
 6339|    286|                                  bool def_optional) {
 6340|       |  // str and flag must not be NULL.
 6341|    286|  if (str == nullptr || flag_name == nullptr) return nullptr;
  ------------------
  |  Branch (6341:7): [True: 0, False: 286]
  |  Branch (6341:25): [True: 0, False: 286]
  ------------------
 6342|       |
 6343|       |  // The flag must start with "--" followed by GTEST_FLAG_PREFIX_.
 6344|    286|  const std::string flag_str =
 6345|    286|      std::string("--") + GTEST_FLAG_PREFIX_ + flag_name;
  ------------------
  |  |  331|    286|#define GTEST_FLAG_PREFIX_ "gtest_"
  ------------------
 6346|    286|  const size_t flag_len = flag_str.length();
 6347|    286|  if (strncmp(str, flag_str.c_str(), flag_len) != 0) return nullptr;
  ------------------
  |  Branch (6347:7): [True: 286, False: 0]
  ------------------
 6348|       |
 6349|       |  // Skips the flag name.
 6350|      0|  const char* flag_end = str + flag_len;
 6351|       |
 6352|       |  // When def_optional is true, it's OK to not have a "=value" part.
 6353|      0|  if (def_optional && (flag_end[0] == '\0')) {
  ------------------
  |  Branch (6353:7): [True: 0, False: 0]
  |  Branch (6353:23): [True: 0, False: 0]
  ------------------
 6354|      0|    return flag_end;
 6355|      0|  }
 6356|       |
 6357|       |  // If def_optional is true and there are more characters after the
 6358|       |  // flag name, or if def_optional is false, there must be a '=' after
 6359|       |  // the flag name.
 6360|      0|  if (flag_end[0] != '=') return nullptr;
  ------------------
  |  Branch (6360:7): [True: 0, False: 0]
  ------------------
 6361|       |
 6362|       |  // Returns the string after "=".
 6363|      0|  return flag_end + 1;
 6364|      0|}
_ZN7testing8internal27PrettyUnitTestResultPrinter18OnTestProgramStartERKNS_8UnitTestE:
 3360|      2|  void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
_ZN7testing8internal27PrettyUnitTestResultPrinter22OnEnvironmentsSetUpEndERKNS_8UnitTestE:
 3363|      2|  void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) override {}
_ZN7testing8internal35HandleExceptionsInMethodIfSupportedINS_4TestEvEET0_PT_MS4_FS3_vEPKc:
 2621|      4|                                           const char* location) {
 2622|       |  // NOTE: The user code can affect the way in which Google Test handles
 2623|       |  // exceptions by setting GTEST_FLAG(catch_exceptions), but only before
 2624|       |  // RUN_ALL_TESTS() starts. It is technically possible to check the flag
 2625|       |  // after the exception is caught and either report or re-throw the
 2626|       |  // exception based on the flag's value:
 2627|       |  //
 2628|       |  // try {
 2629|       |  //   // Perform the test method.
 2630|       |  // } catch (...) {
 2631|       |  //   if (GTEST_FLAG_GET(catch_exceptions))
 2632|       |  //     // Report the exception as failure.
 2633|       |  //   else
 2634|       |  //     throw;  // Re-throws the original exception.
 2635|       |  // }
 2636|       |  //
 2637|       |  // However, the purpose of this flag is to allow the program to drop into
 2638|       |  // the debugger when the exception is thrown. On most platforms, once the
 2639|       |  // control enters the catch block, the exception origin information is
 2640|       |  // lost and the debugger will stop the program at the point of the
 2641|       |  // re-throw in this function -- instead of at the point of the original
 2642|       |  // throw statement in the code under test.  For this reason, we perform
 2643|       |  // the check early, sacrificing the ability to affect Google Test's
 2644|       |  // exception handling in the method where the exception is thrown.
 2645|      4|  if (internal::GetUnitTestImpl()->catch_exceptions()) {
  ------------------
  |  Branch (2645:7): [True: 4, False: 0]
  ------------------
 2646|      4|#if GTEST_HAS_EXCEPTIONS
 2647|      4|    try {
 2648|      4|      return HandleSehExceptionsInMethodIfSupported(object, method, location);
 2649|      4|    } catch (const AssertionException&) {  // NOLINT
 2650|       |      // This failure was reported already.
 2651|      0|    } catch (const internal::GoogleTestFailureException&) {  // NOLINT
 2652|       |      // This exception type can only be thrown by a failed Google
 2653|       |      // Test assertion with the intention of letting another testing
 2654|       |      // framework catch it.  Therefore we just re-throw it.
 2655|      0|      throw;
 2656|      0|    } catch (const std::exception& e) {  // NOLINT
 2657|      0|      internal::ReportFailureInUnknownLocation(
 2658|      0|          TestPartResult::kFatalFailure,
 2659|      0|          FormatCxxExceptionMessage(e.what(), location));
 2660|      0|    } catch (...) {  // NOLINT
 2661|      0|      internal::ReportFailureInUnknownLocation(
 2662|      0|          TestPartResult::kFatalFailure,
 2663|      0|          FormatCxxExceptionMessage(nullptr, location));
 2664|      0|    }
 2665|      0|    return static_cast<Result>(0);
 2666|       |#else
 2667|       |    return HandleSehExceptionsInMethodIfSupported(object, method, location);
 2668|       |#endif  // GTEST_HAS_EXCEPTIONS
 2669|      4|  } else {
 2670|      0|    return (object->*method)();
 2671|      0|  }
 2672|      4|}
_ZN7testing8internal38HandleSehExceptionsInMethodIfSupportedINS_4TestEvEET0_PT_MS4_FS3_vEPKc:
 2602|      4|                                              const char* location) {
 2603|       |#if GTEST_HAS_SEH
 2604|       |  __try {
 2605|       |    return (object->*method)();
 2606|       |  } __except (internal::UnitTestOptions::GTestProcessSEH(  // NOLINT
 2607|       |      GetExceptionCode(), location)) {
 2608|       |    return static_cast<Result>(0);
 2609|       |  }
 2610|       |#else
 2611|      4|  (void)location;
 2612|      4|  return (object->*method)();
 2613|      4|#endif  // GTEST_HAS_SEH
 2614|      4|}
_ZN7testing8internal35HandleExceptionsInMethodIfSupportedINS0_15TestFactoryBaseEPNS_4TestEEET0_PT_MS6_FS5_vEPKc:
 2621|      2|                                           const char* location) {
 2622|       |  // NOTE: The user code can affect the way in which Google Test handles
 2623|       |  // exceptions by setting GTEST_FLAG(catch_exceptions), but only before
 2624|       |  // RUN_ALL_TESTS() starts. It is technically possible to check the flag
 2625|       |  // after the exception is caught and either report or re-throw the
 2626|       |  // exception based on the flag's value:
 2627|       |  //
 2628|       |  // try {
 2629|       |  //   // Perform the test method.
 2630|       |  // } catch (...) {
 2631|       |  //   if (GTEST_FLAG_GET(catch_exceptions))
 2632|       |  //     // Report the exception as failure.
 2633|       |  //   else
 2634|       |  //     throw;  // Re-throws the original exception.
 2635|       |  // }
 2636|       |  //
 2637|       |  // However, the purpose of this flag is to allow the program to drop into
 2638|       |  // the debugger when the exception is thrown. On most platforms, once the
 2639|       |  // control enters the catch block, the exception origin information is
 2640|       |  // lost and the debugger will stop the program at the point of the
 2641|       |  // re-throw in this function -- instead of at the point of the original
 2642|       |  // throw statement in the code under test.  For this reason, we perform
 2643|       |  // the check early, sacrificing the ability to affect Google Test's
 2644|       |  // exception handling in the method where the exception is thrown.
 2645|      2|  if (internal::GetUnitTestImpl()->catch_exceptions()) {
  ------------------
  |  Branch (2645:7): [True: 2, False: 0]
  ------------------
 2646|      2|#if GTEST_HAS_EXCEPTIONS
 2647|      2|    try {
 2648|      2|      return HandleSehExceptionsInMethodIfSupported(object, method, location);
 2649|      2|    } catch (const AssertionException&) {  // NOLINT
 2650|       |      // This failure was reported already.
 2651|      0|    } catch (const internal::GoogleTestFailureException&) {  // NOLINT
 2652|       |      // This exception type can only be thrown by a failed Google
 2653|       |      // Test assertion with the intention of letting another testing
 2654|       |      // framework catch it.  Therefore we just re-throw it.
 2655|      0|      throw;
 2656|      0|    } catch (const std::exception& e) {  // NOLINT
 2657|      0|      internal::ReportFailureInUnknownLocation(
 2658|      0|          TestPartResult::kFatalFailure,
 2659|      0|          FormatCxxExceptionMessage(e.what(), location));
 2660|      0|    } catch (...) {  // NOLINT
 2661|      0|      internal::ReportFailureInUnknownLocation(
 2662|      0|          TestPartResult::kFatalFailure,
 2663|      0|          FormatCxxExceptionMessage(nullptr, location));
 2664|      0|    }
 2665|      0|    return static_cast<Result>(0);
 2666|       |#else
 2667|       |    return HandleSehExceptionsInMethodIfSupported(object, method, location);
 2668|       |#endif  // GTEST_HAS_EXCEPTIONS
 2669|      2|  } else {
 2670|      0|    return (object->*method)();
 2671|      0|  }
 2672|      2|}
_ZN7testing8internal38HandleSehExceptionsInMethodIfSupportedINS0_15TestFactoryBaseEPNS_4TestEEET0_PT_MS6_FS5_vEPKc:
 2602|      2|                                              const char* location) {
 2603|       |#if GTEST_HAS_SEH
 2604|       |  __try {
 2605|       |    return (object->*method)();
 2606|       |  } __except (internal::UnitTestOptions::GTestProcessSEH(  // NOLINT
 2607|       |      GetExceptionCode(), location)) {
 2608|       |    return static_cast<Result>(0);
 2609|       |  }
 2610|       |#else
 2611|      2|  (void)location;
 2612|      2|  return (object->*method)();
 2613|      2|#endif  // GTEST_HAS_SEH
 2614|      2|}
gtest-all.cc:_ZZN7testing9TestSuite3RunEvENK3$_0clEPKNS_8TestInfoES4_:
 2987|      2|                   [](const TestInfo* const a, const TestInfo* const b) {
 2988|      2|                     if (const int result = std::strcmp(a->file(), b->file())) {
  ------------------
  |  Branch (2988:36): [True: 0, False: 2]
  ------------------
 2989|      0|                       return result < 0;
 2990|      0|                     }
 2991|       |
 2992|      2|                     return a->line() < b->line();
 2993|      2|                   });
_ZN7testing8internal35HandleExceptionsInMethodIfSupportedINS_9TestSuiteEvEET0_PT_MS4_FS3_vEPKc:
 2621|      2|                                           const char* location) {
 2622|       |  // NOTE: The user code can affect the way in which Google Test handles
 2623|       |  // exceptions by setting GTEST_FLAG(catch_exceptions), but only before
 2624|       |  // RUN_ALL_TESTS() starts. It is technically possible to check the flag
 2625|       |  // after the exception is caught and either report or re-throw the
 2626|       |  // exception based on the flag's value:
 2627|       |  //
 2628|       |  // try {
 2629|       |  //   // Perform the test method.
 2630|       |  // } catch (...) {
 2631|       |  //   if (GTEST_FLAG_GET(catch_exceptions))
 2632|       |  //     // Report the exception as failure.
 2633|       |  //   else
 2634|       |  //     throw;  // Re-throws the original exception.
 2635|       |  // }
 2636|       |  //
 2637|       |  // However, the purpose of this flag is to allow the program to drop into
 2638|       |  // the debugger when the exception is thrown. On most platforms, once the
 2639|       |  // control enters the catch block, the exception origin information is
 2640|       |  // lost and the debugger will stop the program at the point of the
 2641|       |  // re-throw in this function -- instead of at the point of the original
 2642|       |  // throw statement in the code under test.  For this reason, we perform
 2643|       |  // the check early, sacrificing the ability to affect Google Test's
 2644|       |  // exception handling in the method where the exception is thrown.
 2645|      2|  if (internal::GetUnitTestImpl()->catch_exceptions()) {
  ------------------
  |  Branch (2645:7): [True: 2, False: 0]
  ------------------
 2646|      2|#if GTEST_HAS_EXCEPTIONS
 2647|      2|    try {
 2648|      2|      return HandleSehExceptionsInMethodIfSupported(object, method, location);
 2649|      2|    } catch (const AssertionException&) {  // NOLINT
 2650|       |      // This failure was reported already.
 2651|      0|    } catch (const internal::GoogleTestFailureException&) {  // NOLINT
 2652|       |      // This exception type can only be thrown by a failed Google
 2653|       |      // Test assertion with the intention of letting another testing
 2654|       |      // framework catch it.  Therefore we just re-throw it.
 2655|      0|      throw;
 2656|      0|    } catch (const std::exception& e) {  // NOLINT
 2657|      0|      internal::ReportFailureInUnknownLocation(
 2658|      0|          TestPartResult::kFatalFailure,
 2659|      0|          FormatCxxExceptionMessage(e.what(), location));
 2660|      0|    } catch (...) {  // NOLINT
 2661|      0|      internal::ReportFailureInUnknownLocation(
 2662|      0|          TestPartResult::kFatalFailure,
 2663|      0|          FormatCxxExceptionMessage(nullptr, location));
 2664|      0|    }
 2665|      0|    return static_cast<Result>(0);
 2666|       |#else
 2667|       |    return HandleSehExceptionsInMethodIfSupported(object, method, location);
 2668|       |#endif  // GTEST_HAS_EXCEPTIONS
 2669|      2|  } else {
 2670|      0|    return (object->*method)();
 2671|      0|  }
 2672|      2|}
_ZN7testing8internal38HandleSehExceptionsInMethodIfSupportedINS_9TestSuiteEvEET0_PT_MS4_FS3_vEPKc:
 2602|      2|                                              const char* location) {
 2603|       |#if GTEST_HAS_SEH
 2604|       |  __try {
 2605|       |    return (object->*method)();
 2606|       |  } __except (internal::UnitTestOptions::GTestProcessSEH(  // NOLINT
 2607|       |      GetExceptionCode(), location)) {
 2608|       |    return static_cast<Result>(0);
 2609|       |  }
 2610|       |#else
 2611|      2|  (void)location;
 2612|      2|  return (object->*method)();
 2613|      2|#endif  // GTEST_HAS_SEH
 2614|      2|}
_ZN7testing8internal35HandleExceptionsInMethodIfSupportedINS0_12UnitTestImplEbEET0_PT_MS4_FS3_vEPKc:
 2621|      2|                                           const char* location) {
 2622|       |  // NOTE: The user code can affect the way in which Google Test handles
 2623|       |  // exceptions by setting GTEST_FLAG(catch_exceptions), but only before
 2624|       |  // RUN_ALL_TESTS() starts. It is technically possible to check the flag
 2625|       |  // after the exception is caught and either report or re-throw the
 2626|       |  // exception based on the flag's value:
 2627|       |  //
 2628|       |  // try {
 2629|       |  //   // Perform the test method.
 2630|       |  // } catch (...) {
 2631|       |  //   if (GTEST_FLAG_GET(catch_exceptions))
 2632|       |  //     // Report the exception as failure.
 2633|       |  //   else
 2634|       |  //     throw;  // Re-throws the original exception.
 2635|       |  // }
 2636|       |  //
 2637|       |  // However, the purpose of this flag is to allow the program to drop into
 2638|       |  // the debugger when the exception is thrown. On most platforms, once the
 2639|       |  // control enters the catch block, the exception origin information is
 2640|       |  // lost and the debugger will stop the program at the point of the
 2641|       |  // re-throw in this function -- instead of at the point of the original
 2642|       |  // throw statement in the code under test.  For this reason, we perform
 2643|       |  // the check early, sacrificing the ability to affect Google Test's
 2644|       |  // exception handling in the method where the exception is thrown.
 2645|      2|  if (internal::GetUnitTestImpl()->catch_exceptions()) {
  ------------------
  |  Branch (2645:7): [True: 2, False: 0]
  ------------------
 2646|      2|#if GTEST_HAS_EXCEPTIONS
 2647|      2|    try {
 2648|      2|      return HandleSehExceptionsInMethodIfSupported(object, method, location);
 2649|      2|    } catch (const AssertionException&) {  // NOLINT
 2650|       |      // This failure was reported already.
 2651|      0|    } catch (const internal::GoogleTestFailureException&) {  // NOLINT
 2652|       |      // This exception type can only be thrown by a failed Google
 2653|       |      // Test assertion with the intention of letting another testing
 2654|       |      // framework catch it.  Therefore we just re-throw it.
 2655|      0|      throw;
 2656|      0|    } catch (const std::exception& e) {  // NOLINT
 2657|      0|      internal::ReportFailureInUnknownLocation(
 2658|      0|          TestPartResult::kFatalFailure,
 2659|      0|          FormatCxxExceptionMessage(e.what(), location));
 2660|      0|    } catch (...) {  // NOLINT
 2661|      0|      internal::ReportFailureInUnknownLocation(
 2662|      0|          TestPartResult::kFatalFailure,
 2663|      0|          FormatCxxExceptionMessage(nullptr, location));
 2664|      0|    }
 2665|      0|    return static_cast<Result>(0);
 2666|       |#else
 2667|       |    return HandleSehExceptionsInMethodIfSupported(object, method, location);
 2668|       |#endif  // GTEST_HAS_EXCEPTIONS
 2669|      2|  } else {
 2670|      0|    return (object->*method)();
 2671|      0|  }
 2672|      2|}
_ZN7testing8internal38HandleSehExceptionsInMethodIfSupportedINS0_12UnitTestImplEbEET0_PT_MS4_FS3_vEPKc:
 2602|      2|                                              const char* location) {
 2603|       |#if GTEST_HAS_SEH
 2604|       |  __try {
 2605|       |    return (object->*method)();
 2606|       |  } __except (internal::UnitTestOptions::GTestProcessSEH(  // NOLINT
 2607|       |      GetExceptionCode(), location)) {
 2608|       |    return static_cast<Result>(0);
 2609|       |  }
 2610|       |#else
 2611|      2|  (void)location;
 2612|      2|  return (object->*method)();
 2613|      2|#endif  // GTEST_HAS_SEH
 2614|      2|}
_ZNK7testing8internal15TestSuiteNameIsclEPKNS_9TestSuiteE:
 5728|      2|  bool operator()(const TestSuite* test_suite) const {
 5729|      2|    return test_suite != nullptr &&
  ------------------
  |  Branch (5729:12): [True: 2, False: 0]
  ------------------
 5730|      2|           strcmp(test_suite->name(), name_.c_str()) == 0;
  ------------------
  |  Branch (5730:12): [True: 2, False: 0]
  ------------------
 5731|      2|  }
_ZN7testing8internal28ParseGoogleTestFlagsOnlyImplIcEEvPiPPT_:
 6630|      2|void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
 6631|      2|  std::string flagfile_value;
 6632|     15|  for (int i = 1; i < *argc; i++) {
  ------------------
  |  Branch (6632:19): [True: 13, False: 2]
  ------------------
 6633|     13|    const std::string arg_string = StreamableToString(argv[i]);
 6634|     13|    const char* const arg = arg_string.c_str();
 6635|       |
 6636|     13|    using internal::ParseFlag;
 6637|       |
 6638|     13|    bool remove_flag = false;
 6639|     13|    if (ParseGoogleTestFlag(arg)) {
  ------------------
  |  Branch (6639:9): [True: 0, False: 13]
  ------------------
 6640|      0|      remove_flag = true;
 6641|      0|#if GTEST_USE_OWN_FLAGFILE_FLAG_ && GTEST_HAS_FILE_SYSTEM
 6642|     13|    } else if (ParseFlag(arg, "flagfile", &flagfile_value)) {
  ------------------
  |  Branch (6642:16): [True: 0, False: 13]
  ------------------
 6643|      0|      GTEST_FLAG_SET(flagfile, flagfile_value);
  ------------------
  |  | 2294|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  ------------------
  |  |  |  | 2226|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
 6644|      0|      LoadFlagsFromFile(flagfile_value);
 6645|      0|      remove_flag = true;
 6646|      0|#endif  // GTEST_USE_OWN_FLAGFILE_FLAG_ && GTEST_HAS_FILE_SYSTEM
 6647|     13|    } else if (arg_string == "--help" || HasGoogleTestFlagPrefix(arg)) {
  ------------------
  |  Branch (6647:16): [True: 0, False: 13]
  |  Branch (6647:42): [True: 0, False: 13]
  ------------------
 6648|       |      // Both help flag and unrecognized Google Test flags (excluding
 6649|       |      // internal ones) trigger help display.
 6650|      0|      g_help_flag = true;
 6651|      0|    }
 6652|       |
 6653|     13|    if (remove_flag) {
  ------------------
  |  Branch (6653:9): [True: 0, False: 13]
  ------------------
 6654|       |      // Shift the remainder of the argv list left by one.  Note
 6655|       |      // that argv has (*argc + 1) elements, the last one always being
 6656|       |      // NULL.  The following loop moves the trailing NULL element as
 6657|       |      // well.
 6658|      0|      for (int j = i; j != *argc; j++) {
  ------------------
  |  Branch (6658:23): [True: 0, False: 0]
  ------------------
 6659|      0|        argv[j] = argv[j + 1];
 6660|      0|      }
 6661|       |
 6662|       |      // Decrements the argument count.
 6663|      0|      (*argc)--;
 6664|       |
 6665|       |      // We also need to decrement the iterator as we just removed
 6666|       |      // an element.
 6667|      0|      i--;
 6668|      0|    }
 6669|     13|  }
 6670|       |
 6671|      2|  if (g_help_flag) {
  ------------------
  |  Branch (6671:7): [True: 0, False: 2]
  ------------------
 6672|       |    // We print the help here instead of in RUN_ALL_TESTS(), as the
 6673|       |    // latter may not be called at all if the user is using Google
 6674|       |    // Test with another testing framework.
 6675|      0|    PrintColorEncoded(kColorEncodedHelpMessage);
 6676|      0|  }
 6677|      2|}
gtest-all.cc:_ZN7testing8internalL19ParseGoogleTestFlagEPKc:
 6574|     13|static bool ParseGoogleTestFlag(const char* const arg) {
 6575|     13|#define GTEST_INTERNAL_PARSE_FLAG(flag_name)  \
 6576|     13|  do {                                        \
 6577|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
 6578|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
 6579|     13|      GTEST_FLAG_SET(flag_name, value);       \
 6580|     13|      return true;                            \
 6581|     13|    }                                         \
 6582|     13|  } while (false)
 6583|       |
 6584|     13|  GTEST_INTERNAL_PARSE_FLAG(also_run_disabled_tests);
  ------------------
  |  | 6576|     13|  do {                                        \
  |  | 6577|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2293|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6578|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6578:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6579|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2294|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6580|      0|      return true;                            \
  |  | 6581|      0|    }                                         \
  |  | 6582|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6582:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6585|     13|  GTEST_INTERNAL_PARSE_FLAG(break_on_failure);
  ------------------
  |  | 6576|     13|  do {                                        \
  |  | 6577|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2293|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6578|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6578:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6579|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2294|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6580|      0|      return true;                            \
  |  | 6581|      0|    }                                         \
  |  | 6582|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6582:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6586|     13|  GTEST_INTERNAL_PARSE_FLAG(catch_exceptions);
  ------------------
  |  | 6576|     13|  do {                                        \
  |  | 6577|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2293|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6578|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6578:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6579|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2294|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6580|      0|      return true;                            \
  |  | 6581|      0|    }                                         \
  |  | 6582|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6582:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6587|     13|  GTEST_INTERNAL_PARSE_FLAG(color);
  ------------------
  |  | 6576|     13|  do {                                        \
  |  | 6577|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2293|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6578|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6578:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6579|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2294|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6580|      0|      return true;                            \
  |  | 6581|      0|    }                                         \
  |  | 6582|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6582:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6588|     13|  GTEST_INTERNAL_PARSE_FLAG(death_test_style);
  ------------------
  |  | 6576|     13|  do {                                        \
  |  | 6577|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2293|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6578|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6578:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6579|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2294|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6580|      0|      return true;                            \
  |  | 6581|      0|    }                                         \
  |  | 6582|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6582:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6589|     13|  GTEST_INTERNAL_PARSE_FLAG(death_test_use_fork);
  ------------------
  |  | 6576|     13|  do {                                        \
  |  | 6577|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2293|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6578|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6578:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6579|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2294|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6580|      0|      return true;                            \
  |  | 6581|      0|    }                                         \
  |  | 6582|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6582:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6590|     13|  GTEST_INTERNAL_PARSE_FLAG(fail_fast);
  ------------------
  |  | 6576|     13|  do {                                        \
  |  | 6577|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2293|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6578|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6578:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6579|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2294|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6580|      0|      return true;                            \
  |  | 6581|      0|    }                                         \
  |  | 6582|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6582:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6591|     13|  GTEST_INTERNAL_PARSE_FLAG(filter);
  ------------------
  |  | 6576|     13|  do {                                        \
  |  | 6577|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2293|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6578|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6578:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6579|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2294|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6580|      0|      return true;                            \
  |  | 6581|      0|    }                                         \
  |  | 6582|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6582:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6592|     13|  GTEST_INTERNAL_PARSE_FLAG(internal_run_death_test);
  ------------------
  |  | 6576|     13|  do {                                        \
  |  | 6577|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2293|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6578|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6578:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6579|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2294|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6580|      0|      return true;                            \
  |  | 6581|      0|    }                                         \
  |  | 6582|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6582:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6593|     13|  GTEST_INTERNAL_PARSE_FLAG(list_tests);
  ------------------
  |  | 6576|     13|  do {                                        \
  |  | 6577|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2293|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6578|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6578:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6579|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2294|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6580|      0|      return true;                            \
  |  | 6581|      0|    }                                         \
  |  | 6582|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6582:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6594|     13|  GTEST_INTERNAL_PARSE_FLAG(output);
  ------------------
  |  | 6576|     13|  do {                                        \
  |  | 6577|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2293|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6578|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6578:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6579|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2294|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6580|      0|      return true;                            \
  |  | 6581|      0|    }                                         \
  |  | 6582|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6582:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6595|     13|  GTEST_INTERNAL_PARSE_FLAG(brief);
  ------------------
  |  | 6576|     13|  do {                                        \
  |  | 6577|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2293|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6578|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6578:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6579|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2294|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6580|      0|      return true;                            \
  |  | 6581|      0|    }                                         \
  |  | 6582|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6582:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6596|     13|  GTEST_INTERNAL_PARSE_FLAG(print_time);
  ------------------
  |  | 6576|     13|  do {                                        \
  |  | 6577|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2293|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6578|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6578:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6579|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2294|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6580|      0|      return true;                            \
  |  | 6581|      0|    }                                         \
  |  | 6582|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6582:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6597|     13|  GTEST_INTERNAL_PARSE_FLAG(print_utf8);
  ------------------
  |  | 6576|     13|  do {                                        \
  |  | 6577|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2293|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6578|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6578:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6579|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2294|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6580|      0|      return true;                            \
  |  | 6581|      0|    }                                         \
  |  | 6582|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6582:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6598|     13|  GTEST_INTERNAL_PARSE_FLAG(random_seed);
  ------------------
  |  | 6576|     13|  do {                                        \
  |  | 6577|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2293|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6578|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6578:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6579|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2294|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6580|      0|      return true;                            \
  |  | 6581|      0|    }                                         \
  |  | 6582|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6582:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6599|     13|  GTEST_INTERNAL_PARSE_FLAG(repeat);
  ------------------
  |  | 6576|     13|  do {                                        \
  |  | 6577|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2293|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6578|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6578:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6579|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2294|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6580|      0|      return true;                            \
  |  | 6581|      0|    }                                         \
  |  | 6582|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6582:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6600|     13|  GTEST_INTERNAL_PARSE_FLAG(recreate_environments_when_repeating);
  ------------------
  |  | 6576|     13|  do {                                        \
  |  | 6577|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2293|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6578|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6578:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6579|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2294|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6580|      0|      return true;                            \
  |  | 6581|      0|    }                                         \
  |  | 6582|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6582:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6601|     13|  GTEST_INTERNAL_PARSE_FLAG(shuffle);
  ------------------
  |  | 6576|     13|  do {                                        \
  |  | 6577|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2293|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6578|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6578:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6579|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2294|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6580|      0|      return true;                            \
  |  | 6581|      0|    }                                         \
  |  | 6582|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6582:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6602|     13|  GTEST_INTERNAL_PARSE_FLAG(stack_trace_depth);
  ------------------
  |  | 6576|     13|  do {                                        \
  |  | 6577|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2293|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6578|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6578:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6579|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2294|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6580|      0|      return true;                            \
  |  | 6581|      0|    }                                         \
  |  | 6582|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6582:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6603|     13|  GTEST_INTERNAL_PARSE_FLAG(stream_result_to);
  ------------------
  |  | 6576|     13|  do {                                        \
  |  | 6577|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2293|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6578|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6578:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6579|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2294|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6580|      0|      return true;                            \
  |  | 6581|      0|    }                                         \
  |  | 6582|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6582:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6604|     13|  GTEST_INTERNAL_PARSE_FLAG(throw_on_failure);
  ------------------
  |  | 6576|     13|  do {                                        \
  |  | 6577|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2293|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6578|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6578:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6579|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2294|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6580|      0|      return true;                            \
  |  | 6581|      0|    }                                         \
  |  | 6582|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6582:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6605|     13|  return false;
 6606|     13|}
gtest-all.cc:_ZN7testing8internalL9ParseFlagEPKcS2_Pb:
 6376|    156|static bool ParseFlag(const char* str, const char* flag_name, bool* value) {
 6377|       |  // Gets the value of the flag as a string.
 6378|    156|  const char* const value_str = ParseFlagValue(str, flag_name, true);
 6379|       |
 6380|       |  // Aborts if the parsing failed.
 6381|    156|  if (value_str == nullptr) return false;
  ------------------
  |  Branch (6381:7): [True: 156, False: 0]
  ------------------
 6382|       |
 6383|       |  // Converts the string value to a bool.
 6384|      0|  *value = !(*value_str == '0' || *value_str == 'f' || *value_str == 'F');
  ------------------
  |  Branch (6384:14): [True: 0, False: 0]
  |  Branch (6384:35): [True: 0, False: 0]
  |  Branch (6384:56): [True: 0, False: 0]
  ------------------
 6385|      0|  return true;
 6386|    156|}
gtest-all.cc:_ZN7testing8internalL9ParseFlagINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEbPKcSA_PT_:
 6409|     91|static bool ParseFlag(const char* str, const char* flag_name, String* value) {
 6410|       |  // Gets the value of the flag as a string.
 6411|     91|  const char* const value_str = ParseFlagValue(str, flag_name, false);
 6412|       |
 6413|       |  // Aborts if the parsing failed.
 6414|     91|  if (value_str == nullptr) return false;
  ------------------
  |  Branch (6414:7): [True: 91, False: 0]
  ------------------
 6415|       |
 6416|       |  // Sets *value to the value of the flag.
 6417|      0|  *value = value_str;
 6418|      0|  return true;
 6419|     91|}
gtest-all.cc:_ZN7testing8internalL23HasGoogleTestFlagPrefixEPKc:
 6427|     13|static bool HasGoogleTestFlagPrefix(const char* str) {
 6428|     13|  return (SkipPrefix("--", &str) || SkipPrefix("-", &str) ||
  ------------------
  |  Branch (6428:11): [True: 4, False: 9]
  |  Branch (6428:37): [True: 5, False: 4]
  ------------------
 6429|      4|          SkipPrefix("/", &str)) &&
  ------------------
  |  Branch (6429:11): [True: 4, False: 0]
  ------------------
 6430|     13|         !SkipPrefix(GTEST_FLAG_PREFIX_ "internal_", &str) &&
  ------------------
  |  |  331|     13|#define GTEST_FLAG_PREFIX_ "gtest_"
  ------------------
  |  Branch (6430:10): [True: 13, False: 0]
  ------------------
 6431|     13|         (SkipPrefix(GTEST_FLAG_PREFIX_, &str) ||
  ------------------
  |  |  331|     13|#define GTEST_FLAG_PREFIX_ "gtest_"
  ------------------
  |  Branch (6431:11): [True: 0, False: 13]
  ------------------
 6432|     13|          SkipPrefix(GTEST_FLAG_PREFIX_DASH_, &str));
  ------------------
  |  |  332|     13|#define GTEST_FLAG_PREFIX_DASH_ "gtest-"
  ------------------
  |  Branch (6432:11): [True: 0, False: 13]
  ------------------
 6433|     13|}
_ZN7testing8internal18InitGoogleTestImplIcEEvPiPPT_:
 6758|      2|void InitGoogleTestImpl(int* argc, CharType** argv) {
 6759|       |  // We don't want to run the initialization code twice.
 6760|      2|  if (GTestIsInitialized()) return;
  ------------------
  |  Branch (6760:7): [True: 0, False: 2]
  ------------------
 6761|       |
 6762|      2|  if (*argc <= 0) return;
  ------------------
  |  Branch (6762:7): [True: 0, False: 2]
  ------------------
 6763|       |
 6764|      2|  g_argvs.clear();
 6765|     17|  for (int i = 0; i != *argc; i++) {
  ------------------
  |  Branch (6765:19): [True: 15, False: 2]
  ------------------
 6766|     15|    g_argvs.push_back(StreamableToString(argv[i]));
 6767|     15|  }
 6768|       |
 6769|       |#ifdef GTEST_HAS_ABSL
 6770|       |  absl::InitializeSymbolizer(g_argvs[0].c_str());
 6771|       |
 6772|       |  // When using the Abseil Flags library, set the program usage message to the
 6773|       |  // help message, but remove the color-encoding from the message first.
 6774|       |  absl::SetProgramUsageMessage(absl::StrReplaceAll(
 6775|       |      kColorEncodedHelpMessage,
 6776|       |      {{"@D", ""}, {"@R", ""}, {"@G", ""}, {"@Y", ""}, {"@@", "@"}}));
 6777|       |#endif  // GTEST_HAS_ABSL
 6778|       |
 6779|      2|  ParseGoogleTestFlagsOnly(argc, argv);
 6780|      2|  GetUnitTestImpl()->PostFlagParsingInit();
 6781|      2|}

WebPDeallocateAlphaMemory:
  175|  5.17k|void WebPDeallocateAlphaMemory(VP8Decoder* const dec) {
  176|  5.17k|  assert(dec != NULL);
  177|  5.17k|  WebPSafeFree(dec->alpha_plane_mem);
  178|  5.17k|  dec->alpha_plane_mem = NULL;
  179|  5.17k|  dec->alpha_plane = NULL;
  180|  5.17k|  ALPHDelete(dec->alph_dec);
  181|       |  dec->alph_dec = NULL;
  182|  5.17k|}
alpha_dec.c:ALPHDelete:
   41|  5.17k|static void ALPHDelete(ALPHDecoder* const dec) {
   42|  5.17k|  if (dec != NULL) {
  ------------------
  |  Branch (42:7): [True: 0, False: 5.17k]
  ------------------
   43|      0|    VP8LDelete(dec->vp8l_dec);
   44|       |    dec->vp8l_dec = NULL;
   45|      0|    WebPSafeFree(dec);
   46|      0|  }
   47|  5.17k|}

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

VP8InitDithering:
  343|  2.66k|                      VP8Decoder* const dec) {
  344|  2.66k|  assert(dec != NULL);
  345|  2.66k|  if (options != NULL) {
  ------------------
  |  Branch (345:7): [True: 0, False: 2.66k]
  ------------------
  346|      0|    const int d = options->dithering_strength;
  347|      0|    const int max_amp = (1 << VP8_RANDOM_DITHER_FIX) - 1;
  ------------------
  |  |   29|      0|#define VP8_RANDOM_DITHER_FIX 8  // fixed-point precision for dithering
  ------------------
  348|      0|    const int f = (d < 0) ? 0 : (d > 100) ? max_amp : (d * max_amp / 100);
  ------------------
  |  Branch (348:19): [True: 0, False: 0]
  |  Branch (348:33): [True: 0, False: 0]
  ------------------
  349|      0|    if (f > 0) {
  ------------------
  |  Branch (349:9): [True: 0, False: 0]
  ------------------
  350|      0|      int s;
  351|      0|      int all_amp = 0;
  352|      0|      for (s = 0; s < NUM_MB_SEGMENTS; ++s) {
  ------------------
  |  Branch (352:19): [True: 0, False: 0]
  ------------------
  353|      0|        VP8QuantMatrix* const dqm = &dec->dqm[s];
  354|      0|        if (dqm->uv_quant < DITHER_AMP_TAB_SIZE) {
  ------------------
  |  |  337|      0|#define DITHER_AMP_TAB_SIZE 12
  ------------------
  |  Branch (354:13): [True: 0, False: 0]
  ------------------
  355|      0|          const int idx = (dqm->uv_quant < 0) ? 0 : dqm->uv_quant;
  ------------------
  |  Branch (355:27): [True: 0, False: 0]
  ------------------
  356|      0|          dqm->dither = (f * kQuantToDitherAmp[idx]) >> 3;
  357|      0|        }
  358|      0|        all_amp |= dqm->dither;
  359|      0|      }
  360|      0|      if (all_amp != 0) {
  ------------------
  |  Branch (360:11): [True: 0, False: 0]
  ------------------
  361|      0|        VP8InitRandom(&dec->dithering_rg, 1.0f);
  362|      0|        dec->dither = 1;
  363|      0|      }
  364|      0|    }
  365|       |    // potentially allow alpha dithering
  366|      0|    dec->alpha_dithering = options->alpha_dithering_strength;
  367|      0|    if (dec->alpha_dithering > 100) {
  ------------------
  |  Branch (367:9): [True: 0, False: 0]
  ------------------
  368|      0|      dec->alpha_dithering = 100;
  369|      0|    } else if (dec->alpha_dithering < 0) {
  ------------------
  |  Branch (369:16): [True: 0, False: 0]
  ------------------
  370|      0|      dec->alpha_dithering = 0;
  371|      0|    }
  372|      0|  }
  373|  2.66k|}
VP8ProcessRow:
  518|  35.0k|int VP8ProcessRow(VP8Decoder* const dec, VP8Io* const io) {
  519|  35.0k|  int ok = 1;
  520|  35.0k|  VP8ThreadContext* const ctx = &dec->thread_ctx;
  521|  35.0k|  const int filter_row = (dec->filter_type > 0) &&
  ------------------
  |  Branch (521:26): [True: 32.3k, False: 2.78k]
  ------------------
  522|  32.3k|                         (dec->mb_y >= dec->tl_mb_y) &&
  ------------------
  |  Branch (522:26): [True: 32.3k, False: 0]
  ------------------
  523|  32.3k|                         (dec->mb_y <= dec->br_mb_y);
  ------------------
  |  Branch (523:26): [True: 32.3k, False: 0]
  ------------------
  524|  35.0k|  if (dec->mt_method == 0) {
  ------------------
  |  Branch (524:7): [True: 35.0k, False: 0]
  ------------------
  525|       |    // ctx->id and ctx->f_info are already set
  526|  35.0k|    ctx->mb_y = dec->mb_y;
  527|  35.0k|    ctx->filter_row = filter_row;
  528|  35.0k|    ReconstructRow(dec, ctx);
  529|  35.0k|    ok = FinishRow(dec, io);
  530|  35.0k|  } else {
  531|      0|    WebPWorker* const worker = &dec->worker;
  532|       |    // Finish previous job *before* updating context
  533|      0|    ok &= WebPGetWorkerInterface()->Sync(worker);
  534|      0|    assert(worker->status == OK);
  535|      0|    if (ok) {  // spawn a new deblocking/output job
  ------------------
  |  Branch (535:9): [True: 0, False: 0]
  ------------------
  536|      0|      ctx->io = *io;
  537|      0|      ctx->id = dec->cache_id;
  538|      0|      ctx->mb_y = dec->mb_y;
  539|      0|      ctx->filter_row = filter_row;
  540|      0|      if (dec->mt_method == 2) {  // swap macroblock data
  ------------------
  |  Branch (540:11): [True: 0, False: 0]
  ------------------
  541|      0|        VP8MBData* const tmp = ctx->mb_data;
  542|      0|        ctx->mb_data = dec->mb_data;
  543|      0|        dec->mb_data = tmp;
  544|      0|      } else {
  545|       |        // perform reconstruction directly in main thread
  546|      0|        ReconstructRow(dec, ctx);
  547|      0|      }
  548|      0|      if (filter_row) {  // swap filter info
  ------------------
  |  Branch (548:11): [True: 0, False: 0]
  ------------------
  549|      0|        VP8FInfo* const tmp = ctx->f_info;
  550|      0|        ctx->f_info = dec->f_info;
  551|      0|        dec->f_info = tmp;
  552|      0|      }
  553|       |      // (reconstruct)+filter in parallel
  554|      0|      WebPGetWorkerInterface()->Launch(worker);
  555|      0|      if (++dec->cache_id == dec->num_caches) {
  ------------------
  |  Branch (555:11): [True: 0, False: 0]
  ------------------
  556|      0|        dec->cache_id = 0;
  557|      0|      }
  558|      0|    }
  559|      0|  }
  560|  35.0k|  return ok;
  561|  35.0k|}
VP8EnterCritical:
  566|  2.66k|VP8StatusCode VP8EnterCritical(VP8Decoder* const dec, VP8Io* const io) {
  567|       |  // Call setup() first. This may trigger additional decoding features on 'io'.
  568|       |  // Note: Afterward, we must call teardown() no matter what.
  569|  2.66k|  if (io->setup != NULL && !io->setup(io)) {
  ------------------
  |  Branch (569:7): [True: 2.66k, False: 0]
  |  Branch (569:28): [True: 0, False: 2.66k]
  ------------------
  570|      0|    VP8SetError(dec, VP8_STATUS_INVALID_PARAM, "Frame setup failed");
  571|      0|    return dec->status;
  572|      0|  }
  573|       |
  574|       |  // Disable filtering per user request
  575|  2.66k|  if (io->bypass_filtering) {
  ------------------
  |  Branch (575:7): [True: 0, False: 2.66k]
  ------------------
  576|      0|    dec->filter_type = 0;
  577|      0|  }
  578|       |
  579|       |  // Define the area where we can skip in-loop filtering, in case of cropping.
  580|       |  //
  581|       |  // 'Simple' filter reads two luma samples outside of the macroblock
  582|       |  // and filters one. It doesn't filter the chroma samples. Hence, we can
  583|       |  // avoid doing the in-loop filtering before crop_top/crop_left position.
  584|       |  // For the 'Complex' filter, 3 samples are read and up to 3 are filtered.
  585|       |  // Means: there's a dependency chain that goes all the way up to the
  586|       |  // top-left corner of the picture (MB #0). We must filter all the previous
  587|       |  // macroblocks.
  588|  2.66k|  {
  589|  2.66k|    const int extra_pixels = kFilterExtraRows[dec->filter_type];
  590|  2.66k|    if (dec->filter_type == 2) {
  ------------------
  |  Branch (590:9): [True: 1.38k, False: 1.28k]
  ------------------
  591|       |      // For complex filter, we need to preserve the dependency chain.
  592|  1.38k|      dec->tl_mb_x = 0;
  593|  1.38k|      dec->tl_mb_y = 0;
  594|  1.38k|    } else {
  595|       |      // For simple filter, we can filter only the cropped region.
  596|       |      // We include 'extra_pixels' on the other side of the boundary, since
  597|       |      // vertical or horizontal filtering of the previous macroblock can
  598|       |      // modify some abutting pixels.
  599|  1.28k|      dec->tl_mb_x = (io->crop_left - extra_pixels) >> 4;
  600|  1.28k|      dec->tl_mb_y = (io->crop_top - extra_pixels) >> 4;
  601|  1.28k|      if (dec->tl_mb_x < 0) dec->tl_mb_x = 0;
  ------------------
  |  Branch (601:11): [True: 1.12k, False: 159]
  ------------------
  602|  1.28k|      if (dec->tl_mb_y < 0) dec->tl_mb_y = 0;
  ------------------
  |  Branch (602:11): [True: 1.12k, False: 159]
  ------------------
  603|  1.28k|    }
  604|       |    // We need some 'extra' pixels on the right/bottom.
  605|  2.66k|    dec->br_mb_y = (io->crop_bottom + 15 + extra_pixels) >> 4;
  606|  2.66k|    dec->br_mb_x = (io->crop_right + 15 + extra_pixels) >> 4;
  607|  2.66k|    if (dec->br_mb_x > dec->mb_w) {
  ------------------
  |  Branch (607:9): [True: 494, False: 2.17k]
  ------------------
  608|    494|      dec->br_mb_x = dec->mb_w;
  609|    494|    }
  610|  2.66k|    if (dec->br_mb_y > dec->mb_h) {
  ------------------
  |  Branch (610:9): [True: 690, False: 1.97k]
  ------------------
  611|    690|      dec->br_mb_y = dec->mb_h;
  612|    690|    }
  613|  2.66k|  }
  614|  2.66k|  PrecomputeFilterStrengths(dec);
  615|  2.66k|  return VP8_STATUS_OK;
  616|  2.66k|}
VP8ExitCritical:
  618|  2.66k|int VP8ExitCritical(VP8Decoder* const dec, VP8Io* const io) {
  619|  2.66k|  int ok = 1;
  620|  2.66k|  if (dec->mt_method > 0) {
  ------------------
  |  Branch (620:7): [True: 0, False: 2.66k]
  ------------------
  621|      0|    ok = WebPGetWorkerInterface()->Sync(&dec->worker);
  622|      0|  }
  623|       |
  624|  2.66k|  if (io->teardown != NULL) {
  ------------------
  |  Branch (624:7): [True: 2.66k, False: 0]
  ------------------
  625|  2.66k|    io->teardown(io);
  626|  2.66k|  }
  627|  2.66k|  return ok;
  628|  2.66k|}
VP8GetThreadMethod:
  679|  2.66k|                       int height) {
  680|  2.66k|  if (options == NULL || options->use_threads == 0) {
  ------------------
  |  Branch (680:7): [True: 2.66k, False: 0]
  |  Branch (680:26): [True: 0, False: 0]
  ------------------
  681|  2.66k|    return 0;
  682|  2.66k|  }
  683|      0|  (void)headers;
  684|      0|  (void)width;
  685|      0|  (void)height;
  686|      0|  assert(headers == NULL || !headers->is_lossless);
  687|      0|#if defined(WEBP_USE_THREAD)
  688|      0|  if (width >= MIN_WIDTH_FOR_THREADS) return 2;
  ------------------
  |  |   72|      0|#define MIN_WIDTH_FOR_THREADS 512
  ------------------
  |  Branch (688:7): [True: 0, False: 0]
  ------------------
  689|      0|#endif
  690|      0|  return 0;
  691|      0|}
VP8InitFrame:
  813|  2.66k|int VP8InitFrame(VP8Decoder* const dec, VP8Io* const io) {
  814|  2.66k|  if (!InitThreadContext(dec)) return 0;  // call first. Sets dec->num_caches.
  ------------------
  |  Branch (814:7): [True: 0, False: 2.66k]
  ------------------
  815|  2.66k|  if (!AllocateMemory(dec)) return 0;
  ------------------
  |  Branch (815:7): [True: 0, False: 2.66k]
  ------------------
  816|  2.66k|  InitIo(dec, io);
  817|  2.66k|  VP8DspInit();  // Init critical function pointers and look-up tables.
  818|  2.66k|  return 1;
  819|  2.66k|}
frame_dec.c:ReconstructRow:
   84|  35.0k|                           const VP8ThreadContext* ctx) {
   85|  35.0k|  int j;
   86|  35.0k|  int mb_x;
   87|  35.0k|  const int mb_y = ctx->mb_y;
   88|  35.0k|  const int cache_id = ctx->id;
   89|  35.0k|  uint8_t* const y_dst = dec->yuv_b + Y_OFF;
  ------------------
  |  |   67|  35.0k|#define Y_OFF (BPS * 1 + 8)
  |  |  ------------------
  |  |  |  |   33|  35.0k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
   90|  35.0k|  uint8_t* const u_dst = dec->yuv_b + U_OFF;
  ------------------
  |  |   68|  35.0k|#define U_OFF (Y_OFF + BPS * 16 + BPS)
  |  |  ------------------
  |  |  |  |   67|  35.0k|#define Y_OFF (BPS * 1 + 8)
  |  |  |  |  ------------------
  |  |  |  |  |  |   33|  35.0k|#define BPS 32  // this is the common stride for enc/dec
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define U_OFF (Y_OFF + BPS * 16 + BPS)
  |  |  ------------------
  |  |  |  |   33|  35.0k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  |  |               #define U_OFF (Y_OFF + BPS * 16 + BPS)
  |  |  ------------------
  |  |  |  |   33|  35.0k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
   91|  35.0k|  uint8_t* const v_dst = dec->yuv_b + V_OFF;
  ------------------
  |  |   69|  35.0k|#define V_OFF (U_OFF + 16)
  |  |  ------------------
  |  |  |  |   68|  35.0k|#define U_OFF (Y_OFF + BPS * 16 + BPS)
  |  |  |  |  ------------------
  |  |  |  |  |  |   67|  35.0k|#define Y_OFF (BPS * 1 + 8)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   33|  35.0k|#define BPS 32  // this is the common stride for enc/dec
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define U_OFF (Y_OFF + BPS * 16 + BPS)
  |  |  |  |  ------------------
  |  |  |  |  |  |   33|  35.0k|#define BPS 32  // this is the common stride for enc/dec
  |  |  |  |  ------------------
  |  |  |  |               #define U_OFF (Y_OFF + BPS * 16 + BPS)
  |  |  |  |  ------------------
  |  |  |  |  |  |   33|  35.0k|#define BPS 32  // this is the common stride for enc/dec
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   92|       |
   93|       |  // Initialize left-most block.
   94|   596k|  for (j = 0; j < 16; ++j) {
  ------------------
  |  Branch (94:15): [True: 561k, False: 35.0k]
  ------------------
   95|   561k|    y_dst[j * BPS - 1] = 129;
  ------------------
  |  |   33|   561k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
   96|   561k|  }
   97|   315k|  for (j = 0; j < 8; ++j) {
  ------------------
  |  Branch (97:15): [True: 280k, False: 35.0k]
  ------------------
   98|   280k|    u_dst[j * BPS - 1] = 129;
  ------------------
  |  |   33|   280k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
   99|   280k|    v_dst[j * BPS - 1] = 129;
  ------------------
  |  |   33|   280k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  100|   280k|  }
  101|       |
  102|       |  // Init top-left sample on left column too.
  103|  35.0k|  if (mb_y > 0) {
  ------------------
  |  Branch (103:7): [True: 33.2k, False: 1.89k]
  ------------------
  104|  33.2k|    y_dst[-1 - BPS] = u_dst[-1 - BPS] = v_dst[-1 - BPS] = 129;
  ------------------
  |  |   33|  33.2k|#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|  33.2k|#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|  33.2k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  105|  33.2k|  } else {
  106|       |    // we only need to do this init once at block (0,0).
  107|       |    // Afterward, it remains valid for the whole topmost row.
  108|  1.89k|    WEBP_UNSAFE_MEMSET(y_dst - BPS - 1, 127, 16 + 4 + 1);
  ------------------
  |  |  175|  1.89k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  109|  1.89k|    WEBP_UNSAFE_MEMSET(u_dst - BPS - 1, 127, 8 + 1);
  ------------------
  |  |  175|  1.89k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  110|  1.89k|    WEBP_UNSAFE_MEMSET(v_dst - BPS - 1, 127, 8 + 1);
  ------------------
  |  |  175|  1.89k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  111|  1.89k|  }
  112|       |
  113|       |  // Reconstruct one row.
  114|  85.0k|  for (mb_x = 0; mb_x < dec->mb_w; ++mb_x) {
  ------------------
  |  Branch (114:18): [True: 49.9k, False: 35.0k]
  ------------------
  115|  49.9k|    const VP8MBData* const block = ctx->mb_data + mb_x;
  116|       |
  117|       |    // Rotate in the left samples from previously decoded block. We move four
  118|       |    // pixels at a time for alignment reason, and because of in-loop filter.
  119|  49.9k|    if (mb_x > 0) {
  ------------------
  |  Branch (119:9): [True: 14.8k, False: 35.0k]
  ------------------
  120|   267k|      for (j = -1; j < 16; ++j) {
  ------------------
  |  Branch (120:20): [True: 252k, False: 14.8k]
  ------------------
  121|   252k|        Copy32b(&y_dst[j * BPS - 4], &y_dst[j * BPS + 12]);
  ------------------
  |  |   33|   252k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
                      Copy32b(&y_dst[j * BPS - 4], &y_dst[j * BPS + 12]);
  ------------------
  |  |   33|   252k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  122|   252k|      }
  123|   148k|      for (j = -1; j < 8; ++j) {
  ------------------
  |  Branch (123:20): [True: 133k, False: 14.8k]
  ------------------
  124|   133k|        Copy32b(&u_dst[j * BPS - 4], &u_dst[j * BPS + 4]);
  ------------------
  |  |   33|   133k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
                      Copy32b(&u_dst[j * BPS - 4], &u_dst[j * BPS + 4]);
  ------------------
  |  |   33|   133k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  125|   133k|        Copy32b(&v_dst[j * BPS - 4], &v_dst[j * BPS + 4]);
  ------------------
  |  |   33|   133k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
                      Copy32b(&v_dst[j * BPS - 4], &v_dst[j * BPS + 4]);
  ------------------
  |  |   33|   133k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  126|   133k|      }
  127|  14.8k|    }
  128|  49.9k|    {
  129|       |      // bring top samples into the cache
  130|  49.9k|      VP8TopSamples* const top_yuv = dec->yuv_t + mb_x;
  131|  49.9k|      const int16_t* const coeffs = block->coeffs;
  132|  49.9k|      uint32_t bits = block->non_zero_y;
  133|  49.9k|      int n;
  134|       |
  135|  49.9k|      if (mb_y > 0) {
  ------------------
  |  Branch (135:11): [True: 35.2k, False: 14.7k]
  ------------------
  136|  35.2k|        WEBP_UNSAFE_MEMCPY(y_dst - BPS, top_yuv[0].y, 16);
  ------------------
  |  |  174|  35.2k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
  137|  35.2k|        WEBP_UNSAFE_MEMCPY(u_dst - BPS, top_yuv[0].u, 8);
  ------------------
  |  |  174|  35.2k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
  138|  35.2k|        WEBP_UNSAFE_MEMCPY(v_dst - BPS, top_yuv[0].v, 8);
  ------------------
  |  |  174|  35.2k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
  139|  35.2k|      }
  140|       |
  141|       |      // predict and add residuals
  142|  49.9k|      if (block->is_i4x4) {  // 4x4
  ------------------
  |  Branch (142:11): [True: 17.1k, False: 32.8k]
  ------------------
  143|  17.1k|        uint32_t* const top_right = (uint32_t*)(y_dst - BPS + 16);
  ------------------
  |  |   33|  17.1k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  144|       |
  145|  17.1k|        if (mb_y > 0) {
  ------------------
  |  Branch (145:13): [True: 12.0k, False: 5.06k]
  ------------------
  146|  12.0k|          if (mb_x >= dec->mb_w - 1) {  // on rightmost border
  ------------------
  |  Branch (146:15): [True: 11.4k, False: 601]
  ------------------
  147|  11.4k|            WEBP_UNSAFE_MEMSET(top_right, top_yuv[0].y[15], sizeof(*top_right));
  ------------------
  |  |  175|  11.4k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  148|  11.4k|          } else {
  149|    601|            WEBP_UNSAFE_MEMCPY(top_right, top_yuv[1].y, sizeof(*top_right));
  ------------------
  |  |  174|    601|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
  150|    601|          }
  151|  12.0k|        }
  152|       |        // replicate the top-right pixels below
  153|  17.1k|        top_right[BPS] = top_right[2 * BPS] = top_right[3 * BPS] = top_right[0];
  ------------------
  |  |   33|  17.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|  17.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|  17.1k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  154|       |
  155|       |        // predict and add residuals for all 4x4 blocks in turn.
  156|   290k|        for (n = 0; n < 16; ++n, bits <<= 2) {
  ------------------
  |  Branch (156:21): [True: 273k, False: 17.1k]
  ------------------
  157|   273k|          uint8_t* const dst = y_dst + kScan[n];
  158|   273k|          VP8PredLuma4[block->imodes[n]](dst);
  159|   273k|          DoTransform(bits, coeffs + n * 16, dst);
  160|   273k|        }
  161|  32.8k|      } else {  // 16x16
  162|  32.8k|        const int pred_func = CheckMode(mb_x, mb_y, block->imodes[0]);
  163|  32.8k|        VP8PredLuma16[pred_func](y_dst);
  164|  32.8k|        if (bits != 0) {
  ------------------
  |  Branch (164:13): [True: 8.12k, False: 24.6k]
  ------------------
  165|   138k|          for (n = 0; n < 16; ++n, bits <<= 2) {
  ------------------
  |  Branch (165:23): [True: 129k, False: 8.12k]
  ------------------
  166|   129k|            DoTransform(bits, coeffs + n * 16, y_dst + kScan[n]);
  167|   129k|          }
  168|  8.12k|        }
  169|  32.8k|      }
  170|  49.9k|      {
  171|       |        // Chroma
  172|  49.9k|        const uint32_t bits_uv = block->non_zero_uv;
  173|  49.9k|        const int pred_func = CheckMode(mb_x, mb_y, block->uvmode);
  174|  49.9k|        VP8PredChroma8[pred_func](u_dst);
  175|  49.9k|        VP8PredChroma8[pred_func](v_dst);
  176|  49.9k|        DoUVTransform(bits_uv >> 0, coeffs + 16 * 16, u_dst);
  177|  49.9k|        DoUVTransform(bits_uv >> 8, coeffs + 20 * 16, v_dst);
  178|  49.9k|      }
  179|       |
  180|       |      // stash away top samples for next block
  181|  49.9k|      if (mb_y < dec->mb_h - 1) {
  ------------------
  |  Branch (181:11): [True: 38.4k, False: 11.5k]
  ------------------
  182|  38.4k|        WEBP_UNSAFE_MEMCPY(top_yuv[0].y, y_dst + 15 * BPS, 16);
  ------------------
  |  |  174|  38.4k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
  183|  38.4k|        WEBP_UNSAFE_MEMCPY(top_yuv[0].u, u_dst + 7 * BPS, 8);
  ------------------
  |  |  174|  38.4k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
  184|  38.4k|        WEBP_UNSAFE_MEMCPY(top_yuv[0].v, v_dst + 7 * BPS, 8);
  ------------------
  |  |  174|  38.4k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
  185|  38.4k|      }
  186|  49.9k|    }
  187|       |    // Transfer reconstructed samples from yuv_b cache to final destination.
  188|  49.9k|    {
  189|  49.9k|      const int y_offset = cache_id * 16 * dec->cache_y_stride;
  190|  49.9k|      const int uv_offset = cache_id * 8 * dec->cache_uv_stride;
  191|  49.9k|      uint8_t* const y_out = dec->cache_y + mb_x * 16 + y_offset;
  192|  49.9k|      uint8_t* const u_out = dec->cache_u + mb_x * 8 + uv_offset;
  193|  49.9k|      uint8_t* const v_out = dec->cache_v + mb_x * 8 + uv_offset;
  194|   848k|      for (j = 0; j < 16; ++j) {
  ------------------
  |  Branch (194:19): [True: 798k, False: 49.9k]
  ------------------
  195|   798k|        WEBP_UNSAFE_MEMCPY(y_out + j * dec->cache_y_stride, y_dst + j * BPS,
  ------------------
  |  |  174|   798k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
  196|   798k|                           16);
  197|   798k|      }
  198|   449k|      for (j = 0; j < 8; ++j) {
  ------------------
  |  Branch (198:19): [True: 399k, False: 49.9k]
  ------------------
  199|   399k|        WEBP_UNSAFE_MEMCPY(u_out + j * dec->cache_uv_stride, u_dst + j * BPS,
  ------------------
  |  |  174|   399k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
  200|   399k|                           8);
  201|   399k|        WEBP_UNSAFE_MEMCPY(v_out + j * dec->cache_uv_stride, v_dst + j * BPS,
  ------------------
  |  |  174|   399k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
  202|   399k|                           8);
  203|   399k|      }
  204|  49.9k|    }
  205|  49.9k|  }
  206|  35.0k|}
frame_dec.c:Copy32b:
   51|   519k|static void Copy32b(uint8_t* const dst, const uint8_t* const src) {
   52|   519k|  WEBP_UNSAFE_MEMCPY(dst, src, 4);
  ------------------
  |  |  174|   519k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
   53|   519k|}
frame_dec.c:DoTransform:
   56|   403k|                                    uint8_t* const dst) {
   57|   403k|  switch (bits >> 30) {
   58|  16.3k|    case 3:
  ------------------
  |  Branch (58:5): [True: 16.3k, False: 387k]
  ------------------
   59|  16.3k|      VP8Transform(src, dst, 0);
   60|  16.3k|      break;
   61|  18.5k|    case 2:
  ------------------
  |  Branch (61:5): [True: 18.5k, False: 385k]
  ------------------
   62|  18.5k|      VP8TransformAC3(src, dst);
   63|  18.5k|      break;
   64|  93.6k|    case 1:
  ------------------
  |  Branch (64:5): [True: 93.6k, False: 310k]
  ------------------
   65|  93.6k|      VP8TransformDC(src, dst);
   66|  93.6k|      break;
   67|   275k|    default:
  ------------------
  |  Branch (67:5): [True: 275k, False: 128k]
  ------------------
   68|   275k|      break;
   69|   403k|  }
   70|   403k|}
frame_dec.c:CheckMode:
   40|  82.7k|static int CheckMode(int mb_x, int mb_y, int mode) {
   41|  82.7k|  if (mode == B_DC_PRED) {
  ------------------
  |  Branch (41:7): [True: 40.8k, False: 41.8k]
  ------------------
   42|  40.8k|    if (mb_x == 0) {
  ------------------
  |  Branch (42:9): [True: 26.5k, False: 14.3k]
  ------------------
   43|  26.5k|      return (mb_y == 0) ? B_DC_PRED_NOTOPLEFT : B_DC_PRED_NOLEFT;
  ------------------
  |  Branch (43:14): [True: 1.60k, False: 24.9k]
  ------------------
   44|  26.5k|    } else {
   45|  14.3k|      return (mb_y == 0) ? B_DC_PRED_NOTOP : B_DC_PRED;
  ------------------
  |  Branch (45:14): [True: 12.7k, False: 1.61k]
  ------------------
   46|  14.3k|    }
   47|  40.8k|  }
   48|  41.8k|  return mode;
   49|  82.7k|}
frame_dec.c:DoUVTransform:
   73|  99.8k|                          uint8_t* const dst) {
   74|  99.8k|  if (bits & 0xff) {             // any non-zero coeff at all?
  ------------------
  |  Branch (74:7): [True: 25.7k, False: 74.0k]
  ------------------
   75|  25.7k|    if (bits & 0xaa) {           // any non-zero AC coefficient?
  ------------------
  |  Branch (75:9): [True: 13.6k, False: 12.1k]
  ------------------
   76|  13.6k|      VP8TransformUV(src, dst);  // note we don't use the AC3 variant for U/V
   77|  13.6k|    } else {
   78|  12.1k|      VP8TransformDCUV(src, dst);
   79|  12.1k|    }
   80|  25.7k|  }
   81|  99.8k|}
frame_dec.c:FinishRow:
  416|  35.0k|static int FinishRow(void* arg1, void* arg2) {
  417|  35.0k|  VP8Decoder* const dec = (VP8Decoder*)arg1;
  418|  35.0k|  VP8Io* const io = (VP8Io*)arg2;
  419|  35.0k|  int ok = 1;
  420|  35.0k|  const VP8ThreadContext* const ctx = &dec->thread_ctx;
  421|  35.0k|  const int cache_id = ctx->id;
  422|  35.0k|  const int extra_y_rows = kFilterExtraRows[dec->filter_type];
  423|  35.0k|  const int ysize = extra_y_rows * dec->cache_y_stride;
  424|  35.0k|  const int uvsize = (extra_y_rows / 2) * dec->cache_uv_stride;
  425|  35.0k|  const int y_offset = cache_id * 16 * dec->cache_y_stride;
  426|  35.0k|  const int uv_offset = cache_id * 8 * dec->cache_uv_stride;
  427|  35.0k|  uint8_t* const ydst = dec->cache_y - ysize + y_offset;
  428|  35.0k|  uint8_t* const udst = dec->cache_u - uvsize + uv_offset;
  429|  35.0k|  uint8_t* const vdst = dec->cache_v - uvsize + uv_offset;
  430|  35.0k|  const int mb_y = ctx->mb_y;
  431|  35.0k|  const int is_first_row = (mb_y == 0);
  432|  35.0k|  const int is_last_row = (mb_y >= dec->br_mb_y - 1);
  433|       |
  434|  35.0k|  if (dec->mt_method == 2) {
  ------------------
  |  Branch (434:7): [True: 0, False: 35.0k]
  ------------------
  435|      0|    ReconstructRow(dec, ctx);
  436|      0|  }
  437|       |
  438|  35.0k|  if (ctx->filter_row) {
  ------------------
  |  Branch (438:7): [True: 32.3k, False: 2.78k]
  ------------------
  439|  32.3k|    FilterRow(dec);
  440|  32.3k|  }
  441|       |
  442|  35.0k|  if (dec->dither) {
  ------------------
  |  Branch (442:7): [True: 0, False: 35.0k]
  ------------------
  443|      0|    DitherRow(dec);
  444|      0|  }
  445|       |
  446|  35.0k|  if (io->put != NULL) {
  ------------------
  |  Branch (446:7): [True: 35.0k, False: 0]
  ------------------
  447|  35.0k|    int y_start = MACROBLOCK_VPOS(mb_y);
  ------------------
  |  |  413|  35.0k|#define MACROBLOCK_VPOS(mb_y) ((mb_y) * 16)  // vertical position of a MB
  ------------------
  448|  35.0k|    int y_end = MACROBLOCK_VPOS(mb_y + 1);
  ------------------
  |  |  413|  35.0k|#define MACROBLOCK_VPOS(mb_y) ((mb_y) * 16)  // vertical position of a MB
  ------------------
  449|  35.0k|    if (!is_first_row) {
  ------------------
  |  Branch (449:9): [True: 33.2k, False: 1.89k]
  ------------------
  450|  33.2k|      y_start -= extra_y_rows;
  451|  33.2k|      io->y = ydst;
  452|  33.2k|      io->u = udst;
  453|  33.2k|      io->v = vdst;
  454|  33.2k|    } else {
  455|  1.89k|      io->y = dec->cache_y + y_offset;
  456|  1.89k|      io->u = dec->cache_u + uv_offset;
  457|  1.89k|      io->v = dec->cache_v + uv_offset;
  458|  1.89k|    }
  459|       |
  460|  35.0k|    if (!is_last_row) {
  ------------------
  |  Branch (460:9): [True: 34.7k, False: 365]
  ------------------
  461|  34.7k|      y_end -= extra_y_rows;
  462|  34.7k|    }
  463|  35.0k|    if (y_end > io->crop_bottom) {
  ------------------
  |  Branch (463:9): [True: 333, False: 34.7k]
  ------------------
  464|    333|      y_end = io->crop_bottom;  // make sure we don't overflow on last row.
  465|    333|    }
  466|       |    // If dec->alpha_data is not NULL, we have some alpha plane present.
  467|  35.0k|    io->a = NULL;
  468|  35.0k|    if (dec->alpha_data != NULL && y_start < y_end) {
  ------------------
  |  Branch (468:9): [True: 0, False: 35.0k]
  |  Branch (468:36): [True: 0, False: 0]
  ------------------
  469|      0|      io->a = VP8DecompressAlphaRows(dec, io, y_start, y_end - y_start);
  470|      0|      if (io->a == NULL) {
  ------------------
  |  Branch (470:11): [True: 0, False: 0]
  ------------------
  471|      0|        return VP8SetError(dec, VP8_STATUS_BITSTREAM_ERROR,
  472|      0|                           "Could not decode alpha data.");
  473|      0|      }
  474|      0|    }
  475|  35.0k|    if (y_start < io->crop_top) {
  ------------------
  |  Branch (475:9): [True: 0, False: 35.0k]
  ------------------
  476|      0|      const int delta_y = io->crop_top - y_start;
  477|      0|      y_start = io->crop_top;
  478|      0|      assert(!(delta_y & 1));
  479|      0|      io->y += dec->cache_y_stride * delta_y;
  480|      0|      io->u += dec->cache_uv_stride * (delta_y >> 1);
  481|      0|      io->v += dec->cache_uv_stride * (delta_y >> 1);
  482|      0|      if (io->a != NULL) {
  ------------------
  |  Branch (482:11): [True: 0, False: 0]
  ------------------
  483|      0|        io->a += io->width * delta_y;
  484|      0|      }
  485|      0|    }
  486|  35.0k|    if (y_start < y_end) {
  ------------------
  |  Branch (486:9): [True: 35.0k, False: 0]
  ------------------
  487|  35.0k|      io->y += io->crop_left;
  488|  35.0k|      io->u += io->crop_left >> 1;
  489|  35.0k|      io->v += io->crop_left >> 1;
  490|  35.0k|      if (io->a != NULL) {
  ------------------
  |  Branch (490:11): [True: 0, False: 35.0k]
  ------------------
  491|      0|        io->a += io->crop_left;
  492|      0|      }
  493|  35.0k|      io->mb_y = y_start - io->crop_top;
  494|  35.0k|      io->mb_w = io->crop_right - io->crop_left;
  495|  35.0k|      io->mb_h = y_end - y_start;
  496|  35.0k|      ok = io->put(io);
  497|  35.0k|    }
  498|  35.0k|  }
  499|       |  // rotate top samples if needed
  500|  35.0k|  if (cache_id + 1 == dec->num_caches) {
  ------------------
  |  Branch (500:7): [True: 35.0k, False: 0]
  ------------------
  501|  35.0k|    if (!is_last_row) {
  ------------------
  |  Branch (501:9): [True: 34.7k, False: 365]
  ------------------
  502|  34.7k|      WEBP_UNSAFE_MEMCPY(dec->cache_y - ysize, ydst + 16 * dec->cache_y_stride,
  ------------------
  |  |  174|  34.7k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
  503|  34.7k|                         ysize);
  504|  34.7k|      WEBP_UNSAFE_MEMCPY(dec->cache_u - uvsize, udst + 8 * dec->cache_uv_stride,
  ------------------
  |  |  174|  34.7k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
  505|  34.7k|                         uvsize);
  506|  34.7k|      WEBP_UNSAFE_MEMCPY(dec->cache_v - uvsize, vdst + 8 * dec->cache_uv_stride,
  ------------------
  |  |  174|  34.7k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
  507|  34.7k|                         uvsize);
  508|  34.7k|    }
  509|  35.0k|  }
  510|       |
  511|  35.0k|  return ok;
  512|  35.0k|}
frame_dec.c:FilterRow:
  268|  32.3k|static void FilterRow(const VP8Decoder* const dec) {
  269|  32.3k|  int mb_x;
  270|  32.3k|  const int mb_y = dec->thread_ctx.mb_y;
  271|  32.3k|  assert(dec->thread_ctx.filter_row);
  272|  79.1k|  for (mb_x = dec->tl_mb_x; mb_x < dec->br_mb_x; ++mb_x) {
  ------------------
  |  Branch (272:29): [True: 46.8k, False: 32.3k]
  ------------------
  273|  46.8k|    DoFilter(dec, mb_x, mb_y);
  274|  46.8k|  }
  275|  32.3k|}
frame_dec.c:DoFilter:
  218|  46.8k|static void DoFilter(const VP8Decoder* const dec, int mb_x, int mb_y) {
  219|  46.8k|  const VP8ThreadContext* const ctx = &dec->thread_ctx;
  220|  46.8k|  const int cache_id = ctx->id;
  221|  46.8k|  const int y_bps = dec->cache_y_stride;
  222|  46.8k|  const VP8FInfo* const f_info = ctx->f_info + mb_x;
  223|  46.8k|  uint8_t* const y_dst = dec->cache_y + cache_id * 16 * y_bps + mb_x * 16;
  224|  46.8k|  const int ilevel = f_info->f_ilevel;
  225|  46.8k|  const int limit = f_info->f_limit;
  226|  46.8k|  if (limit == 0) {
  ------------------
  |  Branch (226:7): [True: 8.61k, False: 38.2k]
  ------------------
  227|  8.61k|    return;
  228|  8.61k|  }
  229|  46.8k|  assert(limit >= 3);
  230|  38.2k|  if (dec->filter_type == 1) {  // simple
  ------------------
  |  Branch (230:7): [True: 12.8k, False: 25.3k]
  ------------------
  231|  12.8k|    if (mb_x > 0) {
  ------------------
  |  Branch (231:9): [True: 4.39k, False: 8.45k]
  ------------------
  232|  4.39k|      VP8SimpleHFilter16(y_dst, y_bps, limit + 4);
  233|  4.39k|    }
  234|  12.8k|    if (f_info->f_inner) {
  ------------------
  |  Branch (234:9): [True: 8.07k, False: 4.77k]
  ------------------
  235|  8.07k|      VP8SimpleHFilter16i(y_dst, y_bps, limit);
  236|  8.07k|    }
  237|  12.8k|    if (mb_y > 0) {
  ------------------
  |  Branch (237:9): [True: 8.15k, False: 4.69k]
  ------------------
  238|  8.15k|      VP8SimpleVFilter16(y_dst, y_bps, limit + 4);
  239|  8.15k|    }
  240|  12.8k|    if (f_info->f_inner) {
  ------------------
  |  Branch (240:9): [True: 8.07k, False: 4.77k]
  ------------------
  241|  8.07k|      VP8SimpleVFilter16i(y_dst, y_bps, limit);
  242|  8.07k|    }
  243|  25.3k|  } else {  // complex
  244|  25.3k|    const int uv_bps = dec->cache_uv_stride;
  245|  25.3k|    uint8_t* const u_dst = dec->cache_u + cache_id * 8 * uv_bps + mb_x * 8;
  246|  25.3k|    uint8_t* const v_dst = dec->cache_v + cache_id * 8 * uv_bps + mb_x * 8;
  247|  25.3k|    const int hev_thresh = f_info->hev_thresh;
  248|  25.3k|    if (mb_x > 0) {
  ------------------
  |  Branch (248:9): [True: 6.71k, False: 18.6k]
  ------------------
  249|  6.71k|      VP8HFilter16(y_dst, y_bps, limit + 4, ilevel, hev_thresh);
  250|  6.71k|      VP8HFilter8(u_dst, v_dst, uv_bps, limit + 4, ilevel, hev_thresh);
  251|  6.71k|    }
  252|  25.3k|    if (f_info->f_inner) {
  ------------------
  |  Branch (252:9): [True: 16.7k, False: 8.63k]
  ------------------
  253|  16.7k|      VP8HFilter16i(y_dst, y_bps, limit, ilevel, hev_thresh);
  254|  16.7k|      VP8HFilter8i(u_dst, v_dst, uv_bps, limit, ilevel, hev_thresh);
  255|  16.7k|    }
  256|  25.3k|    if (mb_y > 0) {
  ------------------
  |  Branch (256:9): [True: 18.6k, False: 6.69k]
  ------------------
  257|  18.6k|      VP8VFilter16(y_dst, y_bps, limit + 4, ilevel, hev_thresh);
  258|  18.6k|      VP8VFilter8(u_dst, v_dst, uv_bps, limit + 4, ilevel, hev_thresh);
  259|  18.6k|    }
  260|  25.3k|    if (f_info->f_inner) {
  ------------------
  |  Branch (260:9): [True: 16.7k, False: 8.63k]
  ------------------
  261|  16.7k|      VP8VFilter16i(y_dst, y_bps, limit, ilevel, hev_thresh);
  262|  16.7k|      VP8VFilter8i(u_dst, v_dst, uv_bps, limit, ilevel, hev_thresh);
  263|  16.7k|    }
  264|  25.3k|  }
  265|  38.2k|}
frame_dec.c:PrecomputeFilterStrengths:
  280|  2.66k|static void PrecomputeFilterStrengths(VP8Decoder* const dec) {
  281|  2.66k|  if (dec->filter_type > 0) {
  ------------------
  |  Branch (281:7): [True: 2.51k, False: 159]
  ------------------
  282|  2.51k|    int s;
  283|  2.51k|    const VP8FilterHeader* const hdr = &dec->filter_hdr;
  284|  12.5k|    for (s = 0; s < NUM_MB_SEGMENTS; ++s) {
  ------------------
  |  Branch (284:17): [True: 10.0k, False: 2.51k]
  ------------------
  285|  10.0k|      int i4x4;
  286|       |      // First, compute the initial level
  287|  10.0k|      int base_level;
  288|  10.0k|      if (dec->segment_hdr.use_segment) {
  ------------------
  |  Branch (288:11): [True: 1.44k, False: 8.59k]
  ------------------
  289|  1.44k|        base_level = dec->segment_hdr.filter_strength[s];
  290|  1.44k|        if (!dec->segment_hdr.absolute_delta) {
  ------------------
  |  Branch (290:13): [True: 404, False: 1.04k]
  ------------------
  291|    404|          base_level += hdr->level;
  292|    404|        }
  293|  8.59k|      } else {
  294|  8.59k|        base_level = hdr->level;
  295|  8.59k|      }
  296|  30.1k|      for (i4x4 = 0; i4x4 <= 1; ++i4x4) {
  ------------------
  |  Branch (296:22): [True: 20.0k, False: 10.0k]
  ------------------
  297|  20.0k|        VP8FInfo* const info = &dec->fstrengths[s][i4x4];
  298|  20.0k|        int level = base_level;
  299|  20.0k|        if (hdr->use_lf_delta) {
  ------------------
  |  Branch (299:13): [True: 2.58k, False: 17.4k]
  ------------------
  300|  2.58k|          level += hdr->ref_lf_delta[0];
  301|  2.58k|          if (i4x4) {
  ------------------
  |  Branch (301:15): [True: 1.29k, False: 1.29k]
  ------------------
  302|  1.29k|            level += hdr->mode_lf_delta[0];
  303|  1.29k|          }
  304|  2.58k|        }
  305|  20.0k|        level = (level < 0) ? 0 : (level > 63) ? 63 : level;
  ------------------
  |  Branch (305:17): [True: 695, False: 19.3k]
  |  Branch (305:35): [True: 109, False: 19.2k]
  ------------------
  306|  20.0k|        if (level > 0) {
  ------------------
  |  Branch (306:13): [True: 17.9k, False: 2.14k]
  ------------------
  307|  17.9k|          int ilevel = level;
  308|  17.9k|          if (hdr->sharpness > 0) {
  ------------------
  |  Branch (308:15): [True: 12.7k, False: 5.16k]
  ------------------
  309|  12.7k|            if (hdr->sharpness > 4) {
  ------------------
  |  Branch (309:17): [True: 3.82k, False: 8.94k]
  ------------------
  310|  3.82k|              ilevel >>= 2;
  311|  8.94k|            } else {
  312|  8.94k|              ilevel >>= 1;
  313|  8.94k|            }
  314|  12.7k|            if (ilevel > 9 - hdr->sharpness) {
  ------------------
  |  Branch (314:17): [True: 9.94k, False: 2.82k]
  ------------------
  315|  9.94k|              ilevel = 9 - hdr->sharpness;
  316|  9.94k|            }
  317|  12.7k|          }
  318|  17.9k|          if (ilevel < 1) ilevel = 1;
  ------------------
  |  Branch (318:15): [True: 554, False: 17.3k]
  ------------------
  319|  17.9k|          info->f_ilevel = ilevel;
  320|  17.9k|          info->f_limit = 2 * level + ilevel;
  321|  17.9k|          info->hev_thresh = (level >= 40) ? 2 : (level >= 15) ? 1 : 0;
  ------------------
  |  Branch (321:30): [True: 5.41k, False: 12.5k]
  |  Branch (321:50): [True: 7.50k, False: 5.01k]
  ------------------
  322|  17.9k|        } else {
  323|  2.14k|          info->f_limit = 0;  // no filtering
  324|  2.14k|        }
  325|  20.0k|        info->f_inner = i4x4;
  326|  20.0k|      }
  327|  10.0k|    }
  328|  2.51k|  }
  329|  2.66k|}
frame_dec.c:InitThreadContext:
  658|  2.66k|static int InitThreadContext(VP8Decoder* const dec) {
  659|  2.66k|  dec->cache_id = 0;
  660|  2.66k|  if (dec->mt_method > 0) {
  ------------------
  |  Branch (660:7): [True: 0, False: 2.66k]
  ------------------
  661|      0|    WebPWorker* const worker = &dec->worker;
  662|      0|    if (!WebPGetWorkerInterface()->Reset(worker)) {
  ------------------
  |  Branch (662:9): [True: 0, False: 0]
  ------------------
  663|      0|      return VP8SetError(dec, VP8_STATUS_OUT_OF_MEMORY,
  664|      0|                         "thread initialization failed.");
  665|      0|    }
  666|      0|    worker->data1 = dec;
  667|      0|    worker->data2 = (void*)&dec->thread_ctx.io;
  668|      0|    worker->hook = FinishRow;
  669|      0|    dec->num_caches =
  670|      0|        (dec->filter_type > 0) ? MT_CACHE_LINES : MT_CACHE_LINES - 1;
  ------------------
  |  |  654|      0|#define MT_CACHE_LINES 3
  ------------------
                      (dec->filter_type > 0) ? MT_CACHE_LINES : MT_CACHE_LINES - 1;
  ------------------
  |  |  654|      0|#define MT_CACHE_LINES 3
  ------------------
  |  Branch (670:9): [True: 0, False: 0]
  ------------------
  671|  2.66k|  } else {
  672|  2.66k|    dec->num_caches = ST_CACHE_LINES;
  ------------------
  |  |  655|  2.66k|#define ST_CACHE_LINES 1  // 1 cache row only for single-threaded case
  ------------------
  673|  2.66k|  }
  674|  2.66k|  return 1;
  675|  2.66k|}
frame_dec.c:AllocateMemory:
  699|  2.66k|static int AllocateMemory(VP8Decoder* const dec) {
  700|  2.66k|  const int num_caches = dec->num_caches;
  701|  2.66k|  const int mb_w = dec->mb_w;
  702|       |  // Note: we use 'size_t' when there's no overflow risk, uint64_t otherwise.
  703|  2.66k|  const size_t intra_pred_mode_size = 4 * mb_w * sizeof(uint8_t);
  704|  2.66k|  const size_t top_size = sizeof(VP8TopSamples) * mb_w;
  705|  2.66k|  const size_t mb_info_size = (mb_w + 1) * sizeof(VP8MB);
  706|  2.66k|  const size_t f_info_size =
  707|  2.66k|      (dec->filter_type > 0)
  ------------------
  |  Branch (707:7): [True: 2.51k, False: 159]
  ------------------
  708|  2.66k|          ? mb_w * (dec->mt_method > 0 ? 2 : 1) * sizeof(VP8FInfo)
  ------------------
  |  Branch (708:21): [True: 0, False: 2.51k]
  ------------------
  709|  2.66k|          : 0;
  710|  2.66k|  const size_t yuv_size = YUV_SIZE * sizeof(*dec->yuv_b);
  ------------------
  |  |   66|  2.66k|#define YUV_SIZE (BPS * 17 + BPS * 9)
  |  |  ------------------
  |  |  |  |   33|  2.66k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  |  |               #define YUV_SIZE (BPS * 17 + BPS * 9)
  |  |  ------------------
  |  |  |  |   33|  2.66k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
  711|  2.66k|  const size_t mb_data_size =
  712|  2.66k|      (dec->mt_method == 2 ? 2 : 1) * mb_w * sizeof(*dec->mb_data);
  ------------------
  |  Branch (712:8): [True: 0, False: 2.66k]
  ------------------
  713|  2.66k|  const size_t cache_height =
  714|  2.66k|      (16 * num_caches + kFilterExtraRows[dec->filter_type]) * 3 / 2;
  715|  2.66k|  const size_t cache_size = top_size * cache_height;
  716|       |  // alpha_size is the only one that scales as width x height.
  717|  2.66k|  const uint64_t alpha_size =
  718|  2.66k|      (dec->alpha_data != NULL)
  ------------------
  |  Branch (718:7): [True: 0, False: 2.66k]
  ------------------
  719|  2.66k|          ? (uint64_t)dec->pic_hdr.width * dec->pic_hdr.height
  720|  2.66k|          : 0ULL;
  721|  2.66k|  const uint64_t needed = (uint64_t)intra_pred_mode_size + top_size +
  722|  2.66k|                          mb_info_size + f_info_size + yuv_size + mb_data_size +
  723|  2.66k|                          cache_size + alpha_size + WEBP_ALIGN_CST;
  ------------------
  |  |   70|  2.66k|#define WEBP_ALIGN_CST 31
  ------------------
  724|  2.66k|  uint8_t* mem;
  725|       |
  726|  2.66k|  if (!CheckSizeOverflow(needed)) return 0;  // check for overflow
  ------------------
  |  Branch (726:7): [True: 0, False: 2.66k]
  ------------------
  727|  2.66k|  if (needed > dec->mem_size) {
  ------------------
  |  Branch (727:7): [True: 2.66k, False: 0]
  ------------------
  728|  2.66k|    WebPSafeFree(dec->mem);
  729|  2.66k|    dec->mem_size = 0;
  730|  2.66k|    dec->mem = WebPSafeMalloc(needed, sizeof(uint8_t));
  731|  2.66k|    if (dec->mem == NULL) {
  ------------------
  |  Branch (731:9): [True: 0, False: 2.66k]
  ------------------
  732|      0|      return VP8SetError(dec, VP8_STATUS_OUT_OF_MEMORY,
  733|      0|                         "no memory during frame initialization.");
  734|      0|    }
  735|       |    // down-cast is ok, thanks to WebPSafeMalloc() above.
  736|  2.66k|    dec->mem_size = (size_t)needed;
  737|  2.66k|  }
  738|       |
  739|  2.66k|  mem = (uint8_t*)dec->mem;
  740|  2.66k|  dec->intra_t = mem;
  741|  2.66k|  mem += intra_pred_mode_size;
  742|       |
  743|  2.66k|  dec->yuv_t = (VP8TopSamples*)mem;
  744|  2.66k|  mem += top_size;
  745|       |
  746|  2.66k|  dec->mb_info = ((VP8MB*)mem) + 1;
  747|  2.66k|  mem += mb_info_size;
  748|       |
  749|  2.66k|  dec->f_info = f_info_size ? (VP8FInfo*)mem : NULL;
  ------------------
  |  Branch (749:17): [True: 2.51k, False: 159]
  ------------------
  750|  2.66k|  mem += f_info_size;
  751|  2.66k|  dec->thread_ctx.id = 0;
  752|  2.66k|  dec->thread_ctx.f_info = dec->f_info;
  753|  2.66k|  if (dec->filter_type > 0 && dec->mt_method > 0) {
  ------------------
  |  Branch (753:7): [True: 2.51k, False: 159]
  |  Branch (753:31): [True: 0, False: 2.51k]
  ------------------
  754|       |    // secondary cache line. The deblocking process need to make use of the
  755|       |    // filtering strength from previous macroblock row, while the new ones
  756|       |    // are being decoded in parallel. We'll just swap the pointers.
  757|      0|    dec->thread_ctx.f_info += mb_w;
  758|      0|  }
  759|       |
  760|  2.66k|  mem = (uint8_t*)WEBP_ALIGN(mem);
  ------------------
  |  |   72|  2.66k|  (((uintptr_t)(PTR) + WEBP_ALIGN_CST) & ~(uintptr_t)WEBP_ALIGN_CST)
  |  |  ------------------
  |  |  |  |   70|  2.66k|#define WEBP_ALIGN_CST 31
  |  |  ------------------
  |  |                 (((uintptr_t)(PTR) + WEBP_ALIGN_CST) & ~(uintptr_t)WEBP_ALIGN_CST)
  |  |  ------------------
  |  |  |  |   70|  2.66k|#define WEBP_ALIGN_CST 31
  |  |  ------------------
  ------------------
  761|  2.66k|  assert((yuv_size & WEBP_ALIGN_CST) == 0);
  762|  2.66k|  dec->yuv_b = mem;
  763|  2.66k|  mem += yuv_size;
  764|       |
  765|  2.66k|  dec->mb_data = (VP8MBData*)mem;
  766|  2.66k|  dec->thread_ctx.mb_data = (VP8MBData*)mem;
  767|  2.66k|  if (dec->mt_method == 2) {
  ------------------
  |  Branch (767:7): [True: 0, False: 2.66k]
  ------------------
  768|      0|    dec->thread_ctx.mb_data += mb_w;
  769|      0|  }
  770|  2.66k|  mem += mb_data_size;
  771|       |
  772|  2.66k|  dec->cache_y_stride = 16 * mb_w;
  773|  2.66k|  dec->cache_uv_stride = 8 * mb_w;
  774|  2.66k|  {
  775|  2.66k|    const int extra_rows = kFilterExtraRows[dec->filter_type];
  776|  2.66k|    const int extra_y = extra_rows * dec->cache_y_stride;
  777|  2.66k|    const int extra_uv = (extra_rows / 2) * dec->cache_uv_stride;
  778|  2.66k|    dec->cache_y = mem + extra_y;
  779|  2.66k|    dec->cache_u =
  780|  2.66k|        dec->cache_y + 16 * num_caches * dec->cache_y_stride + extra_uv;
  781|  2.66k|    dec->cache_v =
  782|  2.66k|        dec->cache_u + 8 * num_caches * dec->cache_uv_stride + extra_uv;
  783|  2.66k|    dec->cache_id = 0;
  784|  2.66k|  }
  785|  2.66k|  mem += cache_size;
  786|       |
  787|       |  // alpha plane
  788|  2.66k|  dec->alpha_plane = alpha_size ? mem : NULL;
  ------------------
  |  Branch (788:22): [True: 0, False: 2.66k]
  ------------------
  789|  2.66k|  mem += alpha_size;
  790|  2.66k|  assert(mem <= (uint8_t*)dec->mem + dec->mem_size);
  791|       |
  792|       |  // note: left/top-info is initialized once for all.
  793|  2.66k|  WEBP_UNSAFE_MEMSET(dec->mb_info - 1, 0, mb_info_size);
  ------------------
  |  |  175|  2.66k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  794|  2.66k|  VP8InitScanline(dec);  // initialize left too.
  795|       |
  796|       |  // initialize top
  797|  2.66k|  WEBP_UNSAFE_MEMSET(dec->intra_t, B_DC_PRED, intra_pred_mode_size);
  ------------------
  |  |  175|  2.66k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  798|       |
  799|  2.66k|  return 1;
  800|  2.66k|}
frame_dec.c:InitIo:
  802|  2.66k|static void InitIo(VP8Decoder* const dec, VP8Io* io) {
  803|       |  // prepare 'io'
  804|  2.66k|  io->mb_y = 0;
  805|  2.66k|  io->y = dec->cache_y;
  806|  2.66k|  io->u = dec->cache_u;
  807|  2.66k|  io->v = dec->cache_v;
  808|  2.66k|  io->y_stride = dec->cache_y_stride;
  809|  2.66k|  io->uv_stride = dec->cache_uv_stride;
  810|       |  io->a = NULL;
  811|  2.66k|}

WebPInitCustomIo:
  662|  5.14k|void WebPInitCustomIo(WebPDecParams* const params, VP8Io* const io) {
  663|  5.14k|  io->put = CustomPut;
  664|  5.14k|  io->setup = CustomSetup;
  665|  5.14k|  io->teardown = CustomTeardown;
  666|  5.14k|  io->opaque = params;
  667|  5.14k|}
io_dec.c:CustomPut:
  633|  35.0k|static int CustomPut(const VP8Io* io) {
  634|  35.0k|  WebPDecParams* const p = (WebPDecParams*)io->opaque;
  635|  35.0k|  const int mb_w = io->mb_w;
  636|  35.0k|  const int mb_h = io->mb_h;
  637|  35.0k|  int num_lines_out;
  638|  35.0k|  assert(!(io->mb_y & 1));
  639|       |
  640|  35.0k|  if (mb_w <= 0 || mb_h <= 0) {
  ------------------
  |  Branch (640:7): [True: 0, False: 35.0k]
  |  Branch (640:20): [True: 0, False: 35.0k]
  ------------------
  641|      0|    return 0;
  642|      0|  }
  643|  35.0k|  num_lines_out = p->emit(io, p);
  644|  35.0k|  if (p->emit_alpha != NULL) {
  ------------------
  |  Branch (644:7): [True: 17.6k, False: 17.4k]
  ------------------
  645|  17.6k|    p->emit_alpha(io, p, num_lines_out);
  646|  17.6k|  }
  647|  35.0k|  p->last_y += num_lines_out;
  648|  35.0k|  return 1;
  649|  35.0k|}
io_dec.c:CustomSetup:
  568|  2.66k|static int CustomSetup(VP8Io* io) {
  569|  2.66k|  WebPDecParams* const p = (WebPDecParams*)io->opaque;
  570|  2.66k|  const WEBP_CSP_MODE colorspace = p->output->colorspace;
  571|  2.66k|  const int is_rgb = WebPIsRGBMode(colorspace);
  572|  2.66k|  const int is_alpha = WebPIsAlphaMode(colorspace);
  573|       |
  574|  2.66k|  p->memory = NULL;
  575|  2.66k|  p->emit = NULL;
  576|  2.66k|  p->emit_alpha = NULL;
  577|  2.66k|  p->emit_alpha_row = NULL;
  578|       |  // Note: WebPIoInitFromOptions() does not distinguish between MODE_YUV and
  579|       |  // MODE_YUVA, only RGB vs YUV.
  580|  2.66k|  if (!WebPIoInitFromOptions(p->options, io, /*src_colorspace=*/MODE_YUV)) {
  ------------------
  |  Branch (580:7): [True: 0, False: 2.66k]
  ------------------
  581|      0|    return 0;
  582|      0|  }
  583|  2.66k|  if (is_alpha && WebPIsPremultipliedMode(colorspace)) {
  ------------------
  |  Branch (583:7): [True: 1.30k, False: 1.36k]
  |  Branch (583:19): [True: 0, False: 1.30k]
  ------------------
  584|      0|    WebPInitUpsamplers();
  585|      0|  }
  586|  2.66k|  if (io->use_scaling) {
  ------------------
  |  Branch (586:7): [True: 0, False: 2.66k]
  ------------------
  587|      0|#if !defined(WEBP_REDUCE_SIZE)
  588|      0|    const int ok = is_rgb ? InitRGBRescaler(io, p) : InitYUVRescaler(io, p);
  ------------------
  |  Branch (588:20): [True: 0, False: 0]
  ------------------
  589|      0|    if (!ok) {
  ------------------
  |  Branch (589:9): [True: 0, False: 0]
  ------------------
  590|      0|      return 0;  // memory error
  591|      0|    }
  592|       |#else
  593|       |    return 0;  // rescaling support not compiled
  594|       |#endif
  595|  2.66k|  } else {
  596|  2.66k|    if (is_rgb) {
  ------------------
  |  Branch (596:9): [True: 2.30k, False: 360]
  ------------------
  597|  2.30k|      WebPInitSamplers();
  598|  2.30k|      p->emit = EmitSampledRGB;  // default
  599|  2.30k|      if (io->fancy_upsampling) {
  ------------------
  |  Branch (599:11): [True: 2.30k, False: 0]
  ------------------
  600|  2.30k|#ifdef FANCY_UPSAMPLING
  601|  2.30k|        const int uv_width = (io->mb_w + 1) >> 1;
  602|  2.30k|        p->memory = WebPSafeMalloc(1ULL, (size_t)(io->mb_w + 2 * uv_width));
  603|  2.30k|        if (p->memory == NULL) {
  ------------------
  |  Branch (603:13): [True: 0, False: 2.30k]
  ------------------
  604|      0|          return 0;  // memory error.
  605|      0|        }
  606|  2.30k|        p->tmp_y = (uint8_t*)p->memory;
  607|  2.30k|        p->tmp_u = p->tmp_y + io->mb_w;
  608|  2.30k|        p->tmp_v = p->tmp_u + uv_width;
  609|  2.30k|        p->emit = EmitFancyRGB;
  610|  2.30k|        WebPInitUpsamplers();
  611|  2.30k|#endif
  612|  2.30k|      }
  613|  2.30k|    } else {
  614|    360|      p->emit = EmitYUV;
  615|    360|    }
  616|  2.66k|    if (is_alpha) {  // need transparency output
  ------------------
  |  Branch (616:9): [True: 1.30k, False: 1.36k]
  ------------------
  617|  1.30k|      p->emit_alpha =
  618|  1.30k|          (colorspace == MODE_RGBA_4444 || colorspace == MODE_rgbA_4444)
  ------------------
  |  Branch (618:12): [True: 0, False: 1.30k]
  |  Branch (618:44): [True: 0, False: 1.30k]
  ------------------
  619|  1.30k|              ? EmitAlphaRGBA4444
  620|  1.30k|          : is_rgb ? EmitAlphaRGB
  ------------------
  |  Branch (620:13): [True: 1.30k, False: 0]
  ------------------
  621|  1.30k|                   : EmitAlphaYUV;
  622|  1.30k|      if (is_rgb) {
  ------------------
  |  Branch (622:11): [True: 1.30k, False: 0]
  ------------------
  623|  1.30k|        WebPInitAlphaProcessing();
  624|  1.30k|      }
  625|  1.30k|    }
  626|  2.66k|  }
  627|       |
  628|  2.66k|  return 1;
  629|  2.66k|}
io_dec.c:EmitFancyRGB:
   66|  30.8k|static int EmitFancyRGB(const VP8Io* const io, WebPDecParams* const p) {
   67|  30.8k|  int num_lines_out = io->mb_h;  // a priori guess
   68|  30.8k|  const WebPRGBABuffer* const buf = &p->output->u.RGBA;
   69|  30.8k|  uint8_t* dst = buf->rgba + (ptrdiff_t)io->mb_y * buf->stride;
   70|  30.8k|  WebPUpsampleLinePairFunc upsample = WebPUpsamplers[p->output->colorspace];
   71|  30.8k|  const uint8_t* cur_y = io->y;
   72|  30.8k|  const uint8_t* cur_u = io->u;
   73|  30.8k|  const uint8_t* cur_v = io->v;
   74|  30.8k|  const uint8_t* top_u = p->tmp_u;
   75|  30.8k|  const uint8_t* top_v = p->tmp_v;
   76|  30.8k|  int y = io->mb_y;
   77|  30.8k|  const int y_end = io->mb_y + io->mb_h;
   78|  30.8k|  const int mb_w = io->mb_w;
   79|  30.8k|  const int uv_w = (mb_w + 1) / 2;
   80|       |
   81|  30.8k|  if (y == 0) {
  ------------------
  |  Branch (81:7): [True: 1.69k, False: 29.1k]
  ------------------
   82|       |    // First line is special cased. We mirror the u/v samples at boundary.
   83|  1.69k|    upsample(cur_y, NULL, cur_u, cur_v, cur_u, cur_v, dst, NULL, mb_w);
   84|  29.1k|  } else {
   85|       |    // We can finish the left-over line from previous call.
   86|  29.1k|    upsample(p->tmp_y, cur_y, top_u, top_v, cur_u, cur_v, dst - buf->stride,
   87|  29.1k|             dst, mb_w);
   88|  29.1k|    ++num_lines_out;
   89|  29.1k|  }
   90|       |  // Loop over each output pairs of row.
   91|   241k|  for (; y + 2 < y_end; y += 2) {
  ------------------
  |  Branch (91:10): [True: 210k, False: 30.8k]
  ------------------
   92|   210k|    top_u = cur_u;
   93|   210k|    top_v = cur_v;
   94|   210k|    cur_u += io->uv_stride;
   95|   210k|    cur_v += io->uv_stride;
   96|   210k|    dst += 2 * buf->stride;
   97|   210k|    cur_y += 2 * io->y_stride;
   98|   210k|    upsample(cur_y - io->y_stride, cur_y, top_u, top_v, cur_u, cur_v,
   99|   210k|             dst - buf->stride, dst, mb_w);
  100|   210k|  }
  101|       |  // move to last row
  102|  30.8k|  cur_y += io->y_stride;
  103|  30.8k|  if (io->crop_top + y_end < io->crop_bottom) {
  ------------------
  |  Branch (103:7): [True: 30.4k, False: 345]
  ------------------
  104|       |    // Save the unfinished samples for next call (as we're not done yet).
  105|  30.4k|    WEBP_UNSAFE_MEMCPY(p->tmp_y, cur_y, mb_w * sizeof(*p->tmp_y));
  ------------------
  |  |  174|  30.4k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
  106|  30.4k|    WEBP_UNSAFE_MEMCPY(p->tmp_u, cur_u, uv_w * sizeof(*p->tmp_u));
  ------------------
  |  |  174|  30.4k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
  107|  30.4k|    WEBP_UNSAFE_MEMCPY(p->tmp_v, cur_v, uv_w * sizeof(*p->tmp_v));
  ------------------
  |  |  174|  30.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|  30.4k|    num_lines_out--;
  111|  30.4k|  } else {
  112|       |    // Process the very last row of even-sized picture
  113|    345|    if (!(y_end & 1)) {
  ------------------
  |  Branch (113:9): [True: 137, False: 208]
  ------------------
  114|    137|      upsample(cur_y, NULL, cur_u, cur_v, cur_u, cur_v, dst + buf->stride, NULL,
  115|    137|               mb_w);
  116|    137|    }
  117|    345|  }
  118|  30.8k|  return num_lines_out;
  119|  30.8k|}
io_dec.c:EmitYUV:
   35|  4.25k|static int EmitYUV(const VP8Io* const io, WebPDecParams* const p) {
   36|  4.25k|  WebPDecBuffer* output = p->output;
   37|  4.25k|  const WebPYUVABuffer* const buf = &output->u.YUVA;
   38|  4.25k|  uint8_t* const y_dst = buf->y + (ptrdiff_t)io->mb_y * buf->y_stride;
   39|  4.25k|  uint8_t* const u_dst = buf->u + (ptrdiff_t)(io->mb_y >> 1) * buf->u_stride;
   40|  4.25k|  uint8_t* const v_dst = buf->v + (ptrdiff_t)(io->mb_y >> 1) * buf->v_stride;
   41|  4.25k|  const int mb_w = io->mb_w;
   42|  4.25k|  const int mb_h = io->mb_h;
   43|  4.25k|  const int uv_w = (mb_w + 1) / 2;
   44|  4.25k|  const int uv_h = (mb_h + 1) / 2;
   45|  4.25k|  WebPCopyPlane(io->y, io->y_stride, y_dst, buf->y_stride, mb_w, mb_h);
   46|  4.25k|  WebPCopyPlane(io->u, io->uv_stride, u_dst, buf->u_stride, uv_w, uv_h);
   47|  4.25k|  WebPCopyPlane(io->v, io->uv_stride, v_dst, buf->v_stride, uv_w, uv_h);
   48|  4.25k|  return io->mb_h;
   49|  4.25k|}
io_dec.c:EmitAlphaRGB:
  183|  17.6k|                        int expected_num_lines_out) {
  184|  17.6k|  const uint8_t* alpha = io->a;
  185|  17.6k|  if (alpha != NULL) {
  ------------------
  |  Branch (185:7): [True: 0, False: 17.6k]
  ------------------
  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|  17.6k|  return 0;
  206|  17.6k|}
io_dec.c:CustomTeardown:
  653|  2.66k|static void CustomTeardown(const VP8Io* io) {
  654|  2.66k|  WebPDecParams* const p = (WebPDecParams*)io->opaque;
  655|  2.66k|  WebPSafeFree(p->memory);
  656|       |  p->memory = NULL;
  657|  2.66k|}

VP8ParseQuant:
   50|  2.69k|void VP8ParseQuant(VP8Decoder* const dec) {
   51|  2.69k|  VP8BitReader* const br = &dec->br;
   52|  2.69k|  const int base_q0 = VP8GetValue(br, 7, "global-header");
  ------------------
  |  |   43|  2.69k|#define VP8GetValue(BR, N, L) VP8GetValue(BR, N)
  ------------------
   53|  2.69k|  const int dqy1_dc = VP8Get(br, "global-header")
  ------------------
  |  |   44|  2.69k|#define VP8Get(BR, L) VP8GetValue(BR, 1, L)
  |  |  ------------------
  |  |  |  |   43|  2.69k|#define VP8GetValue(BR, N, L) VP8GetValue(BR, N)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (43:31): [True: 655, False: 2.04k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   54|  2.69k|                          ? VP8GetSignedValue(br, 4, "global-header")
  ------------------
  |  |   45|    655|#define VP8GetSignedValue(BR, N, L) VP8GetSignedValue(BR, N)
  ------------------
   55|  2.69k|                          : 0;
   56|  2.69k|  const int dqy2_dc = VP8Get(br, "global-header")
  ------------------
  |  |   44|  2.69k|#define VP8Get(BR, L) VP8GetValue(BR, 1, L)
  |  |  ------------------
  |  |  |  |   43|  2.69k|#define VP8GetValue(BR, N, L) VP8GetValue(BR, N)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (43:31): [True: 421, False: 2.27k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   57|  2.69k|                          ? VP8GetSignedValue(br, 4, "global-header")
  ------------------
  |  |   45|    421|#define VP8GetSignedValue(BR, N, L) VP8GetSignedValue(BR, N)
  ------------------
   58|  2.69k|                          : 0;
   59|  2.69k|  const int dqy2_ac = VP8Get(br, "global-header")
  ------------------
  |  |   44|  2.69k|#define VP8Get(BR, L) VP8GetValue(BR, 1, L)
  |  |  ------------------
  |  |  |  |   43|  2.69k|#define VP8GetValue(BR, N, L) VP8GetValue(BR, N)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (43:31): [True: 429, False: 2.26k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   60|  2.69k|                          ? VP8GetSignedValue(br, 4, "global-header")
  ------------------
  |  |   45|    429|#define VP8GetSignedValue(BR, N, L) VP8GetSignedValue(BR, N)
  ------------------
   61|  2.69k|                          : 0;
   62|  2.69k|  const int dquv_dc = VP8Get(br, "global-header")
  ------------------
  |  |   44|  2.69k|#define VP8Get(BR, L) VP8GetValue(BR, 1, L)
  |  |  ------------------
  |  |  |  |   43|  2.69k|#define VP8GetValue(BR, N, L) VP8GetValue(BR, N)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (43:31): [True: 325, False: 2.37k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   63|  2.69k|                          ? VP8GetSignedValue(br, 4, "global-header")
  ------------------
  |  |   45|    325|#define VP8GetSignedValue(BR, N, L) VP8GetSignedValue(BR, N)
  ------------------
   64|  2.69k|                          : 0;
   65|  2.69k|  const int dquv_ac = VP8Get(br, "global-header")
  ------------------
  |  |   44|  2.69k|#define VP8Get(BR, L) VP8GetValue(BR, 1, L)
  |  |  ------------------
  |  |  |  |   43|  2.69k|#define VP8GetValue(BR, N, L) VP8GetValue(BR, N)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (43:31): [True: 483, False: 2.21k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   66|  2.69k|                          ? VP8GetSignedValue(br, 4, "global-header")
  ------------------
  |  |   45|    483|#define VP8GetSignedValue(BR, N, L) VP8GetSignedValue(BR, N)
  ------------------
   67|  2.69k|                          : 0;
   68|       |
   69|  2.69k|  const VP8SegmentHeader* const hdr = &dec->segment_hdr;
   70|  2.69k|  int i;
   71|       |
   72|  13.4k|  for (i = 0; i < NUM_MB_SEGMENTS; ++i) {
  ------------------
  |  Branch (72:15): [True: 10.7k, False: 2.69k]
  ------------------
   73|  10.7k|    int q;
   74|  10.7k|    if (hdr->use_segment) {
  ------------------
  |  Branch (74:9): [True: 1.56k, False: 9.22k]
  ------------------
   75|  1.56k|      q = hdr->quantizer[i];
   76|  1.56k|      if (!hdr->absolute_delta) {
  ------------------
  |  Branch (76:11): [True: 452, False: 1.11k]
  ------------------
   77|    452|        q += base_q0;
   78|    452|      }
   79|  9.22k|    } else {
   80|  9.22k|      if (i > 0) {
  ------------------
  |  Branch (80:11): [True: 6.91k, False: 2.30k]
  ------------------
   81|  6.91k|        dec->dqm[i] = dec->dqm[0];
   82|  6.91k|        continue;
   83|  6.91k|      } else {
   84|  2.30k|        q = base_q0;
   85|  2.30k|      }
   86|  9.22k|    }
   87|  3.87k|    {
   88|  3.87k|      VP8QuantMatrix* const m = &dec->dqm[i];
   89|  3.87k|      m->y1_mat[0] = kDcTable[clip(q + dqy1_dc, 127)];
   90|  3.87k|      m->y1_mat[1] = kAcTable[clip(q + 0, 127)];
   91|       |
   92|  3.87k|      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.87k|      m->y2_mat[1] = (kAcTable[clip(q + dqy2_ac, 127)] * 101581) >> 16;
   97|  3.87k|      if (m->y2_mat[1] < 8) m->y2_mat[1] = 8;
  ------------------
  |  Branch (97:11): [True: 1.22k, False: 2.65k]
  ------------------
   98|       |
   99|  3.87k|      m->uv_mat[0] = kDcTable[clip(q + dquv_dc, 117)];
  100|  3.87k|      m->uv_mat[1] = kAcTable[clip(q + dquv_ac, 127)];
  101|       |
  102|  3.87k|      m->uv_quant = q + dquv_ac;  // for dithering strength evaluation
  103|  3.87k|    }
  104|  3.87k|  }
  105|  2.69k|}
quant_dec.c:clip:
   22|  23.2k|static WEBP_INLINE int clip(int v, int M) { return v < 0 ? 0 : v > M ? M : v; }
  ------------------
  |  Branch (22:52): [True: 2.62k, False: 20.6k]
  |  Branch (22:64): [True: 863, False: 19.7k]
  ------------------

VP8ResetProba:
  251|  2.86k|void VP8ResetProba(VP8Proba* const proba) {
  252|  2.86k|  WEBP_UNSAFE_MEMSET(proba->segments, 255u, sizeof(proba->segments));
  ------------------
  |  |  175|  2.86k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  253|       |  // proba->bands[][] is initialized later
  254|  2.86k|}
VP8ParseIntraModeRow:
  333|  37.3k|int VP8ParseIntraModeRow(VP8BitReader* const br, VP8Decoder* const dec) {
  334|  37.3k|  int mb_x;
  335|   184k|  for (mb_x = 0; mb_x < dec->mb_w; ++mb_x) {
  ------------------
  |  Branch (335:18): [True: 147k, False: 37.3k]
  ------------------
  336|   147k|    ParseIntraMode(br, dec, mb_x);
  337|   147k|  }
  338|  37.3k|  return !dec->br.eof;
  339|  37.3k|}
VP8ParseProba:
  450|  2.69k|void VP8ParseProba(VP8BitReader* const br, VP8Decoder* const dec) {
  451|  2.69k|  VP8Proba* const proba = &dec->proba;
  452|  2.69k|  int t, b, c, p;
  453|  13.4k|  for (t = 0; t < NUM_TYPES; ++t) {
  ------------------
  |  Branch (453:15): [True: 10.7k, False: 2.69k]
  ------------------
  454|  97.0k|    for (b = 0; b < NUM_BANDS; ++b) {
  ------------------
  |  Branch (454:17): [True: 86.3k, False: 10.7k]
  ------------------
  455|   345k|      for (c = 0; c < NUM_CTX; ++c) {
  ------------------
  |  Branch (455:19): [True: 258k, False: 86.3k]
  ------------------
  456|  3.10M|        for (p = 0; p < NUM_PROBAS; ++p) {
  ------------------
  |  Branch (456:21): [True: 2.84M, False: 258k]
  ------------------
  457|  2.84M|          const int v =
  458|  2.84M|              VP8GetBit(br, CoeffsUpdateProba[t][b][c][p], "global-header")
  ------------------
  |  |   46|  2.84M|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  |  |  ------------------
  |  |  |  Branch (46:29): [True: 53.2k, False: 2.79M]
  |  |  ------------------
  ------------------
  459|  2.84M|                  ? VP8GetValue(br, 8, "global-header")
  ------------------
  |  |   43|  53.2k|#define VP8GetValue(BR, N, L) VP8GetValue(BR, N)
  ------------------
  460|  2.84M|                  : CoeffsProba0[t][b][c][p];
  461|  2.84M|          proba->bands[t][b].probas[c][p] = v;
  462|  2.84M|        }
  463|   258k|      }
  464|  86.3k|    }
  465|   194k|    for (b = 0; b < 16 + 1; ++b) {
  ------------------
  |  Branch (465:17): [True: 183k, False: 10.7k]
  ------------------
  466|   183k|      proba->bands_ptr[t][b] = &proba->bands[t][kBands[b]];
  467|   183k|    }
  468|  10.7k|  }
  469|  2.69k|  dec->use_skip_proba = VP8Get(br, "global-header");
  ------------------
  |  |   44|  2.69k|#define VP8Get(BR, L) VP8GetValue(BR, 1, L)
  |  |  ------------------
  |  |  |  |   43|  2.69k|#define VP8GetValue(BR, N, L) VP8GetValue(BR, N)
  |  |  ------------------
  ------------------
  470|  2.69k|  if (dec->use_skip_proba) {
  ------------------
  |  Branch (470:7): [True: 492, False: 2.20k]
  ------------------
  471|    492|    dec->skip_p = VP8GetValue(br, 8, "global-header");
  ------------------
  |  |   43|    492|#define VP8GetValue(BR, N, L) VP8GetValue(BR, N)
  ------------------
  472|    492|  }
  473|  2.69k|}
tree_dec.c:ParseIntraMode:
  257|   147k|                           int mb_x) {
  258|   147k|  uint8_t* const top = dec->intra_t + 4 * mb_x;
  259|   147k|  uint8_t* const left = dec->intra_l;
  260|   147k|  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|   147k|  if (dec->segment_hdr.update_map) {
  ------------------
  |  Branch (264:7): [True: 66.9k, False: 80.6k]
  ------------------
  265|       |    // Hardcoded tree parsing
  266|  66.9k|    block->segment =
  267|  66.9k|        !VP8GetBit(br, dec->proba.segments[0], "segments")
  ------------------
  |  |   46|  66.9k|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  ------------------
  |  Branch (267:9): [True: 47.2k, False: 19.6k]
  ------------------
  268|  66.9k|            ? VP8GetBit(br, dec->proba.segments[1], "segments")
  ------------------
  |  |   46|  47.2k|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  ------------------
  269|  66.9k|            : VP8GetBit(br, dec->proba.segments[2], "segments") + 2;
  ------------------
  |  |   46|  19.6k|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  ------------------
  270|  80.6k|  } else {
  271|  80.6k|    block->segment = 0;  // default for intra
  272|  80.6k|  }
  273|   147k|  if (dec->use_skip_proba) block->skip = VP8GetBit(br, dec->skip_p, "skip");
  ------------------
  |  |   46|  72.0k|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  ------------------
  |  Branch (273:7): [True: 72.0k, False: 75.5k]
  ------------------
  274|       |
  275|   147k|  block->is_i4x4 = !VP8GetBit(br, 145, "block-size");
  ------------------
  |  |   46|   147k|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  ------------------
  276|   147k|  if (!block->is_i4x4) {
  ------------------
  |  Branch (276:7): [True: 50.3k, False: 97.2k]
  ------------------
  277|       |    // Hardcoded 16x16 intra-mode decision tree.
  278|  50.3k|    const int ymode =
  279|  50.3k|        VP8GetBit(br, 156, "pred-modes")
  ------------------
  |  |   46|  50.3k|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  |  |  ------------------
  |  |  |  Branch (46:29): [True: 28.7k, False: 21.5k]
  |  |  ------------------
  ------------------
  280|  50.3k|            ? (VP8GetBit(br, 128, "pred-modes") ? TM_PRED : H_PRED)
  ------------------
  |  |   46|  28.7k|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  |  |  ------------------
  |  |  |  Branch (46:29): [True: 22.5k, False: 6.26k]
  |  |  ------------------
  ------------------
  281|  50.3k|            : (VP8GetBit(br, 163, "pred-modes") ? V_PRED : DC_PRED);
  ------------------
  |  |   46|  21.5k|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  |  |  ------------------
  |  |  |  Branch (46:29): [True: 5.80k, False: 15.7k]
  |  |  ------------------
  ------------------
  282|  50.3k|    block->imodes[0] = ymode;
  283|  50.3k|    WEBP_UNSAFE_MEMSET(top, ymode, 4 * sizeof(*top));
  ------------------
  |  |  175|  50.3k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  284|  50.3k|    WEBP_UNSAFE_MEMSET(left, ymode, 4 * sizeof(*left));
  ------------------
  |  |  175|  50.3k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  285|  97.2k|  } else {
  286|  97.2k|    uint8_t* modes = block->imodes;
  287|  97.2k|    int y;
  288|   486k|    for (y = 0; y < 4; ++y) {
  ------------------
  |  Branch (288:17): [True: 388k, False: 97.2k]
  ------------------
  289|   388k|      int ymode = left[y];
  290|   388k|      int x;
  291|  1.94M|      for (x = 0; x < 4; ++x) {
  ------------------
  |  Branch (291:19): [True: 1.55M, False: 388k]
  ------------------
  292|  1.55M|        const uint8_t* const prob = kBModesProba[top[x]][ymode];
  293|  1.55M|#if (USE_GENERIC_TREE == 1)
  294|       |        // Generic tree-parsing
  295|  1.55M|        int i = kYModesIntra4[VP8GetBit(br, prob[0], "pred-modes")];
  ------------------
  |  |   46|  1.55M|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  ------------------
  296|  1.75M|        while (i > 0) {
  ------------------
  |  Branch (296:16): [True: 195k, False: 1.55M]
  ------------------
  297|   195k|          i = kYModesIntra4[2 * i + VP8GetBit(br, prob[i], "pred-modes")];
  ------------------
  |  |   46|   195k|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  ------------------
  298|   195k|        }
  299|  1.55M|        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.55M|        top[x] = ymode;
  320|  1.55M|      }
  321|   388k|      WEBP_UNSAFE_MEMCPY(modes, top, 4 * sizeof(*top));
  ------------------
  |  |  174|   388k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
  322|   388k|      modes += 4;
  323|   388k|      left[y] = ymode;
  324|   388k|    }
  325|  97.2k|  }
  326|       |  // Hardcoded UVMode decision tree
  327|   147k|  block->uvmode = !VP8GetBit(br, 142, "pred-modes-uv")   ? DC_PRED
  ------------------
  |  |   46|   147k|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  ------------------
  |  Branch (327:19): [True: 109k, False: 38.5k]
  ------------------
  328|   147k|                  : !VP8GetBit(br, 114, "pred-modes-uv") ? V_PRED
  ------------------
  |  |   46|  38.5k|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  ------------------
  |  Branch (328:21): [True: 9.96k, False: 28.6k]
  ------------------
  329|  38.5k|                  : VP8GetBit(br, 183, "pred-modes-uv")  ? TM_PRED
  ------------------
  |  |   46|  28.6k|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  |  |  ------------------
  |  |  |  Branch (46:29): [True: 19.8k, False: 8.78k]
  |  |  ------------------
  ------------------
  330|  28.6k|                                                         : H_PRED;
  331|   147k|}

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

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

VP8LCheckSignature:
  109|  18.9k|                       size_t size) {
  110|  18.9k|  return (size >= VP8L_FRAME_HEADER_SIZE && data[0] == VP8L_MAGIC_BYTE &&
  ------------------
  |  |   33|  37.9k|#define VP8L_FRAME_HEADER_SIZE 5  // Size of the VP8L frame header.
  ------------------
                return (size >= VP8L_FRAME_HEADER_SIZE && data[0] == VP8L_MAGIC_BYTE &&
  ------------------
  |  |   28|  37.9k|#define VP8L_MAGIC_BYTE 0x2f   // VP8L signature byte.
  ------------------
  |  Branch (110:11): [True: 18.9k, False: 0]
  |  Branch (110:45): [True: 11.4k, False: 7.45k]
  ------------------
  111|  11.4k|          (data[4] >> 5) == 0);  // version
  ------------------
  |  Branch (111:11): [True: 11.4k, False: 8]
  ------------------
  112|  18.9k|}
VP8LGetInfo:
  126|  5.82k|                int* const has_alpha) {
  127|  5.82k|  if (data == NULL || data_size < VP8L_FRAME_HEADER_SIZE) {
  ------------------
  |  |   33|  5.82k|#define VP8L_FRAME_HEADER_SIZE 5  // Size of the VP8L frame header.
  ------------------
  |  Branch (127:7): [True: 0, False: 5.82k]
  |  Branch (127:23): [True: 0, False: 5.82k]
  ------------------
  128|      0|    return 0;  // not enough data
  129|  5.82k|  } else if (!VP8LCheckSignature(data, data_size)) {
  ------------------
  |  Branch (129:14): [True: 14, False: 5.81k]
  ------------------
  130|     14|    return 0;  // bad signature
  131|  5.81k|  } else {
  132|  5.81k|    int w, h, a;
  133|  5.81k|    VP8LBitReader br;
  134|  5.81k|    VP8LInitBitReader(&br, data, data_size);
  135|  5.81k|    if (!ReadImageInfo(&br, &w, &h, &a)) {
  ------------------
  |  Branch (135:9): [True: 0, False: 5.81k]
  ------------------
  136|      0|      return 0;
  137|      0|    }
  138|  5.81k|    if (width != NULL) *width = w;
  ------------------
  |  Branch (138:9): [True: 5.81k, False: 0]
  ------------------
  139|  5.81k|    if (height != NULL) *height = h;
  ------------------
  |  Branch (139:9): [True: 5.81k, False: 0]
  ------------------
  140|  5.81k|    if (has_alpha != NULL) *has_alpha = a;
  ------------------
  |  Branch (140:9): [True: 3.53k, False: 2.27k]
  ------------------
  141|  5.81k|    return 1;
  142|  5.81k|  }
  143|  5.82k|}
ReadHuffmanCodesHelper:
  454|  3.58k|                           HTreeGroup** const htree_groups) {
  455|  3.58k|  int i, j, ok = 0;
  456|  3.58k|  const int max_alphabet_size =
  457|  3.58k|      kAlphabetSize[0] + ((color_cache_bits > 0) ? 1 << color_cache_bits : 0);
  ------------------
  |  Branch (457:27): [True: 578, False: 3.00k]
  ------------------
  458|  3.58k|  const int table_size = kTableSize[color_cache_bits];
  459|  3.58k|  int* code_lengths = NULL;
  460|  3.58k|  int total_huffman_table_size;
  461|       |
  462|  3.58k|  if ((mapping == NULL && num_htree_groups != num_htree_groups_max) ||
  ------------------
  |  Branch (462:8): [True: 3.43k, False: 149]
  |  Branch (462:27): [True: 0, False: 3.43k]
  ------------------
  463|  3.58k|      num_htree_groups > num_htree_groups_max) {
  ------------------
  |  Branch (463:7): [True: 0, False: 3.58k]
  ------------------
  464|      0|    goto Error;
  465|      0|  }
  466|       |
  467|  3.58k|  code_lengths =
  468|  3.58k|      (int*)WebPSafeCalloc((uint64_t)max_alphabet_size, sizeof(*code_lengths));
  469|  3.58k|  *htree_groups = VP8LHtreeGroupsNew(num_htree_groups);
  470|       |
  471|       |  // MAX_HUFF_IMAGE_SIZE is above what the libwebp encoder allows so something
  472|       |  // fishy might be happening. Do not allocate too much yet.
  473|  3.58k|  total_huffman_table_size =
  474|  3.58k|      (num_htree_groups_max > MAX_HUFF_IMAGE_SIZE ? MAX_HUFF_IMAGE_SIZE
  ------------------
  |  |   64|  3.58k|#define MAX_HUFF_IMAGE_SIZE 2600
  ------------------
                    (num_htree_groups_max > MAX_HUFF_IMAGE_SIZE ? MAX_HUFF_IMAGE_SIZE
  ------------------
  |  |   64|     95|#define MAX_HUFF_IMAGE_SIZE 2600
  ------------------
  |  Branch (474:8): [True: 95, False: 3.48k]
  ------------------
  475|  3.58k|                                                  : num_htree_groups) *
  476|  3.58k|      table_size;
  477|  3.58k|  if (*htree_groups == NULL || code_lengths == NULL ||
  ------------------
  |  Branch (477:7): [True: 0, False: 3.58k]
  |  Branch (477:32): [True: 0, False: 3.58k]
  ------------------
  478|  3.58k|      !VP8LHuffmanTablesAllocate(total_huffman_table_size, huffman_tables)) {
  ------------------
  |  Branch (478:7): [True: 0, False: 3.58k]
  ------------------
  479|      0|    VP8LSetError(dec, VP8_STATUS_OUT_OF_MEMORY);
  480|      0|    goto Error;
  481|      0|  }
  482|       |
  483|   179k|  for (i = 0; i < num_htree_groups_max; ++i) {
  ------------------
  |  Branch (483:15): [True: 176k, False: 2.74k]
  ------------------
  484|       |    // If the index "i" is unused in the Huffman image, just make sure the
  485|       |    // coefficients are valid but do not store them.
  486|   176k|    if (mapping != NULL && mapping[i] == -1) {
  ------------------
  |  Branch (486:9): [True: 155k, False: 20.9k]
  |  Branch (486:28): [True: 155k, False: 790]
  ------------------
  487|   929k|      for (j = 0; j < HUFFMAN_CODES_PER_META_CODE; ++j) {
  ------------------
  |  |   37|   929k|#define HUFFMAN_CODES_PER_META_CODE 5
  ------------------
  |  Branch (487:19): [True: 774k, False: 154k]
  ------------------
  488|   774k|        int alphabet_size = kAlphabetSize[j];
  489|   774k|        if (j == 0 && color_cache_bits > 0) {
  ------------------
  |  Branch (489:13): [True: 155k, False: 619k]
  |  Branch (489:23): [True: 152k, False: 2.42k]
  ------------------
  490|   152k|          alphabet_size += (1 << color_cache_bits);
  491|   152k|        }
  492|       |        // Passing in NULL so that nothing gets filled.
  493|   774k|        if (!ReadHuffmanCode(alphabet_size, dec, code_lengths, NULL)) {
  ------------------
  |  Branch (493:13): [True: 111, False: 774k]
  ------------------
  494|    111|          goto Error;
  495|    111|        }
  496|   774k|      }
  497|   155k|    } else {
  498|  21.7k|      HTreeGroup* const htree_group =
  499|  21.7k|          &(*htree_groups)[(mapping == NULL) ? i : mapping[i]];
  ------------------
  |  Branch (499:28): [True: 20.9k, False: 790]
  ------------------
  500|  21.7k|      HuffmanCode** const htrees = htree_group->htrees;
  501|  21.7k|      int size;
  502|  21.7k|      int total_size = 0;
  503|  21.7k|      int is_trivial_literal = 1;
  504|  21.7k|      int max_bits = 0;
  505|   127k|      for (j = 0; j < HUFFMAN_CODES_PER_META_CODE; ++j) {
  ------------------
  |  |   37|   127k|#define HUFFMAN_CODES_PER_META_CODE 5
  ------------------
  |  Branch (505:19): [True: 106k, False: 20.9k]
  ------------------
  506|   106k|        int alphabet_size = kAlphabetSize[j];
  507|   106k|        if (j == 0 && color_cache_bits > 0) {
  ------------------
  |  Branch (507:13): [True: 21.7k, False: 84.8k]
  |  Branch (507:23): [True: 2.94k, False: 18.7k]
  ------------------
  508|  2.94k|          alphabet_size += (1 << color_cache_bits);
  509|  2.94k|        }
  510|   106k|        size =
  511|   106k|            ReadHuffmanCode(alphabet_size, dec, code_lengths, huffman_tables);
  512|   106k|        htrees[j] = huffman_tables->curr_segment->curr_table;
  513|   106k|        if (size == 0) {
  ------------------
  |  Branch (513:13): [True: 728, False: 105k]
  ------------------
  514|    728|          goto Error;
  515|    728|        }
  516|   105k|        if (is_trivial_literal && kLiteralMap[j] == 1) {
  ------------------
  |  Branch (516:13): [True: 100k, False: 5.48k]
  |  Branch (516:35): [True: 60.1k, False: 40.1k]
  ------------------
  517|  60.1k|          is_trivial_literal = (htrees[j]->bits == 0);
  518|  60.1k|        }
  519|   105k|        total_size += htrees[j]->bits;
  520|   105k|        huffman_tables->curr_segment->curr_table += size;
  521|   105k|        if (j <= ALPHA) {
  ------------------
  |  Branch (521:13): [True: 84.8k, False: 20.9k]
  ------------------
  522|  84.8k|          int local_max_bits = code_lengths[0];
  523|  84.8k|          int k;
  524|  24.2M|          for (k = 1; k < alphabet_size; ++k) {
  ------------------
  |  Branch (524:23): [True: 24.1M, False: 84.8k]
  ------------------
  525|  24.1M|            if (code_lengths[k] > local_max_bits) {
  ------------------
  |  Branch (525:17): [True: 49.1k, False: 24.0M]
  ------------------
  526|  49.1k|              local_max_bits = code_lengths[k];
  527|  49.1k|            }
  528|  24.1M|          }
  529|  84.8k|          max_bits += local_max_bits;
  530|  84.8k|        }
  531|   105k|      }
  532|  20.9k|      htree_group->is_trivial_literal = is_trivial_literal;
  533|  20.9k|      htree_group->is_trivial_code = 0;
  534|  20.9k|      if (is_trivial_literal) {
  ------------------
  |  Branch (534:11): [True: 18.7k, False: 2.24k]
  ------------------
  535|  18.7k|        const int red = htrees[RED][0].value;
  536|  18.7k|        const int blue = htrees[BLUE][0].value;
  537|  18.7k|        const int alpha = htrees[ALPHA][0].value;
  538|  18.7k|        htree_group->literal_arb = ((uint32_t)alpha << 24) | (red << 16) | blue;
  539|  18.7k|        if (total_size == 0 && htrees[GREEN][0].value < NUM_LITERAL_CODES) {
  ------------------
  |  |   43|  18.0k|#define NUM_LITERAL_CODES 256
  ------------------
  |  Branch (539:13): [True: 18.0k, False: 662]
  |  Branch (539:32): [True: 18.0k, False: 20]
  ------------------
  540|  18.0k|          htree_group->is_trivial_code = 1;
  541|  18.0k|          htree_group->literal_arb |= htrees[GREEN][0].value << 8;
  542|  18.0k|        }
  543|  18.7k|      }
  544|  20.9k|      htree_group->use_packed_table =
  545|  20.9k|          !htree_group->is_trivial_code && (max_bits < HUFFMAN_PACKED_BITS);
  ------------------
  |  |   73|  2.92k|#define HUFFMAN_PACKED_BITS 6
  ------------------
  |  Branch (545:11): [True: 2.92k, False: 18.0k]
  |  Branch (545:44): [True: 2.73k, False: 193]
  ------------------
  546|  20.9k|      if (htree_group->use_packed_table) BuildPackedTable(htree_group);
  ------------------
  |  Branch (546:11): [True: 2.73k, False: 18.2k]
  ------------------
  547|  20.9k|    }
  548|   176k|  }
  549|  2.74k|  ok = 1;
  550|       |
  551|  3.58k|Error:
  552|  3.58k|  WebPSafeFree(code_lengths);
  553|  3.58k|  if (!ok) {
  ------------------
  |  Branch (553:7): [True: 839, False: 2.74k]
  ------------------
  554|    839|    VP8LHuffmanTablesDeallocate(huffman_tables);
  555|    839|    VP8LHtreeGroupsFree(*htree_groups);
  556|       |    *htree_groups = NULL;
  557|    839|  }
  558|  3.58k|  return ok;
  559|  2.74k|}
VP8LNew:
 1492|  2.27k|VP8LDecoder* VP8LNew(void) {
 1493|  2.27k|  VP8LDecoder* const dec = (VP8LDecoder*)WebPSafeCalloc(1ULL, sizeof(*dec));
 1494|  2.27k|  if (dec == NULL) return NULL;
  ------------------
  |  Branch (1494:7): [True: 0, False: 2.27k]
  ------------------
 1495|  2.27k|  dec->status = VP8_STATUS_OK;
 1496|  2.27k|  dec->state = READ_DIM;
 1497|       |
 1498|  2.27k|  VP8LDspInit();  // Init critical function pointers.
 1499|       |
 1500|  2.27k|  return dec;
 1501|  2.27k|}
VP8LDelete:
 1524|  2.27k|void VP8LDelete(VP8LDecoder* const dec) {
 1525|  2.27k|  if (dec != NULL) {
  ------------------
  |  Branch (1525:7): [True: 2.27k, False: 0]
  ------------------
 1526|  2.27k|    VP8LClear(dec);
 1527|  2.27k|    WebPSafeFree(dec);
 1528|  2.27k|  }
 1529|  2.27k|}
VP8LDecodeHeader:
 1778|  2.27k|int VP8LDecodeHeader(VP8LDecoder* const dec, VP8Io* const io) {
 1779|  2.27k|  int width, height, has_alpha;
 1780|       |
 1781|  2.27k|  if (dec == NULL) return 0;
  ------------------
  |  Branch (1781:7): [True: 0, False: 2.27k]
  ------------------
 1782|  2.27k|  if (io == NULL) {
  ------------------
  |  Branch (1782:7): [True: 0, False: 2.27k]
  ------------------
 1783|      0|    return VP8LSetError(dec, VP8_STATUS_INVALID_PARAM);
 1784|      0|  }
 1785|       |
 1786|  2.27k|  dec->io = io;
 1787|  2.27k|  dec->status = VP8_STATUS_OK;
 1788|  2.27k|  {
 1789|  2.27k|    const uint8_t* WEBP_BIDI_INDEXABLE const bounded_data =
 1790|  2.27k|        WEBP_UNSAFE_FORGE_BIDI_INDEXABLE(const uint8_t*, io->data,
  ------------------
  |  |  180|  2.27k|#define WEBP_UNSAFE_FORGE_BIDI_INDEXABLE(typ, ptr, size) ((typ)(ptr))
  ------------------
 1791|  2.27k|                                         io->data_size);
 1792|  2.27k|    VP8LInitBitReader(&dec->br, bounded_data, io->data_size);
 1793|  2.27k|  }
 1794|  2.27k|  if (!ReadImageInfo(&dec->br, &width, &height, &has_alpha)) {
  ------------------
  |  Branch (1794:7): [True: 0, False: 2.27k]
  ------------------
 1795|      0|    VP8LSetError(dec, VP8_STATUS_BITSTREAM_ERROR);
 1796|      0|    goto Error;
 1797|      0|  }
 1798|  2.27k|  dec->state = READ_DIM;
 1799|  2.27k|  io->width = width;
 1800|  2.27k|  io->height = height;
 1801|       |
 1802|  2.27k|  if (!DecodeImageStream(width, height, /*is_level0=*/1, dec,
  ------------------
  |  Branch (1802:7): [True: 932, False: 1.34k]
  ------------------
 1803|  2.27k|                         /*decoded_data=*/NULL)) {
 1804|    932|    goto Error;
 1805|    932|  }
 1806|  1.34k|  return 1;
 1807|       |
 1808|    932|Error:
 1809|    932|  VP8LClear(dec);
 1810|       |  assert(dec->status != VP8_STATUS_OK);
 1811|    932|  return 0;
 1812|  2.27k|}
VP8LDecodeImage:
 1814|  1.30k|int VP8LDecodeImage(VP8LDecoder* const dec) {
 1815|  1.30k|  VP8Io* io = NULL;
 1816|  1.30k|  WebPDecParams* params = NULL;
 1817|       |
 1818|  1.30k|  if (dec == NULL) return 0;
  ------------------
  |  Branch (1818:7): [True: 0, False: 1.30k]
  ------------------
 1819|       |
 1820|  1.30k|  assert(dec->hdr.huffman_tables.root.start != NULL);
 1821|  1.30k|  assert(dec->hdr.htree_groups != NULL);
 1822|  1.30k|  assert(dec->hdr.num_htree_groups > 0);
 1823|       |
 1824|  1.30k|  io = dec->io;
 1825|  1.30k|  assert(io != NULL);
 1826|  1.30k|  params = (WebPDecParams*)io->opaque;
 1827|  1.30k|  assert(params != NULL);
 1828|       |
 1829|       |  // Initialization.
 1830|  1.30k|  if (dec->state != READ_DATA) {
  ------------------
  |  Branch (1830:7): [True: 1.30k, False: 0]
  ------------------
 1831|  1.30k|    dec->output = params->output;
 1832|  1.30k|    assert(dec->output != NULL);
 1833|       |
 1834|  1.30k|    if (!WebPIoInitFromOptions(params->options, io, MODE_BGRA)) {
  ------------------
  |  Branch (1834:9): [True: 0, False: 1.30k]
  ------------------
 1835|      0|      VP8LSetError(dec, VP8_STATUS_INVALID_PARAM);
 1836|      0|      goto Err;
 1837|      0|    }
 1838|       |
 1839|  1.30k|    if (!AllocateInternalBuffers32b(dec, io->width)) goto Err;
  ------------------
  |  Branch (1839:9): [True: 0, False: 1.30k]
  ------------------
 1840|       |
 1841|  1.30k|#if !defined(WEBP_REDUCE_SIZE)
 1842|  1.30k|    if (io->use_scaling && !AllocateAndInitRescaler(dec, io)) goto Err;
  ------------------
  |  Branch (1842:9): [True: 0, False: 1.30k]
  |  Branch (1842:28): [True: 0, False: 0]
  ------------------
 1843|       |#else
 1844|       |    if (io->use_scaling) {
 1845|       |      VP8LSetError(dec, VP8_STATUS_INVALID_PARAM);
 1846|       |      goto Err;
 1847|       |    }
 1848|       |#endif
 1849|  1.30k|    if (io->use_scaling || WebPIsPremultipliedMode(dec->output->colorspace)) {
  ------------------
  |  Branch (1849:9): [True: 0, False: 1.30k]
  |  Branch (1849:28): [True: 0, False: 1.30k]
  ------------------
 1850|       |      // need the alpha-multiply functions for premultiplied output or rescaling
 1851|      0|      WebPInitAlphaProcessing();
 1852|      0|    }
 1853|       |
 1854|  1.30k|    if (!WebPIsRGBMode(dec->output->colorspace)) {
  ------------------
  |  Branch (1854:9): [True: 297, False: 1.01k]
  ------------------
 1855|    297|      WebPInitConvertARGBToYUV();
 1856|    297|      if (dec->output->u.YUVA.a != NULL) WebPInitAlphaProcessing();
  ------------------
  |  Branch (1856:11): [True: 0, False: 297]
  ------------------
 1857|    297|    }
 1858|  1.30k|    if (dec->incremental) {
  ------------------
  |  Branch (1858:9): [True: 0, False: 1.30k]
  ------------------
 1859|      0|      if (dec->hdr.color_cache_size > 0 &&
  ------------------
  |  Branch (1859:11): [True: 0, False: 0]
  ------------------
 1860|      0|          dec->hdr.saved_color_cache.colors == NULL) {
  ------------------
  |  Branch (1860:11): [True: 0, False: 0]
  ------------------
 1861|      0|        if (!VP8LColorCacheInit(&dec->hdr.saved_color_cache,
  ------------------
  |  Branch (1861:13): [True: 0, False: 0]
  ------------------
 1862|      0|                                dec->hdr.color_cache.hash_bits)) {
 1863|      0|          VP8LSetError(dec, VP8_STATUS_OUT_OF_MEMORY);
 1864|      0|          goto Err;
 1865|      0|        }
 1866|      0|      }
 1867|      0|    }
 1868|  1.30k|    dec->state = READ_DATA;
 1869|  1.30k|  }
 1870|       |
 1871|       |  // Decode.
 1872|  1.30k|  if (!DecodeImageData(dec, dec->pixels, dec->width, dec->height,
  ------------------
  |  Branch (1872:7): [True: 353, False: 955]
  ------------------
 1873|  1.30k|                       io->crop_bottom, ProcessRows)) {
 1874|    353|    goto Err;
 1875|    353|  }
 1876|       |
 1877|    955|  params->last_y = dec->last_out_row;
 1878|    955|  return 1;
 1879|       |
 1880|    353|Err:
 1881|    353|  VP8LClear(dec);
 1882|       |  assert(dec->status != VP8_STATUS_OK);
 1883|    353|  return 0;
 1884|  1.30k|}
vp8l_dec.c:ReadImageInfo:
  115|  8.08k|                         int* const height, int* const has_alpha) {
  116|  8.08k|  if (VP8LReadBits(br, 8) != VP8L_MAGIC_BYTE) return 0;
  ------------------
  |  |   28|  8.08k|#define VP8L_MAGIC_BYTE 0x2f   // VP8L signature byte.
  ------------------
  |  Branch (116:7): [True: 0, False: 8.08k]
  ------------------
  117|  8.08k|  *width = VP8LReadBits(br, VP8L_IMAGE_SIZE_BITS) + 1;
  ------------------
  |  |   30|  8.08k|  14                         // Number of bits used to store width and height.
  ------------------
  118|  8.08k|  *height = VP8LReadBits(br, VP8L_IMAGE_SIZE_BITS) + 1;
  ------------------
  |  |   30|  8.08k|  14                         // Number of bits used to store width and height.
  ------------------
  119|  8.08k|  *has_alpha = VP8LReadBits(br, 1);
  120|  8.08k|  if (VP8LReadBits(br, VP8L_VERSION_BITS) != 0) return 0;
  ------------------
  |  |   31|  8.08k|#define VP8L_VERSION_BITS 3  // 3 bits reserved for version.
  ------------------
  |  Branch (120:7): [True: 0, False: 8.08k]
  ------------------
  121|  8.08k|  return !br->eos;
  122|  8.08k|}
vp8l_dec.c:VP8LSetError:
   94|  2.75k|static int VP8LSetError(VP8LDecoder* const dec, VP8StatusCode error) {
   95|       |  // The oldest error reported takes precedence over the new one.
   96|  2.75k|  if (dec->status == VP8_STATUS_OK || dec->status == VP8_STATUS_SUSPENDED) {
  ------------------
  |  Branch (96:7): [True: 1.28k, False: 1.46k]
  |  Branch (96:39): [True: 0, False: 1.46k]
  ------------------
   97|  1.28k|    dec->status = error;
   98|  1.28k|  }
   99|  2.75k|  return 0;
  100|  2.75k|}
vp8l_dec.c:ReadHuffmanCode:
  313|   881k|                           HuffmanTables* const table) {
  314|   881k|  int ok = 0;
  315|   881k|  int size = 0;
  316|   881k|  VP8LBitReader* const br = &dec->br;
  317|   881k|  const int simple_code = VP8LReadBits(br, 1);
  318|       |
  319|   881k|  WEBP_UNSAFE_MEMSET(code_lengths, 0, alphabet_size * sizeof(*code_lengths));
  ------------------
  |  |  175|   881k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  320|       |
  321|   881k|  if (simple_code) {  // Read symbols, codes & code lengths directly.
  ------------------
  |  Branch (321:7): [True: 880k, False: 1.23k]
  ------------------
  322|   880k|    const int num_symbols = VP8LReadBits(br, 1) + 1;
  323|   880k|    const int first_symbol_len_code = VP8LReadBits(br, 1);
  324|       |    // The first code is either 1 bit or 8 bit code.
  325|   880k|    int symbol = VP8LReadBits(br, (first_symbol_len_code == 0) ? 1 : 8);
  ------------------
  |  Branch (325:35): [True: 878k, False: 1.87k]
  ------------------
  326|   880k|    code_lengths[symbol] = 1;
  327|       |    // The second code (if present), is always 8 bits long.
  328|   880k|    if (num_symbols == 2) {
  ------------------
  |  Branch (328:9): [True: 438k, False: 441k]
  ------------------
  329|   438k|      symbol = VP8LReadBits(br, 8);
  330|   438k|      code_lengths[symbol] = 1;
  331|   438k|    }
  332|   880k|    ok = 1;
  333|   880k|  } else {  // Decode Huffman-coded code lengths.
  334|  1.23k|    int i;
  335|  1.23k|    int code_length_code_lengths[NUM_CODE_LENGTH_CODES] = {0};
  336|  1.23k|    const int num_codes = VP8LReadBits(br, 4) + 4;
  337|  1.23k|    assert(num_codes <= NUM_CODE_LENGTH_CODES);
  338|       |
  339|  11.9k|    for (i = 0; i < num_codes; ++i) {
  ------------------
  |  Branch (339:17): [True: 10.6k, False: 1.23k]
  ------------------
  340|  10.6k|      code_length_code_lengths[kCodeLengthCodeOrder[i]] = VP8LReadBits(br, 3);
  341|  10.6k|    }
  342|  1.23k|    ok = ReadHuffmanCodeLengths(dec, code_length_code_lengths, alphabet_size,
  343|  1.23k|                                code_lengths);
  344|  1.23k|  }
  345|       |
  346|   881k|  ok = ok && !br->eos;
  ------------------
  |  Branch (346:8): [True: 881k, False: 397]
  |  Branch (346:14): [True: 880k, False: 293]
  ------------------
  347|   881k|  if (ok) {
  ------------------
  |  Branch (347:7): [True: 880k, False: 690]
  ------------------
  348|   880k|    const int* WEBP_BIDI_INDEXABLE const bounded_code_lengths =
  349|   880k|        WEBP_UNSAFE_FORGE_BIDI_INDEXABLE(const int*, code_lengths,
  ------------------
  |  |  180|   880k|#define WEBP_UNSAFE_FORGE_BIDI_INDEXABLE(typ, ptr, size) ((typ)(ptr))
  ------------------
  350|   880k|                                         alphabet_size * sizeof(int));
  351|   880k|    size = VP8LBuildHuffmanTable(table, HUFFMAN_TABLE_BITS,
  ------------------
  |  |   29|   880k|#define HUFFMAN_TABLE_BITS 8
  ------------------
  352|   880k|                                 bounded_code_lengths, alphabet_size);
  353|   880k|  }
  354|   881k|  if (!ok || size == 0) {
  ------------------
  |  Branch (354:7): [True: 690, False: 880k]
  |  Branch (354:14): [True: 149, False: 880k]
  ------------------
  355|    839|    return VP8LSetError(dec, VP8_STATUS_BITSTREAM_ERROR);
  356|    839|  }
  357|   880k|  return size;
  358|   881k|}
vp8l_dec.c:ReadHuffmanCodeLengths:
  247|  1.23k|                                  int num_symbols, int* const code_lengths) {
  248|  1.23k|  int ok = 0;
  249|  1.23k|  VP8LBitReader* const br = &dec->br;
  250|  1.23k|  int symbol;
  251|  1.23k|  int max_symbol;
  252|  1.23k|  int prev_code_len = DEFAULT_CODE_LENGTH;
  ------------------
  |  |   40|  1.23k|#define DEFAULT_CODE_LENGTH 8
  ------------------
  253|  1.23k|  HuffmanTables tables;
  254|  1.23k|  const int* WEBP_BIDI_INDEXABLE const bounded_code_lengths =
  255|  1.23k|      WEBP_UNSAFE_FORGE_BIDI_INDEXABLE(
  ------------------
  |  |  180|  1.23k|#define WEBP_UNSAFE_FORGE_BIDI_INDEXABLE(typ, ptr, size) ((typ)(ptr))
  ------------------
  256|  1.23k|          const int*, code_length_code_lengths,
  257|  1.23k|          NUM_CODE_LENGTH_CODES * sizeof(*code_length_code_lengths));
  258|       |
  259|  1.23k|  if (!VP8LHuffmanTablesAllocate(1 << LENGTHS_TABLE_BITS, &tables) ||
  ------------------
  |  |   32|  1.23k|#define LENGTHS_TABLE_BITS 7
  ------------------
  |  Branch (259:7): [True: 0, False: 1.23k]
  ------------------
  260|  1.23k|      !VP8LBuildHuffmanTable(&tables, LENGTHS_TABLE_BITS, bounded_code_lengths,
  ------------------
  |  |   32|  1.23k|#define LENGTHS_TABLE_BITS 7
  ------------------
  |  Branch (260:7): [True: 272, False: 965]
  ------------------
  261|  1.23k|                             NUM_CODE_LENGTH_CODES)) {
  ------------------
  |  |   62|  1.23k|#define NUM_CODE_LENGTH_CODES 19
  ------------------
  262|    272|    goto End;
  263|    272|  }
  264|       |
  265|    965|  if (VP8LReadBits(br, 1)) {  // use length
  ------------------
  |  Branch (265:7): [True: 705, False: 260]
  ------------------
  266|    705|    const int length_nbits = 2 + 2 * VP8LReadBits(br, 3);
  267|    705|    max_symbol = 2 + VP8LReadBits(br, length_nbits);
  268|    705|    if (max_symbol > num_symbols) {
  ------------------
  |  Branch (268:9): [True: 20, False: 685]
  ------------------
  269|     20|      goto End;
  270|     20|    }
  271|    705|  } else {
  272|    260|    max_symbol = num_symbols;
  273|    260|  }
  274|       |
  275|    945|  symbol = 0;
  276|   138k|  while (symbol < num_symbols) {
  ------------------
  |  Branch (276:10): [True: 138k, False: 173]
  ------------------
  277|   138k|    const HuffmanCode* p;
  278|   138k|    int code_len;
  279|   138k|    if (max_symbol-- == 0) break;
  ------------------
  |  Branch (279:9): [True: 667, False: 137k]
  ------------------
  280|   137k|    VP8LFillBitWindow(br);
  281|   137k|    p = &tables.curr_segment->start[VP8LPrefetchBits(br) & LENGTHS_TABLE_MASK];
  ------------------
  |  |   33|   137k|#define LENGTHS_TABLE_MASK ((1 << LENGTHS_TABLE_BITS) - 1)
  |  |  ------------------
  |  |  |  |   32|   137k|#define LENGTHS_TABLE_BITS 7
  |  |  ------------------
  ------------------
  282|   137k|    VP8LSetBitPos(br, br->bit_pos + p->bits);
  283|   137k|    code_len = p->value;
  284|   137k|    if (code_len < kCodeLengthLiterals) {
  ------------------
  |  Branch (284:9): [True: 123k, False: 14.3k]
  ------------------
  285|   123k|      code_lengths[symbol++] = code_len;
  286|   123k|      if (code_len != 0) prev_code_len = code_len;
  ------------------
  |  Branch (286:11): [True: 118k, False: 4.29k]
  ------------------
  287|   123k|    } else {
  288|  14.3k|      const int use_prev = (code_len == kCodeLengthRepeatCode);
  289|  14.3k|      const int slot = code_len - kCodeLengthLiterals;
  290|  14.3k|      const int extra_bits = kCodeLengthExtraBits[slot];
  291|  14.3k|      const int repeat_offset = kCodeLengthRepeatOffsets[slot];
  292|  14.3k|      int repeat = VP8LReadBits(br, extra_bits) + repeat_offset;
  293|  14.3k|      if (symbol + repeat > num_symbols) {
  ------------------
  |  Branch (293:11): [True: 105, False: 14.2k]
  ------------------
  294|    105|        goto End;
  295|  14.2k|      } else {
  296|  14.2k|        const int length = use_prev ? prev_code_len : 0;
  ------------------
  |  Branch (296:28): [True: 4.00k, False: 10.2k]
  ------------------
  297|   178k|        while (repeat-- > 0) code_lengths[symbol++] = length;
  ------------------
  |  Branch (297:16): [True: 164k, False: 14.2k]
  ------------------
  298|  14.2k|      }
  299|  14.3k|    }
  300|   137k|  }
  301|    840|  ok = 1;
  302|       |
  303|  1.23k|End:
  304|  1.23k|  VP8LHuffmanTablesDeallocate(&tables);
  305|  1.23k|  if (!ok) return VP8LSetError(dec, VP8_STATUS_BITSTREAM_ERROR);
  ------------------
  |  Branch (305:7): [True: 397, False: 840]
  ------------------
  306|    840|  return ok;
  307|  1.23k|}
vp8l_dec.c:BuildPackedTable:
  224|  2.73k|static void BuildPackedTable(HTreeGroup* const htree_group) {
  225|  2.73k|  uint32_t code;
  226|   177k|  for (code = 0; code < HUFFMAN_PACKED_TABLE_SIZE; ++code) {
  ------------------
  |  |   74|   177k|#define HUFFMAN_PACKED_TABLE_SIZE (1u << HUFFMAN_PACKED_BITS)
  |  |  ------------------
  |  |  |  |   73|   177k|#define HUFFMAN_PACKED_BITS 6
  |  |  ------------------
  ------------------
  |  Branch (226:18): [True: 174k, False: 2.73k]
  ------------------
  227|   174k|    uint32_t bits = code;
  228|   174k|    HuffmanCode32* const huff = &htree_group->packed_table[bits];
  229|   174k|    HuffmanCode hcode = htree_group->htrees[GREEN][bits];
  230|   174k|    if (hcode.value >= NUM_LITERAL_CODES) {
  ------------------
  |  |   43|   174k|#define NUM_LITERAL_CODES 256
  ------------------
  |  Branch (230:9): [True: 10.5k, False: 164k]
  ------------------
  231|  10.5k|      huff->bits = hcode.bits + BITS_SPECIAL_MARKER;
  ------------------
  |  |  197|  10.5k|#define BITS_SPECIAL_MARKER 0x100  // something large enough (and a bit-mask)
  ------------------
  232|  10.5k|      huff->value = hcode.value;
  233|   164k|    } else {
  234|   164k|      huff->bits = 0;
  235|   164k|      huff->value = 0;
  236|   164k|      bits >>= AccumulateHCode(hcode, 8, huff);
  237|   164k|      bits >>= AccumulateHCode(htree_group->htrees[RED][bits], 16, huff);
  238|   164k|      bits >>= AccumulateHCode(htree_group->htrees[BLUE][bits], 0, huff);
  239|   164k|      bits >>= AccumulateHCode(htree_group->htrees[ALPHA][bits], 24, huff);
  240|   164k|      (void)bits;
  241|   164k|    }
  242|   174k|  }
  243|  2.73k|}
vp8l_dec.c:AccumulateHCode:
  217|   656k|                           HuffmanCode32* const huff) {
  218|   656k|  huff->bits += hcode.bits;
  219|   656k|  huff->value |= (uint32_t)hcode.value << shift;
  220|       |  assert(huff->bits <= HUFFMAN_TABLE_BITS);
  221|   656k|  return hcode.bits;
  222|   656k|}
vp8l_dec.c:VP8LClear:
 1505|  3.56k|static void VP8LClear(VP8LDecoder* const dec) {
 1506|  3.56k|  int i;
 1507|  3.56k|  if (dec == NULL) return;
  ------------------
  |  Branch (1507:7): [True: 0, False: 3.56k]
  ------------------
 1508|  3.56k|  ClearMetadata(&dec->hdr);
 1509|       |
 1510|  3.56k|  WebPSafeFree(dec->pixels);
 1511|  3.56k|  dec->pixels = NULL;
 1512|  4.77k|  for (i = 0; i < dec->next_transform; ++i) {
  ------------------
  |  Branch (1512:15): [True: 1.20k, False: 3.56k]
  ------------------
 1513|  1.20k|    ClearTransform(&dec->transforms[i]);
 1514|  1.20k|  }
 1515|  3.56k|  dec->next_transform = 0;
 1516|  3.56k|  dec->transforms_seen = 0;
 1517|       |
 1518|  3.56k|  WebPSafeFree(dec->rescaler_memory);
 1519|  3.56k|  dec->rescaler_memory = NULL;
 1520|       |
 1521|       |  dec->output = NULL;  // leave no trace behind
 1522|  3.56k|}
vp8l_dec.c:ClearMetadata:
 1478|  6.06k|static void ClearMetadata(VP8LMetadata* const hdr) {
 1479|  6.06k|  assert(hdr != NULL);
 1480|       |
 1481|  6.06k|  WebPSafeFree(hdr->huffman_image);
 1482|  6.06k|  VP8LHuffmanTablesDeallocate(&hdr->huffman_tables);
 1483|  6.06k|  VP8LHtreeGroupsFree(hdr->htree_groups);
 1484|  6.06k|  VP8LColorCacheClear(&hdr->color_cache);
 1485|  6.06k|  VP8LColorCacheClear(&hdr->saved_color_cache);
 1486|  6.06k|  InitMetadata(hdr);
 1487|  6.06k|}
vp8l_dec.c:InitMetadata:
 1473|  6.06k|static void InitMetadata(VP8LMetadata* const hdr) {
 1474|  6.06k|  assert(hdr != NULL);
 1475|  6.06k|  WEBP_UNSAFE_MEMSET(hdr, 0, sizeof(*hdr));
  ------------------
  |  |  175|  6.06k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
 1476|  6.06k|}
vp8l_dec.c:ClearTransform:
 1383|  1.20k|static void ClearTransform(VP8LTransform* const transform) {
 1384|  1.20k|  WebPSafeFree(transform->data);
 1385|       |  transform->data = NULL;
 1386|  1.20k|}
vp8l_dec.c:DecodeImageStream:
 1543|  3.84k|                             uint32_t** const decoded_data) {
 1544|  3.84k|  int ok = 1;
 1545|  3.84k|  int transform_xsize = xsize;
 1546|  3.84k|  int transform_ysize = ysize;
 1547|  3.84k|  VP8LBitReader* const br = &dec->br;
 1548|  3.84k|  VP8LMetadata* const hdr = &dec->hdr;
 1549|  3.84k|  uint32_t* data = NULL;
 1550|  3.84k|  int color_cache_bits = 0;
 1551|       |
 1552|       |  // Read the transforms (may recurse).
 1553|  3.84k|  if (is_level0) {
  ------------------
  |  Branch (1553:7): [True: 2.27k, False: 1.56k]
  ------------------
 1554|  3.49k|    while (ok && VP8LReadBits(br, 1)) {
  ------------------
  |  Branch (1554:12): [True: 3.34k, False: 146]
  |  Branch (1554:18): [True: 1.21k, False: 2.13k]
  ------------------
 1555|  1.21k|      ok = ReadTransform(&transform_xsize, &transform_ysize, dec);
 1556|  1.21k|    }
 1557|  2.27k|  }
 1558|       |
 1559|       |  // Color cache
 1560|  3.84k|  if (ok && VP8LReadBits(br, 1)) {
  ------------------
  |  Branch (1560:7): [True: 3.70k, False: 146]
  |  Branch (1560:13): [True: 608, False: 3.09k]
  ------------------
 1561|    608|    color_cache_bits = VP8LReadBits(br, 4);
 1562|    608|    ok = (color_cache_bits >= 1 && color_cache_bits <= MAX_CACHE_BITS);
  ------------------
  |  |   36|    604|#define MAX_CACHE_BITS 11
  ------------------
  |  Branch (1562:11): [True: 604, False: 4]
  |  Branch (1562:36): [True: 596, False: 8]
  ------------------
 1563|    608|    if (!ok) {
  ------------------
  |  Branch (1563:9): [True: 12, False: 596]
  ------------------
 1564|     12|      VP8LSetError(dec, VP8_STATUS_BITSTREAM_ERROR);
 1565|     12|      goto End;
 1566|     12|    }
 1567|    608|  }
 1568|       |
 1569|       |  // Read the Huffman codes (may recurse).
 1570|  3.83k|  ok = ok && ReadHuffmanCodes(dec, transform_xsize, transform_ysize,
  ------------------
  |  Branch (1570:8): [True: 3.68k, False: 146]
  |  Branch (1570:14): [True: 2.74k, False: 945]
  ------------------
 1571|  3.68k|                              color_cache_bits, is_level0);
 1572|  3.83k|  if (!ok) {
  ------------------
  |  Branch (1572:7): [True: 1.09k, False: 2.74k]
  ------------------
 1573|  1.09k|    VP8LSetError(dec, VP8_STATUS_BITSTREAM_ERROR);
 1574|  1.09k|    goto End;
 1575|  1.09k|  }
 1576|       |
 1577|       |  // Finish setting up the color-cache
 1578|  2.74k|  if (color_cache_bits > 0) {
  ------------------
  |  Branch (1578:7): [True: 338, False: 2.40k]
  ------------------
 1579|    338|    hdr->color_cache_size = 1 << color_cache_bits;
 1580|    338|    if (!VP8LColorCacheInit(&hdr->color_cache, color_cache_bits)) {
  ------------------
  |  Branch (1580:9): [True: 0, False: 338]
  ------------------
 1581|      0|      ok = VP8LSetError(dec, VP8_STATUS_OUT_OF_MEMORY);
 1582|      0|      goto End;
 1583|      0|    }
 1584|  2.40k|  } else {
 1585|  2.40k|    hdr->color_cache_size = 0;
 1586|  2.40k|  }
 1587|  2.74k|  UpdateDecoder(dec, transform_xsize, transform_ysize);
 1588|       |
 1589|  2.74k|  if (is_level0) {  // level 0 complete
  ------------------
  |  Branch (1589:7): [True: 1.34k, False: 1.39k]
  ------------------
 1590|  1.34k|    dec->state = READ_HDR;
 1591|  1.34k|    goto End;
 1592|  1.34k|  }
 1593|       |
 1594|  1.39k|  {
 1595|  1.39k|    const uint64_t total_size = (uint64_t)transform_xsize * transform_ysize;
 1596|  1.39k|    data = (uint32_t*)WebPSafeMalloc(total_size, sizeof(*data));
 1597|  1.39k|    if (data == NULL) {
  ------------------
  |  Branch (1597:9): [True: 0, False: 1.39k]
  ------------------
 1598|      0|      ok = VP8LSetError(dec, VP8_STATUS_OUT_OF_MEMORY);
 1599|      0|      goto End;
 1600|      0|    }
 1601|  1.39k|  }
 1602|       |
 1603|       |  // Use the Huffman trees to decode the LZ77 encoded data.
 1604|  1.39k|  ok = DecodeImageData(dec, data, transform_xsize, transform_ysize,
 1605|  1.39k|                       transform_ysize, NULL);
 1606|  1.39k|  ok = ok && !br->eos;
  ------------------
  |  Branch (1606:8): [True: 1.33k, False: 61]
  |  Branch (1606:14): [True: 1.33k, False: 0]
  ------------------
 1607|       |
 1608|  3.84k|End:
 1609|  3.84k|  if (!ok) {
  ------------------
  |  Branch (1609:7): [True: 1.16k, False: 2.68k]
  ------------------
 1610|  1.16k|    WebPSafeFree(data);
 1611|  1.16k|    ClearMetadata(hdr);
 1612|  2.68k|  } else {
 1613|  2.68k|    if (decoded_data != NULL) {
  ------------------
  |  Branch (1613:9): [True: 1.33k, False: 1.34k]
  ------------------
 1614|  1.33k|      *decoded_data = data;
 1615|  1.34k|    } else {
 1616|       |      // We allocate image data in this function only for transforms. At level 0
 1617|       |      // (that is: not the transforms), we shouldn't have allocated anything.
 1618|  1.34k|      assert(data == NULL);
 1619|  1.34k|      assert(is_level0);
 1620|  1.34k|    }
 1621|  2.68k|    dec->last_pixel = 0;  // Reset for future DECODE_DATA_FUNC() calls.
 1622|  2.68k|    if (!is_level0) ClearMetadata(hdr);  // Clean up temporary data behind.
  ------------------
  |  Branch (1622:9): [True: 1.33k, False: 1.34k]
  ------------------
 1623|  2.68k|  }
 1624|  3.84k|  return ok;
 1625|  1.39k|}
vp8l_dec.c:ReadTransform:
 1415|  1.21k|                         VP8LDecoder* const dec) {
 1416|  1.21k|  int ok = 1;
 1417|  1.21k|  VP8LBitReader* const br = &dec->br;
 1418|  1.21k|  VP8LTransform* transform = &dec->transforms[dec->next_transform];
 1419|  1.21k|  const VP8LImageTransformType type =
 1420|  1.21k|      (VP8LImageTransformType)VP8LReadBits(br, 2);
 1421|       |
 1422|       |  // Each transform type can only be present once in the stream.
 1423|  1.21k|  if (dec->transforms_seen & (1U << type)) {
  ------------------
  |  Branch (1423:7): [True: 3, False: 1.20k]
  ------------------
 1424|      3|    return 0;  // Already there, let's not accept the second same transform.
 1425|      3|  }
 1426|  1.20k|  dec->transforms_seen |= (1U << type);
 1427|       |
 1428|  1.20k|  transform->type = type;
 1429|  1.20k|  transform->xsize = *xsize;
 1430|  1.20k|  transform->ysize = *ysize;
 1431|  1.20k|  transform->data = NULL;
 1432|  1.20k|  ++dec->next_transform;
 1433|  1.20k|  assert(dec->next_transform <= NUM_TRANSFORMS);
 1434|       |
 1435|  1.20k|  switch (type) {
 1436|    625|    case PREDICTOR_TRANSFORM:
  ------------------
  |  Branch (1436:5): [True: 625, False: 584]
  ------------------
 1437|    788|    case CROSS_COLOR_TRANSFORM:
  ------------------
  |  Branch (1437:5): [True: 163, False: 1.04k]
  ------------------
 1438|    788|      transform->bits =
 1439|    788|          MIN_TRANSFORM_BITS + VP8LReadBits(br, NUM_TRANSFORM_BITS);
  ------------------
  |  |   53|    788|#define MIN_TRANSFORM_BITS 2
  ------------------
                        MIN_TRANSFORM_BITS + VP8LReadBits(br, NUM_TRANSFORM_BITS);
  ------------------
  |  |   54|    788|#define NUM_TRANSFORM_BITS 3
  ------------------
 1440|    788|      ok = DecodeImageStream(
 1441|    788|          VP8LSubSampleSize(transform->xsize, transform->bits),
 1442|    788|          VP8LSubSampleSize(transform->ysize, transform->bits),
 1443|    788|          /*is_level0=*/0, dec, &transform->data);
 1444|    788|      break;
 1445|    222|    case COLOR_INDEXING_TRANSFORM: {
  ------------------
  |  Branch (1445:5): [True: 222, False: 987]
  ------------------
 1446|    222|      const int num_colors = VP8LReadBits(br, 8) + 1;
 1447|    222|      const int bits = (num_colors > 16)  ? 0
  ------------------
  |  Branch (1447:24): [True: 77, False: 145]
  ------------------
 1448|    222|                       : (num_colors > 4) ? 1
  ------------------
  |  Branch (1448:26): [True: 45, False: 100]
  ------------------
 1449|    145|                       : (num_colors > 2) ? 2
  ------------------
  |  Branch (1449:26): [True: 47, False: 53]
  ------------------
 1450|    100|                                          : 3;
 1451|    222|      *xsize = VP8LSubSampleSize(transform->xsize, bits);
 1452|    222|      transform->bits = bits;
 1453|    222|      ok = DecodeImageStream(num_colors, /*ysize=*/1, /*is_level0=*/0, dec,
 1454|    222|                             &transform->data);
 1455|    222|      if (ok && !ExpandColorMap(num_colors, transform)) {
  ------------------
  |  Branch (1455:11): [True: 211, False: 11]
  |  Branch (1455:17): [True: 0, False: 211]
  ------------------
 1456|      0|        return VP8LSetError(dec, VP8_STATUS_OUT_OF_MEMORY);
 1457|      0|      }
 1458|    222|      break;
 1459|    222|    }
 1460|    222|    case SUBTRACT_GREEN_TRANSFORM:
  ------------------
  |  Branch (1460:5): [True: 199, False: 1.01k]
  ------------------
 1461|    199|      break;
 1462|      0|    default:
  ------------------
  |  Branch (1462:5): [True: 0, False: 1.20k]
  ------------------
 1463|      0|      assert(0);  // can't happen
 1464|      0|      break;
 1465|  1.20k|  }
 1466|       |
 1467|  1.20k|  return ok;
 1468|  1.20k|}
vp8l_dec.c:ExpandColorMap:
 1390|    211|static int ExpandColorMap(int num_colors, VP8LTransform* const transform) {
 1391|    211|  int i;
 1392|    211|  const int final_num_colors = 1 << (8 >> transform->bits);
 1393|    211|  uint32_t* const new_color_map = (uint32_t*)WebPSafeMalloc(
 1394|    211|      (uint64_t)final_num_colors, sizeof(*new_color_map));
 1395|    211|  if (new_color_map == NULL) {
  ------------------
  |  Branch (1395:7): [True: 0, False: 211]
  ------------------
 1396|      0|    return 0;
 1397|    211|  } else {
 1398|    211|    uint8_t* const data = (uint8_t*)transform->data;
 1399|    211|    uint8_t* const new_data = (uint8_t*)new_color_map;
 1400|    211|    new_color_map[0] = transform->data[0];
 1401|  29.0k|    for (i = 4; i < 4 * num_colors; ++i) {
  ------------------
  |  Branch (1401:17): [True: 28.8k, False: 211]
  ------------------
 1402|       |      // Equivalent to VP8LAddPixels(), on a byte-basis.
 1403|  28.8k|      new_data[i] = (data[i] + new_data[i - 4]) & 0xff;
 1404|  28.8k|    }
 1405|  44.0k|    for (; i < 4 * final_num_colors; ++i) {
  ------------------
  |  Branch (1405:12): [True: 43.8k, False: 211]
  ------------------
 1406|  43.8k|      new_data[i] = 0;  // black tail.
 1407|  43.8k|    }
 1408|    211|    WebPSafeFree(transform->data);
 1409|    211|    transform->data = new_color_map;
 1410|    211|  }
 1411|    211|  return 1;
 1412|    211|}
vp8l_dec.c:ReadHuffmanCodes:
  361|  3.68k|                            int color_cache_bits, int allow_recursion) {
  362|  3.68k|  int i;
  363|  3.68k|  VP8LBitReader* const br = &dec->br;
  364|  3.68k|  VP8LMetadata* const hdr = &dec->hdr;
  365|  3.68k|  uint32_t* huffman_image = NULL;
  366|  3.68k|  HTreeGroup* htree_groups = NULL;
  367|  3.68k|  HuffmanTables* huffman_tables = &hdr->huffman_tables;
  368|  3.68k|  int num_htree_groups = 1;
  369|  3.68k|  int num_htree_groups_max = 1;
  370|  3.68k|  int* mapping = NULL;
  371|  3.68k|  int ok = 0;
  372|       |
  373|       |  // Check the table has been 0 initialized (through InitMetadata).
  374|  3.68k|  assert(huffman_tables->root.start == NULL);
  375|  3.68k|  assert(huffman_tables->curr_segment == NULL);
  376|       |
  377|  3.68k|  if (allow_recursion && VP8LReadBits(br, 1)) {
  ------------------
  |  Branch (377:7): [True: 2.12k, False: 1.56k]
  |  Branch (377:26): [True: 557, False: 1.57k]
  ------------------
  378|       |    // use meta Huffman codes.
  379|    557|    const int huffman_precision =
  380|    557|        MIN_HUFFMAN_BITS + VP8LReadBits(br, NUM_HUFFMAN_BITS);
  ------------------
  |  |   48|    557|#define MIN_HUFFMAN_BITS 2  // min number of Huffman bits
  ------------------
                      MIN_HUFFMAN_BITS + VP8LReadBits(br, NUM_HUFFMAN_BITS);
  ------------------
  |  |   49|    557|#define NUM_HUFFMAN_BITS 3
  ------------------
  381|    557|    const int huffman_xsize = VP8LSubSampleSize(xsize, huffman_precision);
  382|    557|    const int huffman_ysize = VP8LSubSampleSize(ysize, huffman_precision);
  383|    557|    const int huffman_pixs = huffman_xsize * huffman_ysize;
  384|    557|    if (!DecodeImageStream(huffman_xsize, huffman_ysize, /*is_level0=*/0, dec,
  ------------------
  |  Branch (384:9): [True: 89, False: 468]
  ------------------
  385|    557|                           &huffman_image)) {
  386|     89|      goto Error;
  387|     89|    }
  388|    468|    hdr->huffman_subsample_bits = huffman_precision;
  389|   149k|    for (i = 0; i < huffman_pixs; ++i) {
  ------------------
  |  Branch (389:17): [True: 148k, False: 468]
  ------------------
  390|       |      // The huffman data is stored in red and green bytes.
  391|   148k|      const int group = (huffman_image[i] >> 8) & 0xffff;
  392|   148k|      huffman_image[i] = group;
  393|   148k|      if (group >= num_htree_groups_max) {
  ------------------
  |  Branch (393:11): [True: 642, False: 148k]
  ------------------
  394|    642|        num_htree_groups_max = group + 1;
  395|    642|      }
  396|   148k|    }
  397|       |    // Check the validity of num_htree_groups_max. If it seems too big, use a
  398|       |    // smaller value for later. This will prevent big memory allocations to end
  399|       |    // up with a bad bitstream anyway.
  400|       |    // The value of 1000 is totally arbitrary. We know that num_htree_groups_max
  401|       |    // is smaller than (1 << 16) and should be smaller than the number of pixels
  402|       |    // (though the format allows it to be bigger).
  403|    468|    if (num_htree_groups_max > 1000 || num_htree_groups_max > xsize * ysize) {
  ------------------
  |  Branch (403:9): [True: 110, False: 358]
  |  Branch (403:40): [True: 39, False: 319]
  ------------------
  404|       |      // Create a mapping from the used indices to the minimal set of used
  405|       |      // values [0, num_htree_groups)
  406|    149|      mapping = (int*)WebPSafeMalloc(num_htree_groups_max, sizeof(*mapping));
  407|    149|      if (mapping == NULL) {
  ------------------
  |  Branch (407:11): [True: 0, False: 149]
  ------------------
  408|      0|        VP8LSetError(dec, VP8_STATUS_OUT_OF_MEMORY);
  409|      0|        goto Error;
  410|      0|      }
  411|       |      // -1 means a value is unmapped, and therefore unused in the Huffman
  412|       |      // image.
  413|    149|      WEBP_UNSAFE_MEMSET(mapping, 0xff,
  ------------------
  |  |  175|    149|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  414|    149|                         num_htree_groups_max * sizeof(*mapping));
  415|  27.4k|      for (num_htree_groups = 0, i = 0; i < huffman_pixs; ++i) {
  ------------------
  |  Branch (415:41): [True: 27.2k, False: 149]
  ------------------
  416|       |        // Get the current mapping for the group and remap the Huffman image.
  417|  27.2k|        int* const mapped_group = &mapping[huffman_image[i]];
  418|  27.2k|        if (*mapped_group == -1) *mapped_group = num_htree_groups++;
  ------------------
  |  Branch (418:13): [True: 4.31k, False: 22.9k]
  ------------------
  419|  27.2k|        huffman_image[i] = *mapped_group;
  420|  27.2k|      }
  421|    319|    } else {
  422|    319|      num_htree_groups = num_htree_groups_max;
  423|    319|    }
  424|    468|  }
  425|       |
  426|  3.59k|  if (br->eos) goto Error;
  ------------------
  |  Branch (426:7): [True: 17, False: 3.58k]
  ------------------
  427|       |
  428|  3.58k|  if (!ReadHuffmanCodesHelper(color_cache_bits, num_htree_groups,
  ------------------
  |  Branch (428:7): [True: 839, False: 2.74k]
  ------------------
  429|  3.58k|                              num_htree_groups_max, mapping, dec,
  430|  3.58k|                              huffman_tables, &htree_groups)) {
  431|    839|    goto Error;
  432|    839|  }
  433|  2.74k|  ok = 1;
  434|       |
  435|       |  // All OK. Finalize pointers.
  436|  2.74k|  hdr->huffman_image = huffman_image;
  437|  2.74k|  hdr->num_htree_groups = num_htree_groups;
  438|  2.74k|  hdr->htree_groups = htree_groups;
  439|       |
  440|  3.68k|Error:
  441|  3.68k|  WebPSafeFree(mapping);
  442|  3.68k|  if (!ok) {
  ------------------
  |  Branch (442:7): [True: 945, False: 2.74k]
  ------------------
  443|    945|    WebPSafeFree(huffman_image);
  444|    945|    VP8LHuffmanTablesDeallocate(huffman_tables);
  445|    945|    VP8LHtreeGroupsFree(htree_groups);
  446|    945|  }
  447|  3.68k|  return ok;
  448|  2.74k|}
vp8l_dec.c:UpdateDecoder:
 1531|  2.74k|static void UpdateDecoder(VP8LDecoder* const dec, int width, int height) {
 1532|  2.74k|  VP8LMetadata* const hdr = &dec->hdr;
 1533|  2.74k|  const int num_bits = hdr->huffman_subsample_bits;
 1534|  2.74k|  dec->width = width;
 1535|  2.74k|  dec->height = height;
 1536|       |
 1537|  2.74k|  hdr->huffman_xsize = VP8LSubSampleSize(width, num_bits);
 1538|  2.74k|  hdr->huffman_mask = (num_bits == 0) ? ~0 : (1 << num_bits) - 1;
  ------------------
  |  Branch (1538:23): [True: 2.71k, False: 29]
  ------------------
 1539|  2.74k|}
vp8l_dec.c:AllocateInternalBuffers32b:
 1629|  1.30k|static int AllocateInternalBuffers32b(VP8LDecoder* const dec, int final_width) {
 1630|  1.30k|  const uint64_t num_pixels = (uint64_t)dec->width * dec->height;
 1631|       |  // Scratch buffer corresponding to top-prediction row for transforming the
 1632|       |  // first row in the row-blocks. Not needed for paletted alpha.
 1633|  1.30k|  const uint64_t cache_top_pixels = (uint16_t)final_width;
 1634|       |  // Scratch buffer for temporary BGRA storage. Not needed for paletted alpha.
 1635|  1.30k|  const uint64_t cache_pixels = (uint64_t)final_width * NUM_ARGB_CACHE_ROWS;
  ------------------
  |  |   40|  1.30k|#define NUM_ARGB_CACHE_ROWS 16
  ------------------
 1636|       |  // Scratch buffer to accumulate RGBA values (hence 4*)for YUV conversion.
 1637|  1.30k|  uint64_t accumulated_rgb_pixels = 0;
 1638|  1.30k|  uint64_t total_num_pixels;
 1639|  1.30k|  if (dec->output != NULL && !WebPIsRGBMode(dec->output->colorspace)) {
  ------------------
  |  Branch (1639:7): [True: 1.30k, False: 0]
  |  Branch (1639:30): [True: 297, False: 1.01k]
  ------------------
 1640|    297|    const int uv_width = (dec->io->crop_right - dec->io->crop_left + 1) >> 1;
 1641|    297|    accumulated_rgb_pixels =
 1642|    297|        4 * uv_width * sizeof(*dec->accumulated_rgb_pixels) / sizeof(uint32_t);
 1643|    297|  }
 1644|  1.30k|  total_num_pixels =
 1645|  1.30k|      num_pixels + cache_top_pixels + cache_pixels + accumulated_rgb_pixels;
 1646|  1.30k|  assert(dec->width <= final_width);
 1647|  1.30k|  dec->pixels = (uint32_t*)WebPSafeMalloc(total_num_pixels, sizeof(uint32_t));
 1648|  1.30k|  if (dec->pixels == NULL) {
  ------------------
  |  Branch (1648:7): [True: 0, False: 1.30k]
  ------------------
 1649|      0|    dec->argb_cache = NULL;  // for soundness
 1650|      0|    return VP8LSetError(dec, VP8_STATUS_OUT_OF_MEMORY);
 1651|      0|  }
 1652|  1.30k|  dec->argb_cache = dec->pixels + num_pixels + cache_top_pixels;
 1653|  1.30k|  dec->accumulated_rgb_pixels =
 1654|  1.30k|      accumulated_rgb_pixels == 0
  ------------------
  |  Branch (1654:7): [True: 1.01k, False: 297]
  ------------------
 1655|  1.30k|          ? NULL
 1656|  1.30k|          : (uint16_t*)(dec->pixels + num_pixels + cache_top_pixels +
 1657|    297|                        cache_pixels);
 1658|       |
 1659|  1.30k|  return 1;
 1660|  1.30k|}
vp8l_dec.c:GetHtreeGroupForPos:
  836|  1.03M|                                                   int x, int y) {
  837|  1.03M|  const int meta_index = GetMetaIndex(hdr->huffman_image, hdr->huffman_xsize,
  838|  1.03M|                                      hdr->huffman_subsample_bits, x, y);
  839|       |  assert(meta_index < hdr->num_htree_groups);
  840|  1.03M|  return hdr->htree_groups + meta_index;
  841|  1.03M|}
vp8l_dec.c:GetMetaIndex:
  830|  1.03M|                                    int bits, int x, int y) {
  831|  1.03M|  if (bits == 0) return 0;
  ------------------
  |  Branch (831:7): [True: 997k, False: 34.0k]
  ------------------
  832|  34.0k|  return image[xsize * (y >> bits) + (x >> bits)];
  833|  1.03M|}
vp8l_dec.c:ReadSymbol:
  181|  3.42M|                                  VP8LBitReader* const br) {
  182|  3.42M|  int nbits;
  183|  3.42M|  uint32_t val = VP8LPrefetchBits(br);
  184|  3.42M|  table += val & HUFFMAN_TABLE_MASK;
  ------------------
  |  |   30|  3.42M|#define HUFFMAN_TABLE_MASK ((1 << HUFFMAN_TABLE_BITS) - 1)
  |  |  ------------------
  |  |  |  |   29|  3.42M|#define HUFFMAN_TABLE_BITS 8
  |  |  ------------------
  ------------------
  185|  3.42M|  nbits = table->bits - HUFFMAN_TABLE_BITS;
  ------------------
  |  |   29|  3.42M|#define HUFFMAN_TABLE_BITS 8
  ------------------
  186|  3.42M|  if (nbits > 0) {
  ------------------
  |  Branch (186:7): [True: 178k, False: 3.25M]
  ------------------
  187|   178k|    VP8LSetBitPos(br, br->bit_pos + HUFFMAN_TABLE_BITS);
  ------------------
  |  |   29|   178k|#define HUFFMAN_TABLE_BITS 8
  ------------------
  188|   178k|    val = VP8LPrefetchBits(br);
  189|   178k|    table += table->value;
  190|   178k|    table += val & ((1 << nbits) - 1);
  191|   178k|  }
  192|  3.42M|  VP8LSetBitPos(br, br->bit_pos + table->bits);
  193|  3.42M|  return table->value;
  194|  3.42M|}
vp8l_dec.c:GetCopyLength:
  159|  35.5k|                                     VP8LBitReader* const br) {
  160|       |  // Length and distance prefixes are encoded the same way.
  161|  35.5k|  return GetCopyDistance(length_symbol, br);
  162|  35.5k|}
vp8l_dec.c:GetCopyDistance:
  148|  71.0k|                                       VP8LBitReader* const br) {
  149|  71.0k|  int extra_bits, offset;
  150|  71.0k|  if (distance_symbol < 4) {
  ------------------
  |  Branch (150:7): [True: 49.2k, False: 21.7k]
  ------------------
  151|  49.2k|    return distance_symbol + 1;
  152|  49.2k|  }
  153|  21.7k|  extra_bits = (distance_symbol - 2) >> 1;
  154|  21.7k|  offset = (2 + (distance_symbol & 1)) << extra_bits;
  155|  21.7k|  return offset + VP8LReadBits(br, extra_bits) + 1;
  156|  71.0k|}
vp8l_dec.c:PlaneCodeToDistance:
  164|  35.5k|static WEBP_INLINE int PlaneCodeToDistance(int xsize, int plane_code) {
  165|  35.5k|  if (plane_code > CODE_TO_PLANE_CODES) {
  ------------------
  |  |   66|  35.5k|#define CODE_TO_PLANE_CODES 120
  ------------------
  |  Branch (165:7): [True: 1.65k, False: 33.8k]
  ------------------
  166|  1.65k|    return plane_code - CODE_TO_PLANE_CODES;
  ------------------
  |  |   66|  1.65k|#define CODE_TO_PLANE_CODES 120
  ------------------
  167|  33.8k|  } else {
  168|  33.8k|    const int dist_code = kCodeToPlane[plane_code - 1];
  169|  33.8k|    const int yoffset = dist_code >> 4;
  170|  33.8k|    const int xoffset = 8 - (dist_code & 0xf);
  171|  33.8k|    const int dist = yoffset * xsize + xoffset;
  172|  33.8k|    return (dist >= 1) ? dist : 1;  // dist<1 can happen if xsize is very small
  ------------------
  |  Branch (172:12): [True: 33.6k, False: 217]
  ------------------
  173|  33.8k|  }
  174|  35.5k|}
vp8l_dec.c:DecodeImageData:
 1223|  2.70k|                           ProcessRowsFunc process_func) {
 1224|  2.70k|  int row = dec->last_pixel / width;
 1225|  2.70k|  int col = dec->last_pixel % width;
 1226|  2.70k|  VP8LBitReader* const br = &dec->br;
 1227|  2.70k|  VP8LMetadata* const hdr = &dec->hdr;
 1228|  2.70k|  uint32_t* src = data + dec->last_pixel;
 1229|  2.70k|  uint32_t* last_cached = src;
 1230|  2.70k|  uint32_t* const src_end = data + width * height;     // End of data
 1231|  2.70k|  uint32_t* const src_last = data + width * last_row;  // Last pixel to decode
 1232|  2.70k|  const int len_code_limit = NUM_LITERAL_CODES + NUM_LENGTH_CODES;
  ------------------
  |  |   43|  2.70k|#define NUM_LITERAL_CODES 256
  ------------------
                const int len_code_limit = NUM_LITERAL_CODES + NUM_LENGTH_CODES;
  ------------------
  |  |   44|  2.70k|#define NUM_LENGTH_CODES 24
  ------------------
 1233|  2.70k|  const int color_cache_limit = len_code_limit + hdr->color_cache_size;
 1234|  2.70k|  int next_sync_row = dec->incremental ? row : 1 << 24;
  ------------------
  |  Branch (1234:23): [True: 0, False: 2.70k]
  ------------------
 1235|  2.70k|  VP8LColorCache* const color_cache =
 1236|  2.70k|      (hdr->color_cache_size > 0) ? &hdr->color_cache : NULL;
  ------------------
  |  Branch (1236:7): [True: 332, False: 2.37k]
  ------------------
 1237|  2.70k|  const int mask = hdr->huffman_mask;
 1238|  2.70k|  const HTreeGroup* htree_group =
 1239|  2.70k|      (src < src_last) ? GetHtreeGroupForPos(hdr, col, row) : NULL;
  ------------------
  |  Branch (1239:7): [True: 2.70k, False: 0]
  ------------------
 1240|  2.70k|  assert(dec->last_row < last_row);
 1241|  2.70k|  assert(src_last <= src_end);
 1242|       |
 1243|  18.6M|  while (src < src_last) {
  ------------------
  |  Branch (1243:10): [True: 18.6M, False: 2.29k]
  ------------------
 1244|  18.6M|    int code;
 1245|  18.6M|    if (row >= next_sync_row) {
  ------------------
  |  Branch (1245:9): [True: 0, False: 18.6M]
  ------------------
 1246|      0|      SaveState(dec, (int)(src - data));
 1247|      0|      next_sync_row = row + SYNC_EVERY_N_ROWS;
  ------------------
  |  | 1220|      0|#define SYNC_EVERY_N_ROWS 8  // minimum number of rows between check-points
  ------------------
 1248|      0|    }
 1249|       |    // Only update when changing tile. Note we could use this test:
 1250|       |    // if "((((prev_col ^ col) | prev_row ^ row)) > mask)" -> tile changed
 1251|       |    // but that's actually slower and needs storing the previous col/row.
 1252|  18.6M|    if ((col & mask) == 0) {
  ------------------
  |  Branch (1252:9): [True: 1.00M, False: 17.6M]
  ------------------
 1253|  1.00M|      htree_group = GetHtreeGroupForPos(hdr, col, row);
 1254|  1.00M|    }
 1255|  18.6M|    assert(htree_group != NULL);
 1256|  18.6M|    if (htree_group->is_trivial_code) {
  ------------------
  |  Branch (1256:9): [True: 16.7M, False: 1.90M]
  ------------------
 1257|  16.7M|      *src = htree_group->literal_arb;
 1258|  16.7M|      goto AdvanceByOne;
 1259|  16.7M|    }
 1260|  1.90M|    VP8LFillBitWindow(br);
 1261|  1.90M|    if (htree_group->use_packed_table) {
  ------------------
  |  Branch (1261:9): [True: 835k, False: 1.06M]
  ------------------
 1262|   835k|      code = ReadPackedSymbols(htree_group, br, src);
 1263|   835k|      if (VP8LIsEndOfStream(br)) break;
  ------------------
  |  Branch (1263:11): [True: 194, False: 835k]
  ------------------
 1264|   835k|      if (code == PACKED_NON_LITERAL_CODE) goto AdvanceByOne;
  ------------------
  |  |  198|   835k|#define PACKED_NON_LITERAL_CODE 0  // must be < NUM_LITERAL_CODES
  ------------------
  |  Branch (1264:11): [True: 732k, False: 102k]
  ------------------
 1265|  1.06M|    } else {
 1266|  1.06M|      code = ReadSymbol(htree_group->htrees[GREEN], br);
 1267|  1.06M|    }
 1268|  1.16M|    if (code < NUM_LITERAL_CODES) {  // Literal
  ------------------
  |  |   43|  1.16M|#define NUM_LITERAL_CODES 256
  ------------------
  |  Branch (1268:9): [True: 1.00M, False: 164k]
  ------------------
 1269|  1.00M|      if (htree_group->is_trivial_literal) {
  ------------------
  |  Branch (1269:11): [True: 228k, False: 775k]
  ------------------
 1270|   228k|        if (VP8LIsEndOfStream(br)) break;
  ------------------
  |  Branch (1270:13): [True: 26, False: 228k]
  ------------------
 1271|   228k|        *src = htree_group->literal_arb | (code << 8);
 1272|   775k|      } else {
 1273|   775k|        int red, blue, alpha;
 1274|   775k|        red = ReadSymbol(htree_group->htrees[RED], br);
 1275|   775k|        VP8LFillBitWindow(br);
 1276|   775k|        blue = ReadSymbol(htree_group->htrees[BLUE], br);
 1277|   775k|        alpha = ReadSymbol(htree_group->htrees[ALPHA], br);
 1278|   775k|        if (VP8LIsEndOfStream(br)) break;
  ------------------
  |  Branch (1278:13): [True: 68, False: 775k]
  ------------------
 1279|   775k|        *src = ((uint32_t)alpha << 24) | (red << 16) | (code << 8) | blue;
 1280|   775k|      }
 1281|  18.6M|    AdvanceByOne:
 1282|  18.6M|      ++src;
 1283|  18.6M|      ++col;
 1284|  18.6M|      if (col >= width) {
  ------------------
  |  Branch (1284:11): [True: 972k, False: 17.6M]
  ------------------
 1285|   972k|        col = 0;
 1286|   972k|        ++row;
 1287|   972k|        if (process_func != NULL) {
  ------------------
  |  Branch (1287:13): [True: 925k, False: 46.2k]
  ------------------
 1288|   925k|          if (row <= last_row) {
  ------------------
  |  Branch (1288:15): [True: 925k, False: 0]
  ------------------
 1289|   925k|            process_func(dec, row, /*wait_for_biggest_batch=*/1);
 1290|   925k|          }
 1291|   925k|        }
 1292|   972k|        if (color_cache != NULL) {
  ------------------
  |  Branch (1292:13): [True: 133k, False: 838k]
  ------------------
 1293|  1.48M|          while (last_cached < src) {
  ------------------
  |  Branch (1293:18): [True: 1.35M, False: 133k]
  ------------------
 1294|  1.35M|            VP8LColorCacheInsert(color_cache, *last_cached++);
 1295|  1.35M|          }
 1296|   133k|        }
 1297|   972k|      }
 1298|  18.6M|    } else if (code < len_code_limit) {  // Backward reference
  ------------------
  |  Branch (1298:16): [True: 35.5k, False: 128k]
  ------------------
 1299|  35.5k|      int dist_code, dist;
 1300|  35.5k|      const int length_sym = code - NUM_LITERAL_CODES;
  ------------------
  |  |   43|  35.5k|#define NUM_LITERAL_CODES 256
  ------------------
 1301|  35.5k|      const int length = GetCopyLength(length_sym, br);
 1302|  35.5k|      const int dist_symbol = ReadSymbol(htree_group->htrees[DIST], br);
 1303|  35.5k|      VP8LFillBitWindow(br);
 1304|  35.5k|      dist_code = GetCopyDistance(dist_symbol, br);
 1305|  35.5k|      dist = PlaneCodeToDistance(width, dist_code);
 1306|       |
 1307|  35.5k|      if (VP8LIsEndOfStream(br)) break;
  ------------------
  |  Branch (1307:11): [True: 93, False: 35.4k]
  ------------------
 1308|  35.4k|      if (src - data < (ptrdiff_t)dist || src_end - src < (ptrdiff_t)length) {
  ------------------
  |  Branch (1308:11): [True: 11, False: 35.4k]
  |  Branch (1308:43): [True: 13, False: 35.4k]
  ------------------
 1309|     24|        goto Error;
 1310|  35.4k|      } else {
 1311|  35.4k|        CopyBlock32b(src, dist, length);
 1312|  35.4k|      }
 1313|  35.4k|      src += length;
 1314|  35.4k|      col += length;
 1315|  97.3k|      while (col >= width) {
  ------------------
  |  Branch (1315:14): [True: 61.9k, False: 35.4k]
  ------------------
 1316|  61.9k|        col -= width;
 1317|  61.9k|        ++row;
 1318|  61.9k|        if (process_func != NULL) {
  ------------------
  |  Branch (1318:13): [True: 59.3k, False: 2.57k]
  ------------------
 1319|  59.3k|          if (row <= last_row) {
  ------------------
  |  Branch (1319:15): [True: 59.3k, False: 0]
  ------------------
 1320|  59.3k|            process_func(dec, row, /*wait_for_biggest_batch=*/1);
 1321|  59.3k|          }
 1322|  59.3k|        }
 1323|  61.9k|      }
 1324|       |      // Because of the check done above (before 'src' was incremented by
 1325|       |      // 'length'), the following holds true.
 1326|  35.4k|      assert(src <= src_end);
 1327|  35.4k|      if (col & mask) htree_group = GetHtreeGroupForPos(hdr, col, row);
  ------------------
  |  Branch (1327:11): [True: 23.2k, False: 12.1k]
  ------------------
 1328|  35.4k|      if (color_cache != NULL) {
  ------------------
  |  Branch (1328:11): [True: 17.2k, False: 18.1k]
  ------------------
 1329|   499k|        while (last_cached < src) {
  ------------------
  |  Branch (1329:16): [True: 481k, False: 17.2k]
  ------------------
 1330|   481k|          VP8LColorCacheInsert(color_cache, *last_cached++);
 1331|   481k|        }
 1332|  17.2k|      }
 1333|   128k|    } else if (code < color_cache_limit) {  // Color cache
  ------------------
  |  Branch (1333:16): [True: 128k, False: 0]
  ------------------
 1334|   128k|      const int key = code - len_code_limit;
 1335|   128k|      assert(color_cache != NULL);
 1336|   128k|      if (VP8LIsEndOfStream(br)) break;
  ------------------
  |  Branch (1336:11): [True: 9, False: 128k]
  ------------------
 1337|   518k|      while (last_cached < src) {
  ------------------
  |  Branch (1337:14): [True: 389k, False: 128k]
  ------------------
 1338|   389k|        VP8LColorCacheInsert(color_cache, *last_cached++);
 1339|   389k|      }
 1340|   128k|      *src = VP8LColorCacheLookup(color_cache, key);
 1341|   128k|      goto AdvanceByOne;
 1342|   128k|    } else {  // Not reached
 1343|      0|      goto Error;
 1344|      0|    }
 1345|  1.16M|  }
 1346|       |
 1347|  2.68k|  br->eos = VP8LIsEndOfStream(br);
 1348|       |  // In incremental decoding:
 1349|       |  // br->eos && src < src_last: if 'br' reached the end of the buffer and
 1350|       |  // 'src_last' has not been reached yet, there is not enough data. 'dec' has to
 1351|       |  // be reset until there is more data.
 1352|       |  // !br->eos && src < src_last: this cannot happen as either the buffer is
 1353|       |  // fully read, either enough has been read to reach 'src_last'.
 1354|       |  // src >= src_last: 'src_last' is reached, all is fine. 'src' can actually go
 1355|       |  // beyond 'src_last' in case the image is cropped and an LZ77 goes further.
 1356|       |  // The buffer might have been enough or there is some left. 'br->eos' does
 1357|       |  // not matter.
 1358|  2.68k|  assert(!dec->incremental || (br->eos && src < src_last) || src >= src_last);
 1359|  2.68k|  if (dec->incremental && br->eos && src < src_last) {
  ------------------
  |  Branch (1359:7): [True: 0, False: 2.68k]
  |  Branch (1359:27): [True: 0, False: 0]
  |  Branch (1359:38): [True: 0, False: 0]
  ------------------
 1360|      0|    RestoreState(dec);
 1361|  2.68k|  } else if ((dec->incremental && src >= src_last) || !br->eos) {
  ------------------
  |  Branch (1361:15): [True: 0, False: 2.68k]
  |  Branch (1361:35): [True: 0, False: 0]
  |  Branch (1361:55): [True: 2.29k, False: 390]
  ------------------
 1362|       |    // Process the remaining rows corresponding to last row-block.
 1363|  2.29k|    if (process_func != NULL) {
  ------------------
  |  Branch (1363:9): [True: 955, False: 1.33k]
  ------------------
 1364|    955|      process_func(dec, row > last_row ? last_row : row,
  ------------------
  |  Branch (1364:25): [True: 0, False: 955]
  ------------------
 1365|    955|                   /*wait_for_biggest_batch=*/0);
 1366|    955|    }
 1367|  2.29k|    dec->status = VP8_STATUS_OK;
 1368|  2.29k|    dec->last_pixel = (int)(src - data);  // end-of-scan marker
 1369|  2.29k|  } else {
 1370|       |    // if not incremental, and we are past the end of buffer (eos=1), then this
 1371|       |    // is a real bitstream error.
 1372|    390|    goto Error;
 1373|    390|  }
 1374|  2.29k|  return 1;
 1375|       |
 1376|    414|Error:
 1377|    414|  return VP8LSetError(dec, VP8_STATUS_BITSTREAM_ERROR);
 1378|  2.68k|}
vp8l_dec.c:ReadPackedSymbols:
  201|   835k|                                         uint32_t* const dst) {
  202|   835k|  const uint32_t val = VP8LPrefetchBits(br) & (HUFFMAN_PACKED_TABLE_SIZE - 1);
  ------------------
  |  |   74|   835k|#define HUFFMAN_PACKED_TABLE_SIZE (1u << HUFFMAN_PACKED_BITS)
  |  |  ------------------
  |  |  |  |   73|   835k|#define HUFFMAN_PACKED_BITS 6
  |  |  ------------------
  ------------------
  203|   835k|  const HuffmanCode32 code = group->packed_table[val];
  204|   835k|  assert(group->use_packed_table);
  205|   835k|  if (code.bits < BITS_SPECIAL_MARKER) {
  ------------------
  |  |  197|   835k|#define BITS_SPECIAL_MARKER 0x100  // something large enough (and a bit-mask)
  ------------------
  |  Branch (205:7): [True: 732k, False: 102k]
  ------------------
  206|   732k|    VP8LSetBitPos(br, br->bit_pos + code.bits);
  207|   732k|    *dst = code.value;
  208|   732k|    return PACKED_NON_LITERAL_CODE;
  ------------------
  |  |  198|   732k|#define PACKED_NON_LITERAL_CODE 0  // must be < NUM_LITERAL_CODES
  ------------------
  209|   732k|  } else {
  210|   102k|    VP8LSetBitPos(br, br->bit_pos + code.bits - BITS_SPECIAL_MARKER);
  ------------------
  |  |  197|   102k|#define BITS_SPECIAL_MARKER 0x100  // something large enough (and a bit-mask)
  ------------------
  211|       |    assert(code.value >= NUM_LITERAL_CODES);
  212|   102k|    return code.value;
  213|   102k|  }
  214|   835k|}
vp8l_dec.c:CopyBlock32b:
 1095|  35.4k|                                     int length) {
 1096|  35.4k|  const uint32_t* const src = dst - dist;
 1097|  35.4k|  if (dist <= 2 && length >= 4 && ((uintptr_t)dst & 3) == 0) {
  ------------------
  |  Branch (1097:7): [True: 23.4k, False: 12.0k]
  |  Branch (1097:20): [True: 16.5k, False: 6.81k]
  |  Branch (1097:35): [True: 16.5k, False: 0]
  ------------------
 1098|  16.5k|    uint64_t pattern;
 1099|  16.5k|    if (dist == 1) {
  ------------------
  |  Branch (1099:9): [True: 14.4k, False: 2.17k]
  ------------------
 1100|  14.4k|      pattern = (uint64_t)src[0];
 1101|  14.4k|      pattern |= pattern << 32;
 1102|  14.4k|    } else {
 1103|  2.17k|      WEBP_UNSAFE_MEMCPY(&pattern, src, sizeof(pattern));
  ------------------
  |  |  174|  2.17k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
 1104|  2.17k|    }
 1105|  16.5k|    CopySmallPattern32b(src, dst, length, pattern);
 1106|  18.8k|  } else if (dist >= length) {  // no overlap
  ------------------
  |  Branch (1106:14): [True: 13.3k, False: 5.44k]
  ------------------
 1107|  13.3k|    WEBP_UNSAFE_MEMCPY(dst, src, length * sizeof(*dst));
  ------------------
  |  |  174|  13.3k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
 1108|  13.3k|  } else {
 1109|  5.44k|    int i;
 1110|   106k|    for (i = 0; i < length; ++i) dst[i] = src[i];
  ------------------
  |  Branch (1110:17): [True: 101k, False: 5.44k]
  ------------------
 1111|  5.44k|  }
 1112|  35.4k|}
vp8l_dec.c:CopySmallPattern32b:
 1078|  16.5k|                                            int length, uint64_t pattern) {
 1079|  16.5k|  int i;
 1080|  16.5k|  if ((uintptr_t)dst & 4) {  // Align 'dst' to 8-bytes boundary.
  ------------------
  |  Branch (1080:7): [True: 7.79k, False: 8.79k]
  ------------------
 1081|  7.79k|    *dst++ = *src++;
 1082|  7.79k|    pattern = (pattern >> 32) | (pattern << 32);
 1083|  7.79k|    --length;
 1084|  7.79k|  }
 1085|  16.5k|  assert(0 == ((uintptr_t)dst & 7));
 1086|   602k|  for (i = 0; i < (length >> 1); ++i) {
  ------------------
  |  Branch (1086:15): [True: 585k, False: 16.5k]
  ------------------
 1087|   585k|    ((uint64_t*)dst)[i] = pattern;  // Copy the pattern 8 bytes at a time.
 1088|   585k|  }
 1089|  16.5k|  if (length & 1) {  // Finish with left-over.
  ------------------
  |  Branch (1089:7): [True: 7.73k, False: 8.84k]
  ------------------
 1090|  7.73k|    dst[i << 1] = src[i << 1];
 1091|  7.73k|  }
 1092|  16.5k|}
vp8l_dec.c:ApplyInverseTransforms:
  852|  62.1k|                                   int num_rows, const uint32_t* const rows) {
  853|  62.1k|  int n = dec->next_transform;
  854|  62.1k|  const int cache_pixs = dec->width * num_rows;
  855|  62.1k|  const int end_row = start_row + num_rows;
  856|  62.1k|  const uint32_t* rows_in = rows;
  857|  62.1k|  uint32_t* const rows_out = dec->argb_cache;
  858|       |
  859|       |  // Inverse transforms.
  860|   114k|  while (n-- > 0) {
  ------------------
  |  Branch (860:10): [True: 52.1k, False: 62.1k]
  ------------------
  861|  52.1k|    VP8LTransform* const transform = &dec->transforms[n];
  862|  52.1k|    VP8LInverseTransform(transform, start_row, end_row, rows_in, rows_out);
  863|  52.1k|    rows_in = rows_out;
  864|  52.1k|  }
  865|  62.1k|  if (rows_in != rows_out) {
  ------------------
  |  Branch (865:7): [True: 17.0k, False: 45.0k]
  ------------------
  866|       |    // No transform called, hence just copy.
  867|  17.0k|    WEBP_UNSAFE_MEMCPY(rows_out, rows_in, cache_pixs * sizeof(*rows_out));
  ------------------
  |  |  174|  17.0k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
  868|  17.0k|  }
  869|  62.1k|}
vp8l_dec.c:ProcessRows:
  874|   986k|                        int wait_for_biggest_batch) {
  875|   986k|  const uint32_t* const rows = dec->pixels + dec->width * dec->last_row;
  876|   986k|  int num_rows;
  877|       |
  878|       |  // In case of YUV conversion and if we do not need to get to the last row.
  879|   986k|  if (wait_for_biggest_batch) {
  ------------------
  |  Branch (879:7): [True: 985k, False: 955]
  ------------------
  880|       |    // In case of YUV conversion, and if we do not use the whole cropping
  881|       |    // region.
  882|   985k|    if (!WebPIsRGBMode(dec->output->colorspace) && row >= dec->io->crop_top &&
  ------------------
  |  Branch (882:9): [True: 220k, False: 764k]
  |  Branch (882:52): [True: 220k, False: 0]
  ------------------
  883|   220k|        row < dec->io->crop_bottom) {
  ------------------
  |  Branch (883:9): [True: 220k, False: 222]
  ------------------
  884|       |      // Make sure the number of rows to process is even.
  885|   220k|      if ((row - dec->io->crop_top) % 2 != 0) return;
  ------------------
  |  Branch (885:11): [True: 110k, False: 110k]
  ------------------
  886|       |      // Make sure the cache is as full as possible.
  887|   110k|      if (row % NUM_ARGB_CACHE_ROWS != 0 &&
  ------------------
  |  |   40|   110k|#define NUM_ARGB_CACHE_ROWS 16
  ------------------
  |  Branch (887:11): [True: 96.5k, False: 13.7k]
  ------------------
  888|  96.5k|          (row + 1) % NUM_ARGB_CACHE_ROWS != 0) {
  ------------------
  |  |   40|  96.5k|#define NUM_ARGB_CACHE_ROWS 16
  ------------------
  |  Branch (888:11): [True: 96.5k, False: 0]
  ------------------
  889|  96.5k|        return;
  890|  96.5k|      }
  891|   764k|    } else {
  892|   764k|      if (row % NUM_ARGB_CACHE_ROWS != 0) return;
  ------------------
  |  |   40|   764k|#define NUM_ARGB_CACHE_ROWS 16
  ------------------
  |  Branch (892:11): [True: 717k, False: 47.4k]
  ------------------
  893|   764k|    }
  894|   985k|  }
  895|  62.1k|  num_rows = row - dec->last_row;
  896|  62.1k|  assert(row <= dec->io->crop_bottom);
  897|       |  // We can't process more than NUM_ARGB_CACHE_ROWS at a time (that's the size
  898|       |  // of argb_cache), but we currently don't need more than that.
  899|  62.1k|  assert(num_rows <= NUM_ARGB_CACHE_ROWS);
  900|  62.1k|  if (num_rows > 0) {  // Emit output.
  ------------------
  |  Branch (900:7): [True: 62.1k, False: 13]
  ------------------
  901|  62.1k|    VP8Io* const io = dec->io;
  902|  62.1k|    uint8_t* rows_data = (uint8_t*)dec->argb_cache;
  903|  62.1k|    const int in_stride = io->width * sizeof(uint32_t);  // in unit of RGBA
  904|  62.1k|    ApplyInverseTransforms(dec, dec->last_row, num_rows, rows);
  905|  62.1k|    if (!SetCropWindow(io, dec->last_row, row, &rows_data, in_stride)) {
  ------------------
  |  Branch (905:9): [True: 0, False: 62.1k]
  ------------------
  906|       |      // Nothing to output (this time).
  907|  62.1k|    } else {
  908|  62.1k|      const WebPDecBuffer* const output = dec->output;
  909|  62.1k|      if (WebPIsRGBMode(output->colorspace)) {  // convert to RGBA
  ------------------
  |  Branch (909:11): [True: 48.2k, False: 13.9k]
  ------------------
  910|  48.2k|        const WebPRGBABuffer* const buf = &output->u.RGBA;
  911|  48.2k|        uint8_t* const rgba =
  912|  48.2k|            buf->rgba + (ptrdiff_t)dec->last_out_row * buf->stride;
  913|  48.2k|        const int num_rows_out =
  914|  48.2k|#if !defined(WEBP_REDUCE_SIZE)
  915|  48.2k|            io->use_scaling ? EmitRescaledRowsRGBA(dec, rows_data, in_stride,
  ------------------
  |  Branch (915:13): [True: 0, False: 48.2k]
  ------------------
  916|      0|                                                   io->mb_h, rgba, buf->stride)
  917|  48.2k|                            :
  918|  48.2k|#endif  // WEBP_REDUCE_SIZE
  919|  48.2k|                            EmitRows(output->colorspace, rows_data, in_stride,
  920|  48.2k|                                     io->mb_w, io->mb_h, rgba, buf->stride);
  921|       |        // Update 'last_out_row'.
  922|  48.2k|        dec->last_out_row += num_rows_out;
  923|  48.2k|      } else {  // convert to YUVA
  924|  13.9k|        dec->last_out_row =
  925|  13.9k|            io->use_scaling
  ------------------
  |  Branch (925:13): [True: 0, False: 13.9k]
  ------------------
  926|  13.9k|                ? EmitRescaledRowsYUVA(dec, rows_data, in_stride, io->mb_h)
  927|  13.9k|                : EmitRowsYUVA(rows_data, io, in_stride,
  928|  13.9k|                               dec->accumulated_rgb_pixels, dec);
  929|  13.9k|      }
  930|  62.1k|      assert(dec->last_out_row <= output->height);
  931|  62.1k|    }
  932|  62.1k|  }
  933|       |
  934|       |  // Update 'last_row'.
  935|  62.1k|  dec->last_row = row;
  936|       |  assert(dec->last_row <= dec->height);
  937|  62.1k|}
vp8l_dec.c:SetCropWindow:
  806|  62.1k|                         uint8_t** const in_data, int pixel_stride) {
  807|  62.1k|  assert(y_start < y_end);
  808|  62.1k|  assert(io->crop_left < io->crop_right);
  809|  62.1k|  if (y_end > io->crop_bottom) {
  ------------------
  |  Branch (809:7): [True: 0, False: 62.1k]
  ------------------
  810|      0|    y_end = io->crop_bottom;  // make sure we don't overflow on last row.
  811|      0|  }
  812|  62.1k|  if (y_start < io->crop_top) {
  ------------------
  |  Branch (812:7): [True: 0, False: 62.1k]
  ------------------
  813|      0|    const int delta = io->crop_top - y_start;
  814|      0|    y_start = io->crop_top;
  815|      0|    *in_data += (ptrdiff_t)delta * pixel_stride;
  816|      0|  }
  817|  62.1k|  if (y_start >= y_end) return 0;  // Crop window is empty.
  ------------------
  |  Branch (817:7): [True: 0, False: 62.1k]
  ------------------
  818|       |
  819|  62.1k|  *in_data += io->crop_left * sizeof(uint32_t);
  820|       |
  821|  62.1k|  io->mb_y = y_start - io->crop_top;
  822|  62.1k|  io->mb_w = io->crop_right - io->crop_left;
  823|  62.1k|  io->mb_h = y_end - y_start;
  824|  62.1k|  return 1;  // Non-empty crop window.
  825|  62.1k|}
vp8l_dec.c:EmitRows:
  654|  48.2k|                    int out_stride) {
  655|  48.2k|  int lines = mb_h;
  656|  48.2k|  uint8_t* row_out = out;
  657|   811k|  while (lines-- > 0) {
  ------------------
  |  Branch (657:10): [True: 763k, False: 48.2k]
  ------------------
  658|   763k|    VP8LConvertFromBGRA((const uint32_t*)row_in, mb_w, colorspace, row_out);
  659|   763k|    row_in += in_stride;
  660|   763k|    row_out += out_stride;
  661|   763k|  }
  662|  48.2k|  return mb_h;  // Num rows out == num rows in.
  663|  48.2k|}
vp8l_dec.c:EmitRowsYUVA:
  740|  13.9k|                        VP8LDecoder* const dec) {
  741|  13.9k|  int y_pos = dec->last_out_row;
  742|  13.9k|  const int width = io->mb_w;
  743|  13.9k|  int num_rows = io->mb_h;
  744|  13.9k|  const int y_pos_final = y_pos + num_rows;
  745|  13.9k|  const int y_stride = dec->output->u.YUVA.y_stride;
  746|  13.9k|  const int uv_stride = dec->output->u.YUVA.u_stride;
  747|  13.9k|  const int a_stride = dec->output->u.YUVA.a_stride;
  748|  13.9k|  uint8_t* dst_a = dec->output->u.YUVA.a;
  749|  13.9k|  uint8_t* dst_y = dec->output->u.YUVA.y + (ptrdiff_t)y_pos * y_stride;
  750|  13.9k|  uint8_t* dst_u = dec->output->u.YUVA.u + (ptrdiff_t)(y_pos >> 1) * uv_stride;
  751|  13.9k|  uint8_t* dst_v = dec->output->u.YUVA.v + (ptrdiff_t)(y_pos >> 1) * uv_stride;
  752|  13.9k|  const uint8_t* r_ptr = in + CHANNEL_OFFSET(1);
  ------------------
  |  |   51|  13.9k|#define CHANNEL_OFFSET(i) (3 - (i))
  ------------------
  753|  13.9k|  const uint8_t* g_ptr = in + CHANNEL_OFFSET(2);
  ------------------
  |  |   51|  13.9k|#define CHANNEL_OFFSET(i) (3 - (i))
  ------------------
  754|  13.9k|  const uint8_t* b_ptr = in + CHANNEL_OFFSET(3);
  ------------------
  |  |   51|  13.9k|#define CHANNEL_OFFSET(i) (3 - (i))
  ------------------
  755|  13.9k|  const uint8_t* a_ptr = NULL;
  756|  13.9k|  int has_alpha = 0;
  757|       |
  758|       |  // Make sure the lines are processed two by two from the start.
  759|  13.9k|  assert(y_pos % 2 == 0);
  760|       |
  761|       |  // Make sure num_rows is even. y_pos_final will check if it not.
  762|  13.9k|  num_rows &= ~1;
  763|       |
  764|  13.9k|  if (dst_a) {
  ------------------
  |  Branch (764:7): [True: 0, False: 13.9k]
  ------------------
  765|      0|    dst_a += (ptrdiff_t)y_pos * a_stride;
  766|      0|    a_ptr = in + CHANNEL_OFFSET(0);
  ------------------
  |  |   51|      0|#define CHANNEL_OFFSET(i) (3 - (i))
  ------------------
  767|      0|    has_alpha = CheckNonOpaque(a_ptr, width, num_rows, in_stride);
  768|      0|  }
  769|       |  // Process pairs of lines.
  770|  13.9k|  WebPImportYUVAFromRGBA(r_ptr, g_ptr, b_ptr, a_ptr, /*step=*/4, in_stride,
  771|  13.9k|                         has_alpha, width, num_rows, tmp_rgb, y_stride,
  772|  13.9k|                         uv_stride, a_stride, dst_y, dst_u, dst_v, dst_a);
  773|       |
  774|  13.9k|  y_pos += num_rows;
  775|  13.9k|  if (y_pos_final == io->crop_bottom - io->crop_top && y_pos < y_pos_final) {
  ------------------
  |  Branch (775:7): [True: 222, False: 13.7k]
  |  Branch (775:56): [True: 103, False: 119]
  ------------------
  776|    103|    assert(y_pos + 1 == y_pos_final);
  777|       |    // If we output the last line of an image with odd height.
  778|    103|    dst_y += (ptrdiff_t)num_rows * y_stride;
  779|    103|    dst_u += (ptrdiff_t)(num_rows >> 1) * uv_stride;
  780|    103|    dst_v += (ptrdiff_t)(num_rows >> 1) * uv_stride;
  781|    103|    r_ptr += (ptrdiff_t)num_rows * in_stride;
  782|    103|    g_ptr += (ptrdiff_t)num_rows * in_stride;
  783|    103|    b_ptr += (ptrdiff_t)num_rows * in_stride;
  784|    103|    if (dst_a) {
  ------------------
  |  Branch (784:9): [True: 0, False: 103]
  ------------------
  785|      0|      dst_a += (ptrdiff_t)num_rows * a_stride;
  786|      0|      a_ptr += (ptrdiff_t)num_rows * in_stride;
  787|      0|      has_alpha = CheckNonOpaque(a_ptr, width, /*height=*/1, in_stride);
  788|      0|    }
  789|    103|    WebPImportYUVAFromRGBALastLine(r_ptr, g_ptr, b_ptr, a_ptr, /*step=*/4,
  790|    103|                                   has_alpha, width, tmp_rgb, dst_y, dst_u,
  791|    103|                                   dst_v, dst_a);
  792|    103|    y_pos = y_pos_final;
  793|    103|  }
  794|  13.9k|  return y_pos;
  795|  13.9k|}

WebPParseHeaders:
  435|  5.18k|VP8StatusCode WebPParseHeaders(WebPHeaderStructure* const headers) {
  436|       |  // status is marked volatile as a workaround for a clang-3.8 (aarch64) bug
  437|  5.18k|  volatile VP8StatusCode status;
  438|  5.18k|  int has_animation = 0;
  439|  5.18k|  assert(headers != NULL);
  440|       |  // fill out headers, ignore width/height/has_alpha.
  441|  5.18k|  {
  442|  5.18k|    const uint8_t* WEBP_BIDI_INDEXABLE const bounded_data =
  443|  5.18k|        WEBP_UNSAFE_FORGE_BIDI_INDEXABLE(const uint8_t*, headers->data,
  ------------------
  |  |  180|  5.18k|#define WEBP_UNSAFE_FORGE_BIDI_INDEXABLE(typ, ptr, size) ((typ)(ptr))
  ------------------
  444|  5.18k|                                         headers->data_size);
  445|  5.18k|    status = ParseHeadersInternal(bounded_data, headers->data_size, NULL, NULL,
  446|  5.18k|                                  NULL, &has_animation, NULL, headers);
  447|  5.18k|  }
  448|  5.18k|  if (status == VP8_STATUS_OK || status == VP8_STATUS_NOT_ENOUGH_DATA) {
  ------------------
  |  Branch (448:7): [True: 5.14k, False: 36]
  |  Branch (448:34): [True: 36, False: 0]
  ------------------
  449|       |    // The WebPDemux API + libwebp can be used to decode individual
  450|       |    // uncomposited frames or the WebPAnimDecoder can be used to fully
  451|       |    // reconstruct them (see webp/demux.h).
  452|  5.18k|    if (has_animation) {
  ------------------
  |  Branch (452:9): [True: 0, False: 5.18k]
  ------------------
  453|      0|      status = VP8_STATUS_UNSUPPORTED_FEATURE;
  454|      0|    }
  455|  5.18k|  }
  456|  5.18k|  return status;
  457|  5.18k|}
WebPResetDecParams:
  462|  5.18k|void WebPResetDecParams(WebPDecParams* const params) {
  463|  5.18k|  if (params != NULL) {
  ------------------
  |  Branch (463:7): [True: 5.18k, False: 0]
  ------------------
  464|  5.18k|    WEBP_UNSAFE_MEMSET(params, 0, sizeof(*params));
  ------------------
  |  |  175|  5.18k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  465|  5.18k|  }
  466|  5.18k|}
WebPDecodeRGBInto:
  579|    416|                           int stride) {
  580|    416|  return DecodeIntoRGBABuffer(MODE_RGB, data, data_size, output, stride, size);
  581|    416|}
WebPDecodeRGBAInto:
  586|    408|                            int stride) {
  587|    408|  return DecodeIntoRGBABuffer(MODE_RGBA, data, data_size, output, stride, size);
  588|    408|}
WebPDecodeARGBInto:
  593|    448|                            int stride) {
  594|    448|  return DecodeIntoRGBABuffer(MODE_ARGB, data, data_size, output, stride, size);
  595|    448|}
WebPDecodeBGRInto:
  600|    499|                           int stride) {
  601|    499|  return DecodeIntoRGBABuffer(MODE_BGR, data, data_size, output, stride, size);
  602|    499|}
WebPDecodeBGRAInto:
  607|    133|                            int stride) {
  608|    133|  return DecodeIntoRGBABuffer(MODE_BGRA, data, data_size, output, stride, size);
  609|    133|}
WebPDecodeYUVInto:
  617|    474|                           size_t v_size, int v_stride) {
  618|    474|  WebPDecParams params;
  619|    474|  WebPDecBuffer output;
  620|    474|  if (luma == NULL || !WebPInitDecBuffer(&output)) return NULL;
  ------------------
  |  Branch (620:7): [True: 0, False: 474]
  |  Branch (620:23): [True: 0, False: 474]
  ------------------
  621|    474|  WebPResetDecParams(&params);
  622|    474|  params.output = &output;
  623|    474|  output.colorspace = MODE_YUV;
  624|    474|  output.u.YUVA.y = luma;
  625|    474|  output.u.YUVA.y_stride = luma_stride;
  626|    474|  output.u.YUVA.y_size = luma_size;
  627|    474|  output.u.YUVA.u = u;
  628|    474|  output.u.YUVA.u_stride = u_stride;
  629|    474|  output.u.YUVA.u_size = u_size;
  630|    474|  output.u.YUVA.v = v;
  631|    474|  output.u.YUVA.v_stride = v_stride;
  632|    474|  output.u.YUVA.v_size = v_size;
  633|    474|  output.is_external_memory = 1;
  634|    474|  if (DecodeInto(data, data_size, &params) != VP8_STATUS_OK) {
  ------------------
  |  Branch (634:7): [True: 353, False: 121]
  ------------------
  635|    353|    return NULL;
  636|    353|  }
  637|    121|  return luma;
  638|    474|}
WebPDecodeRGB:
  677|    462|                       size_t data_size, int* width, int* height) {
  678|       |  return Decode(MODE_RGB, data, data_size, width, height, NULL);
  679|    462|}
WebPDecodeRGBA:
  682|    481|                        size_t data_size, int* width, int* height) {
  683|       |  return Decode(MODE_RGBA, data, data_size, width, height, NULL);
  684|    481|}
WebPDecodeARGB:
  687|    472|                        size_t data_size, int* width, int* height) {
  688|       |  return Decode(MODE_ARGB, data, data_size, width, height, NULL);
  689|    472|}
WebPDecodeBGR:
  692|    447|                       size_t data_size, int* width, int* height) {
  693|       |  return Decode(MODE_BGR, data, data_size, width, height, NULL);
  694|    447|}
WebPDecodeBGRA:
  697|    535|                        size_t data_size, int* width, int* height) {
  698|       |  return Decode(MODE_BGRA, data, data_size, width, height, NULL);
  699|    535|}
WebPDecodeYUV:
  703|    409|                       uint8_t** v, int* stride, int* uv_stride) {
  704|       |  // data, width and height are checked by Decode().
  705|    409|  if (u == NULL || v == NULL || stride == NULL || uv_stride == NULL) {
  ------------------
  |  Branch (705:7): [True: 0, False: 409]
  |  Branch (705:20): [True: 0, False: 409]
  |  Branch (705:33): [True: 0, False: 409]
  |  Branch (705:51): [True: 0, False: 409]
  ------------------
  706|      0|    return NULL;
  707|      0|  }
  708|       |
  709|    409|  {
  710|    409|    WebPDecBuffer output;  // only to preserve the side-infos
  711|    409|    uint8_t* const out =
  712|    409|        Decode(MODE_YUV, data, data_size, width, height, &output);
  713|       |
  714|    409|    if (out != NULL) {
  ------------------
  |  Branch (714:9): [True: 121, False: 288]
  ------------------
  715|    121|      const WebPYUVABuffer* const buf = &output.u.YUVA;
  716|    121|      *u = buf->u;
  717|    121|      *v = buf->v;
  718|    121|      *stride = buf->y_stride;
  719|    121|      *uv_stride = buf->u_stride;
  720|       |      assert(buf->u_stride == buf->v_stride);
  721|    121|    }
  722|    409|    return out;
  723|    409|  }
  724|    409|}
WebPGetInfo:
  750|  8.33k|                size_t data_size, int* width, int* height) {
  751|  8.33k|  WebPBitstreamFeatures features;
  752|       |
  753|  8.33k|  if (GetFeatures(data, data_size, &features) != VP8_STATUS_OK) {
  ------------------
  |  Branch (753:7): [True: 319, False: 8.01k]
  ------------------
  754|    319|    return 0;
  755|    319|  }
  756|       |
  757|  8.01k|  if (width != NULL) {
  ------------------
  |  Branch (757:7): [True: 8.01k, False: 0]
  ------------------
  758|  8.01k|    *width = features.width;
  759|  8.01k|  }
  760|  8.01k|  if (height != NULL) {
  ------------------
  |  Branch (760:7): [True: 8.01k, False: 0]
  ------------------
  761|  8.01k|    *height = features.height;
  762|  8.01k|  }
  763|       |
  764|  8.01k|  return 1;
  765|  8.33k|}
WebPIoInitFromOptions:
  907|  3.97k|                          VP8Io* const io, WEBP_CSP_MODE src_colorspace) {
  908|  3.97k|  const int W = io->width;
  909|  3.97k|  const int H = io->height;
  910|  3.97k|  int x = 0, y = 0, w = W, h = H;
  911|       |
  912|       |  // Cropping
  913|  3.97k|  io->use_cropping = (options != NULL) && options->use_cropping;
  ------------------
  |  Branch (913:22): [True: 0, False: 3.97k]
  |  Branch (913:43): [True: 0, False: 0]
  ------------------
  914|  3.97k|  if (io->use_cropping) {
  ------------------
  |  Branch (914:7): [True: 0, False: 3.97k]
  ------------------
  915|      0|    w = options->crop_width;
  916|      0|    h = options->crop_height;
  917|      0|    x = options->crop_left;
  918|      0|    y = options->crop_top;
  919|      0|    if (!WebPIsRGBMode(src_colorspace)) {  // only snap for YUV420
  ------------------
  |  Branch (919:9): [True: 0, False: 0]
  ------------------
  920|      0|      x &= ~1;
  921|      0|      y &= ~1;
  922|      0|    }
  923|      0|    if (!WebPCheckCropDimensions(W, H, x, y, w, h)) {
  ------------------
  |  Branch (923:9): [True: 0, False: 0]
  ------------------
  924|      0|      return 0;  // out of frame boundary error
  925|      0|    }
  926|      0|  }
  927|  3.97k|  io->crop_left = x;
  928|  3.97k|  io->crop_top = y;
  929|  3.97k|  io->crop_right = x + w;
  930|  3.97k|  io->crop_bottom = y + h;
  931|  3.97k|  io->mb_w = w;
  932|  3.97k|  io->mb_h = h;
  933|       |
  934|       |  // Scaling
  935|  3.97k|  io->use_scaling = (options != NULL) && options->use_scaling;
  ------------------
  |  Branch (935:21): [True: 0, False: 3.97k]
  |  Branch (935:42): [True: 0, False: 0]
  ------------------
  936|  3.97k|  if (io->use_scaling) {
  ------------------
  |  Branch (936:7): [True: 0, False: 3.97k]
  ------------------
  937|      0|    int scaled_width = options->scaled_width;
  938|      0|    int scaled_height = options->scaled_height;
  939|      0|    if (!WebPRescalerGetScaledDimensions(w, h, &scaled_width, &scaled_height)) {
  ------------------
  |  Branch (939:9): [True: 0, False: 0]
  ------------------
  940|      0|      return 0;
  941|      0|    }
  942|      0|    io->scaled_width = scaled_width;
  943|      0|    io->scaled_height = scaled_height;
  944|      0|  }
  945|       |
  946|       |  // Filter
  947|  3.97k|  io->bypass_filtering = (options != NULL) && options->bypass_filtering;
  ------------------
  |  Branch (947:26): [True: 0, False: 3.97k]
  |  Branch (947:47): [True: 0, False: 0]
  ------------------
  948|       |
  949|       |  // Fancy upsampler
  950|  3.97k|#ifdef FANCY_UPSAMPLING
  951|  3.97k|  io->fancy_upsampling = (options == NULL) || (!options->no_fancy_upsampling);
  ------------------
  |  Branch (951:26): [True: 3.97k, False: 0]
  |  Branch (951:47): [True: 0, False: 0]
  ------------------
  952|  3.97k|#endif
  953|       |
  954|  3.97k|  if (io->use_scaling) {
  ------------------
  |  Branch (954:7): [True: 0, False: 3.97k]
  ------------------
  955|       |    // disable filter (only for large downscaling ratio).
  956|      0|    io->bypass_filtering |=
  957|      0|        (io->scaled_width < W * 3 / 4) && (io->scaled_height < H * 3 / 4);
  ------------------
  |  Branch (957:9): [True: 0, False: 0]
  |  Branch (957:43): [True: 0, False: 0]
  ------------------
  958|      0|    io->fancy_upsampling = 0;
  959|      0|  }
  960|  3.97k|  return 1;
  961|  3.97k|}
webp_dec.c:ParseHeadersInternal:
  298|  13.5k|    WebPHeaderStructure* const headers) {
  299|  13.5k|  size_t data_size = data_size_param;
  300|  13.5k|  const uint8_t* WEBP_COUNTED_BY(data_size) data = data_param;
  301|  13.5k|  int canvas_width = 0;
  302|  13.5k|  int canvas_height = 0;
  303|  13.5k|  int image_width = 0;
  304|  13.5k|  int image_height = 0;
  305|  13.5k|  int found_riff = 0;
  306|  13.5k|  int found_vp8x = 0;
  307|  13.5k|  int animation_present = 0;
  308|  13.5k|  const int have_all_data = (headers != NULL) ? headers->have_all_data : 0;
  ------------------
  |  Branch (308:29): [True: 5.18k, False: 8.33k]
  ------------------
  309|       |
  310|  13.5k|  VP8StatusCode status;
  311|  13.5k|  WebPHeaderStructure hdrs;
  312|       |
  313|  13.5k|  if (data == NULL || data_size < RIFF_HEADER_SIZE) {
  ------------------
  |  |   76|  13.5k|#define RIFF_HEADER_SIZE 12  // Size of the RIFF header ("RIFFnnnnWEBP").
  ------------------
  |  Branch (313:7): [True: 0, False: 13.5k]
  |  Branch (313:23): [True: 32, False: 13.4k]
  ------------------
  314|     32|    return VP8_STATUS_NOT_ENOUGH_DATA;
  315|     32|  }
  316|  13.4k|  WEBP_UNSAFE_MEMSET(&hdrs, 0, sizeof(hdrs));
  ------------------
  |  |  175|  13.4k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  317|  13.4k|  hdrs.data = data;
  318|  13.4k|  hdrs.data_size = data_size;
  319|       |
  320|       |  // Skip over RIFF header.
  321|  13.4k|  status = ParseRIFF(&data, &data_size, have_all_data, &hdrs.riff_size);
  322|  13.4k|  if (status != VP8_STATUS_OK) {
  ------------------
  |  Branch (322:7): [True: 2, False: 13.4k]
  ------------------
  323|      2|    return status;  // Wrong RIFF header / insufficient data.
  324|      2|  }
  325|  13.4k|  found_riff = (hdrs.riff_size > 0);
  326|       |
  327|       |  // Skip over VP8X.
  328|  13.4k|  {
  329|  13.4k|    uint32_t flags = 0;
  330|  13.4k|    status = ParseVP8X(&data, &data_size, &found_vp8x, &canvas_width,
  331|  13.4k|                       &canvas_height, &flags);
  332|  13.4k|    if (status != VP8_STATUS_OK) {
  ------------------
  |  Branch (332:9): [True: 49, False: 13.4k]
  ------------------
  333|     49|      return status;  // Wrong VP8X / insufficient data.
  334|     49|    }
  335|  13.4k|    animation_present = !!(flags & ANIMATION_FLAG);
  336|  13.4k|    if (!found_riff && found_vp8x) {
  ------------------
  |  Branch (336:9): [True: 13.4k, False: 0]
  |  Branch (336:24): [True: 2, False: 13.4k]
  ------------------
  337|       |      // Note: This restriction may be removed in the future, if it becomes
  338|       |      // necessary to send VP8X chunk to the decoder.
  339|      2|      return VP8_STATUS_BITSTREAM_ERROR;
  340|      2|    }
  341|  13.4k|    if (has_alpha != NULL) *has_alpha = !!(flags & ALPHA_FLAG);
  ------------------
  |  Branch (341:9): [True: 8.24k, False: 5.18k]
  ------------------
  342|  13.4k|    if (has_animation != NULL) *has_animation = animation_present;
  ------------------
  |  Branch (342:9): [True: 13.4k, False: 0]
  ------------------
  343|  13.4k|    if (format != NULL) *format = 0;  // default = undefined
  ------------------
  |  Branch (343:9): [True: 8.24k, False: 5.18k]
  ------------------
  344|       |
  345|  13.4k|    image_width = canvas_width;
  346|  13.4k|    image_height = canvas_height;
  347|  13.4k|    if (found_vp8x && animation_present && headers == NULL) {
  ------------------
  |  Branch (347:9): [True: 0, False: 13.4k]
  |  Branch (347:23): [True: 0, False: 0]
  |  Branch (347:44): [True: 0, False: 0]
  ------------------
  348|      0|      status = VP8_STATUS_OK;
  349|      0|      goto ReturnWidthHeight;  // Just return features from VP8X header.
  350|      0|    }
  351|  13.4k|  }
  352|       |
  353|  13.4k|  if (data_size < TAG_SIZE) {
  ------------------
  |  |   73|  13.4k|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  |  Branch (353:7): [True: 0, False: 13.4k]
  ------------------
  354|      0|    status = VP8_STATUS_NOT_ENOUGH_DATA;
  355|      0|    goto ReturnWidthHeight;
  356|      0|  }
  357|       |
  358|       |  // Skip over optional chunks if data started with "RIFF + VP8X" or "ALPH".
  359|  13.4k|  if ((found_riff && found_vp8x) ||
  ------------------
  |  Branch (359:8): [True: 0, False: 13.4k]
  |  Branch (359:22): [True: 0, False: 0]
  ------------------
  360|  13.4k|      (!found_riff && !found_vp8x && !memcmp(data, "ALPH", TAG_SIZE))) {
  ------------------
  |  |   73|  13.4k|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  |  Branch (360:8): [True: 13.4k, False: 0]
  |  Branch (360:23): [True: 13.4k, False: 0]
  |  Branch (360:38): [True: 85, False: 13.3k]
  ------------------
  361|     85|    size_t local_alpha_data_size = 0;
  362|     85|    const uint8_t* WEBP_COUNTED_BY(local_alpha_data_size) local_alpha_data =
  363|     85|        NULL;
  364|     85|    status = ParseOptionalChunks(&data, &data_size, hdrs.riff_size,
  365|     85|                                 &local_alpha_data, &local_alpha_data_size);
  366|     85|    if (status != VP8_STATUS_OK) {
  ------------------
  |  Branch (366:9): [True: 85, False: 0]
  ------------------
  367|     85|      goto ReturnWidthHeight;  // Invalid chunk size / insufficient data.
  368|     85|    }
  369|      0|    hdrs.alpha_data = local_alpha_data;
  370|      0|    hdrs.alpha_data_size = local_alpha_data_size;
  371|      0|  }
  372|       |
  373|       |  // Skip over VP8/VP8L header.
  374|  13.3k|  status = ParseVP8Header(&data, &data_size, have_all_data, hdrs.riff_size,
  375|  13.3k|                          &hdrs.compressed_size, &hdrs.is_lossless);
  376|  13.3k|  if (status != VP8_STATUS_OK) {
  ------------------
  |  Branch (376:7): [True: 36, False: 13.3k]
  ------------------
  377|     36|    goto ReturnWidthHeight;  // Wrong VP8/VP8L chunk-header / insufficient data.
  378|     36|  }
  379|  13.3k|  if (hdrs.compressed_size > MAX_CHUNK_PAYLOAD) {
  ------------------
  |  |   89|  13.3k|#define MAX_CHUNK_PAYLOAD (~0U - CHUNK_HEADER_SIZE - 1)
  |  |  ------------------
  |  |  |  |   75|  13.3k|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  |  |  ------------------
  ------------------
  |  Branch (379:7): [True: 1, False: 13.3k]
  ------------------
  380|      1|    return VP8_STATUS_BITSTREAM_ERROR;
  381|      1|  }
  382|       |
  383|  13.3k|  if (format != NULL && !animation_present) {
  ------------------
  |  Branch (383:7): [True: 8.16k, False: 5.14k]
  |  Branch (383:25): [True: 8.16k, False: 0]
  ------------------
  384|  8.16k|    *format = hdrs.is_lossless ? 2 : 1;
  ------------------
  |  Branch (384:15): [True: 3.57k, False: 4.59k]
  ------------------
  385|  8.16k|  }
  386|       |
  387|  13.3k|  if (!hdrs.is_lossless) {
  ------------------
  |  Branch (387:7): [True: 7.45k, False: 5.85k]
  ------------------
  388|  7.45k|    if (data_size < VP8_FRAME_HEADER_SIZE) {
  ------------------
  |  |   24|  7.45k|#define VP8_FRAME_HEADER_SIZE 10  // Size of the frame header within VP8 data.
  ------------------
  |  Branch (388:9): [True: 6, False: 7.45k]
  ------------------
  389|      6|      status = VP8_STATUS_NOT_ENOUGH_DATA;
  390|      6|      goto ReturnWidthHeight;
  391|      6|    }
  392|       |    // Validates raw VP8 data.
  393|  7.45k|    if (!VP8GetInfo(data, data_size, (uint32_t)hdrs.compressed_size,
  ------------------
  |  Branch (393:9): [True: 98, False: 7.35k]
  ------------------
  394|  7.45k|                    &image_width, &image_height)) {
  395|     98|      return VP8_STATUS_BITSTREAM_ERROR;
  396|     98|    }
  397|  7.45k|  } else {
  398|  5.85k|    if (data_size < VP8L_FRAME_HEADER_SIZE) {
  ------------------
  |  |   33|  5.85k|#define VP8L_FRAME_HEADER_SIZE 5  // Size of the VP8L frame header.
  ------------------
  |  Branch (398:9): [True: 28, False: 5.82k]
  ------------------
  399|     28|      status = VP8_STATUS_NOT_ENOUGH_DATA;
  400|     28|      goto ReturnWidthHeight;
  401|     28|    }
  402|       |    // Validates raw VP8L data.
  403|  5.82k|    if (!VP8LGetInfo(data, data_size, &image_width, &image_height, has_alpha)) {
  ------------------
  |  Branch (403:9): [True: 14, False: 5.81k]
  ------------------
  404|     14|      return VP8_STATUS_BITSTREAM_ERROR;
  405|     14|    }
  406|  5.82k|  }
  407|       |  // Validates image size coherency.
  408|  13.1k|  if (found_vp8x) {
  ------------------
  |  Branch (408:7): [True: 0, False: 13.1k]
  ------------------
  409|      0|    if (canvas_width != image_width || canvas_height != image_height) {
  ------------------
  |  Branch (409:9): [True: 0, False: 0]
  |  Branch (409:40): [True: 0, False: 0]
  ------------------
  410|      0|      return VP8_STATUS_BITSTREAM_ERROR;
  411|      0|    }
  412|      0|  }
  413|  13.1k|  if (headers != NULL) {
  ------------------
  |  Branch (413:7): [True: 5.14k, False: 8.01k]
  ------------------
  414|  5.14k|    *headers = hdrs;
  415|  5.14k|    headers->offset = data - headers->data;
  416|  5.14k|    assert((uint64_t)(data - headers->data) < MAX_CHUNK_PAYLOAD);
  417|  5.14k|    assert(headers->offset == headers->data_size - data_size);
  418|  5.14k|  }
  419|  13.3k|ReturnWidthHeight:
  420|  13.3k|  if (status == VP8_STATUS_OK ||
  ------------------
  |  Branch (420:7): [True: 13.1k, False: 155]
  ------------------
  421|  13.1k|      (status == VP8_STATUS_NOT_ENOUGH_DATA && found_vp8x && headers == NULL)) {
  ------------------
  |  Branch (421:8): [True: 154, False: 1]
  |  Branch (421:48): [True: 0, False: 154]
  |  Branch (421:62): [True: 0, False: 0]
  ------------------
  422|  13.1k|    if (has_alpha != NULL) {
  ------------------
  |  Branch (422:9): [True: 8.01k, False: 5.14k]
  ------------------
  423|       |      // If the data did not contain a VP8X/VP8L chunk the only definitive way
  424|       |      // to set this is by looking for alpha data (from an ALPH chunk).
  425|  8.01k|      *has_alpha |= (hdrs.alpha_data != NULL);
  426|  8.01k|    }
  427|  13.1k|    if (width != NULL) *width = image_width;
  ------------------
  |  Branch (427:9): [True: 8.01k, False: 5.14k]
  ------------------
  428|  13.1k|    if (height != NULL) *height = image_height;
  ------------------
  |  Branch (428:9): [True: 8.01k, False: 5.14k]
  ------------------
  429|  13.1k|    return VP8_STATUS_OK;
  430|  13.1k|  } else {
  431|    155|    return status;
  432|    155|  }
  433|  13.3k|}
webp_dec.c:ParseRIFF:
   68|  13.4k|                               size_t* WEBP_SINGLE const riff_size) {
   69|  13.4k|  assert(data != NULL);
   70|  13.4k|  assert(data_size != NULL);
   71|  13.4k|  assert(riff_size != NULL);
   72|       |
   73|  13.4k|  *riff_size = 0;  // Default: no RIFF present.
   74|  13.4k|  if (*data_size >= RIFF_HEADER_SIZE && !memcmp(*data, "RIFF", TAG_SIZE)) {
  ------------------
  |  |   76|  26.9k|#define RIFF_HEADER_SIZE 12  // Size of the RIFF header ("RIFFnnnnWEBP").
  ------------------
                if (*data_size >= RIFF_HEADER_SIZE && !memcmp(*data, "RIFF", TAG_SIZE)) {
  ------------------
  |  |   73|  13.4k|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  |  Branch (74:7): [True: 13.4k, False: 0]
  |  Branch (74:41): [True: 2, False: 13.4k]
  ------------------
   75|      2|    if (memcmp(*data + 8, "WEBP", TAG_SIZE)) {
  ------------------
  |  |   73|      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);
  ------------------
  |  |   73|      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) {
  ------------------
  |  |   73|      0|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
                    if (size < TAG_SIZE + CHUNK_HEADER_SIZE) {
  ------------------
  |  |   75|      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) {
  ------------------
  |  |   89|      0|#define MAX_CHUNK_PAYLOAD (~0U - CHUNK_HEADER_SIZE - 1)
  |  |  ------------------
  |  |  |  |   75|      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)) {
  ------------------
  |  |   75|      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;
  ------------------
  |  |   76|      0|#define RIFF_HEADER_SIZE 12  // Size of the RIFF header ("RIFFnnnnWEBP").
  ------------------
   92|      0|      *data += RIFF_HEADER_SIZE;
  ------------------
  |  |   76|      0|#define RIFF_HEADER_SIZE 12  // Size of the RIFF header ("RIFFnnnnWEBP").
  ------------------
   93|      0|    }
   94|      2|  }
   95|  13.4k|  return VP8_STATUS_OK;
   96|  13.4k|}
webp_dec.c:ParseVP8X:
  111|  13.4k|                               uint32_t* WEBP_SINGLE const flags_ptr) {
  112|  13.4k|  const uint32_t vp8x_size = CHUNK_HEADER_SIZE + VP8X_CHUNK_SIZE;
  ------------------
  |  |   75|  13.4k|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
                const uint32_t vp8x_size = CHUNK_HEADER_SIZE + VP8X_CHUNK_SIZE;
  ------------------
  |  |   79|  13.4k|#define VP8X_CHUNK_SIZE 10   // Size of a VP8X chunk.
  ------------------
  113|  13.4k|  assert(data != NULL);
  114|  13.4k|  assert(data_size != NULL);
  115|  13.4k|  assert(found_vp8x != NULL);
  116|       |
  117|  13.4k|  *found_vp8x = 0;
  118|       |
  119|  13.4k|  if (*data_size < CHUNK_HEADER_SIZE) {
  ------------------
  |  |   75|  13.4k|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  |  Branch (119:7): [True: 0, False: 13.4k]
  ------------------
  120|      0|    return VP8_STATUS_NOT_ENOUGH_DATA;  // Insufficient data.
  121|      0|  }
  122|       |
  123|  13.4k|  if (!memcmp(*data, "VP8X", TAG_SIZE)) {
  ------------------
  |  |   73|  13.4k|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  |  Branch (123:7): [True: 51, False: 13.4k]
  ------------------
  124|     51|    int width, height;
  125|     51|    uint32_t flags;
  126|     51|    const uint32_t chunk_size = GetLE32(*data + TAG_SIZE);
  ------------------
  |  |   73|     51|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  127|     51|    if (chunk_size != VP8X_CHUNK_SIZE) {
  ------------------
  |  |   79|     51|#define VP8X_CHUNK_SIZE 10   // Size of a VP8X chunk.
  ------------------
  |  Branch (127:9): [True: 38, False: 13]
  ------------------
  128|     38|      return VP8_STATUS_BITSTREAM_ERROR;  // Wrong chunk size.
  129|     38|    }
  130|       |
  131|       |    // Verify if enough data is available to validate the VP8X chunk.
  132|     13|    if (*data_size < vp8x_size) {
  ------------------
  |  Branch (132:9): [True: 3, False: 10]
  ------------------
  133|      3|      return VP8_STATUS_NOT_ENOUGH_DATA;  // Insufficient data.
  134|      3|    }
  135|     10|    flags = GetLE32(*data + 8);
  136|     10|    width = 1 + GetLE24(*data + 12);
  137|     10|    height = 1 + GetLE24(*data + 15);
  138|     10|    if (width * (uint64_t)height >= MAX_IMAGE_AREA) {
  ------------------
  |  |   82|     10|#define MAX_IMAGE_AREA (1ULL << 32)    // 32-bit max for width x height.
  ------------------
  |  Branch (138:9): [True: 8, False: 2]
  ------------------
  139|      8|      return VP8_STATUS_BITSTREAM_ERROR;  // image is too large
  140|      8|    }
  141|       |
  142|      2|    if (flags_ptr != NULL) *flags_ptr = flags;
  ------------------
  |  Branch (142:9): [True: 2, False: 0]
  ------------------
  143|      2|    if (width_ptr != NULL) *width_ptr = width;
  ------------------
  |  Branch (143:9): [True: 2, False: 0]
  ------------------
  144|      2|    if (height_ptr != NULL) *height_ptr = height;
  ------------------
  |  Branch (144:9): [True: 2, False: 0]
  ------------------
  145|       |    // Skip over VP8X header bytes.
  146|      2|    *data_size -= vp8x_size;
  147|      2|    *data += vp8x_size;
  148|      2|    *found_vp8x = 1;
  149|      2|  }
  150|  13.4k|  return VP8_STATUS_OK;
  151|  13.4k|}
webp_dec.c:ParseOptionalChunks:
  164|     85|    size_t* WEBP_SINGLE const alpha_size) {
  165|     85|  size_t buf_size;
  166|     85|  const uint8_t* WEBP_COUNTED_BY(buf_size) buf;
  167|     85|  uint64_t total_size = TAG_SIZE +           // "WEBP".
  ------------------
  |  |   73|     85|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  168|     85|                        CHUNK_HEADER_SIZE +  // "VP8Xnnnn".
  ------------------
  |  |   75|     85|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  169|     85|                        VP8X_CHUNK_SIZE;     // data.
  ------------------
  |  |   79|     85|#define VP8X_CHUNK_SIZE 10   // Size of a VP8X chunk.
  ------------------
  170|     85|  assert(data != NULL);
  171|     85|  assert(data_size != NULL);
  172|     85|  buf = *data;
  173|     85|  buf_size = *data_size;
  174|       |
  175|     85|  assert(alpha_data != NULL);
  176|     85|  assert(alpha_size != NULL);
  177|     85|  *alpha_data = NULL;
  178|     85|  *alpha_size = 0;
  179|       |
  180|    341|  while (1) {
  ------------------
  |  Branch (180:10): [True: 341, Folded]
  ------------------
  181|    341|    uint32_t chunk_size;
  182|    341|    uint32_t disk_chunk_size;  // chunk_size with padding
  183|       |
  184|    341|    *data_size = buf_size;
  185|    341|    *data = buf;
  186|       |
  187|    341|    if (buf_size < CHUNK_HEADER_SIZE) {  // Insufficient data.
  ------------------
  |  |   75|    341|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  |  Branch (187:9): [True: 10, False: 331]
  ------------------
  188|     10|      return VP8_STATUS_NOT_ENOUGH_DATA;
  189|     10|    }
  190|       |
  191|    331|    chunk_size = GetLE32(buf + TAG_SIZE);
  ------------------
  |  |   73|    331|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  192|    331|    if (chunk_size > MAX_CHUNK_PAYLOAD) {
  ------------------
  |  |   89|    331|#define MAX_CHUNK_PAYLOAD (~0U - CHUNK_HEADER_SIZE - 1)
  |  |  ------------------
  |  |  |  |   75|    331|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  |  |  ------------------
  ------------------
  |  Branch (192:9): [True: 1, False: 330]
  ------------------
  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|    330|    disk_chunk_size = (CHUNK_HEADER_SIZE + chunk_size + 1) & ~1u;
  ------------------
  |  |   75|    330|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  197|    330|    total_size += disk_chunk_size;
  198|       |
  199|       |    // Check that total bytes skipped so far does not exceed riff_size.
  200|    330|    if (riff_size > 0 && (total_size > riff_size)) {
  ------------------
  |  Branch (200:9): [True: 0, False: 330]
  |  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|    330|    if (!memcmp(buf, "VP8 ", TAG_SIZE) || !memcmp(buf, "VP8L", TAG_SIZE)) {
  ------------------
  |  |   73|    330|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
                  if (!memcmp(buf, "VP8 ", TAG_SIZE) || !memcmp(buf, "VP8L", TAG_SIZE)) {
  ------------------
  |  |   73|    330|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  |  Branch (208:9): [True: 0, False: 330]
  |  Branch (208:43): [True: 0, False: 330]
  ------------------
  209|      0|      return VP8_STATUS_OK;
  210|      0|    }
  211|       |
  212|    330|    if (buf_size < disk_chunk_size) {  // Insufficient data.
  ------------------
  |  Branch (212:9): [True: 74, False: 256]
  ------------------
  213|     74|      return VP8_STATUS_NOT_ENOUGH_DATA;
  214|     74|    }
  215|       |
  216|    256|    if (!memcmp(buf, "ALPH", TAG_SIZE)) {  // A valid ALPH header.
  ------------------
  |  |   73|    256|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  |  Branch (216:9): [True: 32, False: 224]
  ------------------
  217|     32|      *alpha_data = buf + CHUNK_HEADER_SIZE;
  ------------------
  |  |   75|     32|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  218|     32|      *alpha_size = chunk_size;
  219|     32|    }
  220|       |
  221|       |    // We have a full and valid chunk; skip it.
  222|    256|    buf += disk_chunk_size;
  223|    256|    buf_size -= disk_chunk_size;
  224|    256|  }
  225|     85|}
webp_dec.c:ParseVP8Header:
  240|  13.3k|                                    int* WEBP_SINGLE const is_lossless) {
  241|  13.3k|  const size_t local_data_size = *data_size;
  242|  13.3k|  const uint8_t* WEBP_COUNTED_BY(local_data_size) const data = *data_ptr;
  243|  13.3k|  const int is_vp8 = !memcmp(data, "VP8 ", TAG_SIZE);
  ------------------
  |  |   73|  13.3k|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  244|  13.3k|  const int is_vp8l = !memcmp(data, "VP8L", TAG_SIZE);
  ------------------
  |  |   73|  13.3k|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  245|  13.3k|  const uint32_t minimal_size =
  246|  13.3k|      TAG_SIZE + CHUNK_HEADER_SIZE;  // "WEBP" + "VP8 nnnn" OR
  ------------------
  |  |   73|  13.3k|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
                    TAG_SIZE + CHUNK_HEADER_SIZE;  // "WEBP" + "VP8 nnnn" OR
  ------------------
  |  |   75|  13.3k|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  247|       |                                     // "WEBP" + "VP8Lnnnn"
  248|  13.3k|  (void)local_data_size;
  249|  13.3k|  assert(data != NULL);
  250|  13.3k|  assert(data_size != NULL);
  251|  13.3k|  assert(chunk_size != NULL);
  252|  13.3k|  assert(is_lossless != NULL);
  253|       |
  254|  13.3k|  if (*data_size < CHUNK_HEADER_SIZE) {
  ------------------
  |  |   75|  13.3k|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  |  Branch (254:7): [True: 0, False: 13.3k]
  ------------------
  255|      0|    return VP8_STATUS_NOT_ENOUGH_DATA;  // Insufficient data.
  256|      0|  }
  257|       |
  258|  13.3k|  if (is_vp8 || is_vp8l) {
  ------------------
  |  Branch (258:7): [True: 6, False: 13.3k]
  |  Branch (258:17): [True: 213, False: 13.1k]
  ------------------
  259|       |    // Bitstream contains VP8/VP8L header.
  260|    219|    const uint32_t size = GetLE32(data + TAG_SIZE);
  ------------------
  |  |   73|    219|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  261|    219|    if ((riff_size >= minimal_size) && (size > riff_size - minimal_size)) {
  ------------------
  |  Branch (261:9): [True: 0, False: 219]
  |  Branch (261:40): [True: 0, False: 0]
  ------------------
  262|      0|      return VP8_STATUS_BITSTREAM_ERROR;  // Inconsistent size information.
  263|      0|    }
  264|    219|    if (have_all_data && (size > *data_size - CHUNK_HEADER_SIZE)) {
  ------------------
  |  |   75|     66|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  |  Branch (264:9): [True: 66, False: 153]
  |  Branch (264:26): [True: 36, False: 30]
  ------------------
  265|     36|      return VP8_STATUS_NOT_ENOUGH_DATA;  // Truncated bitstream.
  266|     36|    }
  267|       |    // Skip over CHUNK_HEADER_SIZE bytes from VP8/VP8L Header.
  268|    183|    *chunk_size = size;
  269|    183|    *data_size -= CHUNK_HEADER_SIZE;
  ------------------
  |  |   75|    183|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  270|    183|    *data_ptr += CHUNK_HEADER_SIZE;
  ------------------
  |  |   75|    183|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  271|    183|    *is_lossless = is_vp8l;
  272|  13.1k|  } else {
  273|       |    // Raw VP8/VP8L bitstream (no header).
  274|  13.1k|    *is_lossless = VP8LCheckSignature(data, *data_size);
  275|  13.1k|    *chunk_size = *data_size;
  276|  13.1k|  }
  277|       |
  278|  13.3k|  return VP8_STATUS_OK;
  279|  13.3k|}
webp_dec.c:DecodeIntoRGBABuffer:
  557|  1.90k|    uint8_t* WEBP_COUNTED_BY(size) const rgba, int stride, size_t size) {
  558|  1.90k|  WebPDecParams params;
  559|  1.90k|  WebPDecBuffer buf;
  560|  1.90k|  if (rgba == NULL || !WebPInitDecBuffer(&buf)) {
  ------------------
  |  Branch (560:7): [True: 0, False: 1.90k]
  |  Branch (560:23): [True: 0, False: 1.90k]
  ------------------
  561|      0|    return NULL;
  562|      0|  }
  563|  1.90k|  WebPResetDecParams(&params);
  564|  1.90k|  params.output = &buf;
  565|  1.90k|  buf.colorspace = colorspace;
  566|  1.90k|  buf.u.RGBA.rgba = rgba;
  567|  1.90k|  buf.u.RGBA.stride = stride;
  568|  1.90k|  buf.u.RGBA.size = size;
  569|  1.90k|  buf.is_external_memory = 1;
  570|  1.90k|  if (DecodeInto(data, data_size, &params) != VP8_STATUS_OK) {
  ------------------
  |  Branch (570:7): [True: 1.45k, False: 448]
  ------------------
  571|  1.45k|    return NULL;
  572|  1.45k|  }
  573|    448|  return rgba;
  574|  1.90k|}
webp_dec.c:DecodeInto:
  474|  5.18k|    WebPDecParams* const params) {
  475|  5.18k|  VP8StatusCode status;
  476|  5.18k|  VP8Io io;
  477|  5.18k|  WebPHeaderStructure headers;
  478|       |
  479|  5.18k|  headers.data = data;
  480|  5.18k|  headers.data_size = data_size;
  481|  5.18k|  headers.have_all_data = 1;
  482|  5.18k|  status = WebPParseHeaders(&headers);  // Process Pre-VP8 chunks.
  483|  5.18k|  if (status != VP8_STATUS_OK) {
  ------------------
  |  Branch (483:7): [True: 36, False: 5.14k]
  ------------------
  484|     36|    return status;
  485|     36|  }
  486|       |
  487|  5.18k|  assert(params != NULL);
  488|  5.14k|  if (!VP8InitIo(&io)) {
  ------------------
  |  Branch (488:7): [True: 0, False: 5.14k]
  ------------------
  489|      0|    return VP8_STATUS_INVALID_PARAM;
  490|      0|  }
  491|  5.14k|  io.data = headers.data + headers.offset;
  492|  5.14k|  io.data_size = headers.data_size - headers.offset;
  493|  5.14k|  WebPInitCustomIo(params, &io);  // Plug the I/O functions.
  494|       |
  495|  5.14k|  if (!headers.is_lossless) {
  ------------------
  |  Branch (495:7): [True: 2.86k, False: 2.27k]
  ------------------
  496|  2.86k|    VP8Decoder* const dec = VP8New();
  497|  2.86k|    if (dec == NULL) {
  ------------------
  |  Branch (497:9): [True: 0, False: 2.86k]
  ------------------
  498|      0|      return VP8_STATUS_OUT_OF_MEMORY;
  499|      0|    }
  500|  2.86k|    dec->alpha_data = headers.alpha_data;
  501|  2.86k|    dec->alpha_data_size = headers.alpha_data_size;
  502|       |
  503|       |    // Decode bitstream header, update io->width/io->height.
  504|  2.86k|    if (!VP8GetHeaders(dec, &io)) {
  ------------------
  |  Branch (504:9): [True: 172, False: 2.69k]
  ------------------
  505|    172|      status = dec->status;  // An error occurred. Grab error status.
  506|  2.69k|    } else {
  507|       |      // Allocate/check output buffers.
  508|  2.69k|      status = WebPAllocateDecBuffer(io.width, io.height, params->options,
  509|  2.69k|                                     params->output);
  510|  2.69k|      if (status == VP8_STATUS_OK) {  // Decode
  ------------------
  |  Branch (510:11): [True: 2.66k, False: 28]
  ------------------
  511|       |        // This change must be done before calling VP8Decode()
  512|  2.66k|        dec->mt_method =
  513|  2.66k|            VP8GetThreadMethod(params->options, &headers, io.width, io.height);
  514|  2.66k|        VP8InitDithering(params->options, dec);
  515|  2.66k|        if (!VP8Decode(dec, &io)) {
  ------------------
  |  Branch (515:13): [True: 2.30k, False: 365]
  ------------------
  516|  2.30k|          status = dec->status;
  517|  2.30k|        }
  518|  2.66k|      }
  519|  2.69k|    }
  520|  2.86k|    VP8Delete(dec);
  521|  2.86k|  } else {
  522|  2.27k|    VP8LDecoder* const dec = VP8LNew();
  523|  2.27k|    if (dec == NULL) {
  ------------------
  |  Branch (523:9): [True: 0, False: 2.27k]
  ------------------
  524|      0|      return VP8_STATUS_OUT_OF_MEMORY;
  525|      0|    }
  526|  2.27k|    if (!VP8LDecodeHeader(dec, &io)) {
  ------------------
  |  Branch (526:9): [True: 932, False: 1.34k]
  ------------------
  527|    932|      status = dec->status;  // An error occurred. Grab error status.
  528|  1.34k|    } else {
  529|       |      // Allocate/check output buffers.
  530|  1.34k|      status = WebPAllocateDecBuffer(io.width, io.height, params->options,
  531|  1.34k|                                     params->output);
  532|  1.34k|      if (status == VP8_STATUS_OK) {  // Decode
  ------------------
  |  Branch (532:11): [True: 1.30k, False: 39]
  ------------------
  533|  1.30k|        if (!VP8LDecodeImage(dec)) {
  ------------------
  |  Branch (533:13): [True: 353, False: 955]
  ------------------
  534|    353|          status = dec->status;
  535|    353|        }
  536|  1.30k|      }
  537|  1.34k|    }
  538|  2.27k|    VP8LDelete(dec);
  539|  2.27k|  }
  540|       |
  541|  5.14k|  if (status != VP8_STATUS_OK) {
  ------------------
  |  Branch (541:7): [True: 3.82k, False: 1.32k]
  ------------------
  542|  3.82k|    WebPFreeDecBuffer(params->output);
  543|  3.82k|  } else {
  544|  1.32k|    if (params->options != NULL && params->options->flip) {
  ------------------
  |  Branch (544:9): [True: 0, False: 1.32k]
  |  Branch (544:36): [True: 0, False: 0]
  ------------------
  545|       |      // This restores the original stride values if options->flip was used
  546|       |      // during the call to WebPAllocateDecBuffer above.
  547|      0|      status = WebPFlipBuffer(params->output);
  548|      0|    }
  549|  1.32k|  }
  550|  5.14k|  return status;
  551|  5.14k|}
webp_dec.c:Decode:
  647|  2.80k|                                      WebPDecBuffer* const keep_info) {
  648|  2.80k|  WebPDecParams params;
  649|  2.80k|  WebPDecBuffer output;
  650|       |
  651|  2.80k|  if (!WebPInitDecBuffer(&output)) {
  ------------------
  |  Branch (651:7): [True: 0, False: 2.80k]
  ------------------
  652|      0|    return NULL;
  653|      0|  }
  654|  2.80k|  WebPResetDecParams(&params);
  655|  2.80k|  params.output = &output;
  656|  2.80k|  output.colorspace = mode;
  657|       |
  658|       |  // Retrieve (and report back) the required dimensions from bitstream.
  659|  2.80k|  if (!WebPGetInfo(data, data_size, &output.width, &output.height)) {
  ------------------
  |  Branch (659:7): [True: 0, False: 2.80k]
  ------------------
  660|      0|    return NULL;
  661|      0|  }
  662|  2.80k|  if (width != NULL) *width = output.width;
  ------------------
  |  Branch (662:7): [True: 2.80k, False: 0]
  ------------------
  663|  2.80k|  if (height != NULL) *height = output.height;
  ------------------
  |  Branch (663:7): [True: 2.80k, False: 0]
  ------------------
  664|       |
  665|       |  // Decode
  666|  2.80k|  if (DecodeInto(data, data_size, &params) != VP8_STATUS_OK) {
  ------------------
  |  Branch (666:7): [True: 2.05k, False: 751]
  ------------------
  667|  2.05k|    return NULL;
  668|  2.05k|  }
  669|    751|  if (keep_info != NULL) {  // keep track of the side-info
  ------------------
  |  Branch (669:7): [True: 121, False: 630]
  ------------------
  670|    121|    WebPCopyDecBuffer(&output, keep_info);
  671|    121|  }
  672|       |  // return decoded samples (don't clear 'output'!)
  673|    751|  return WebPIsRGBMode(mode) ? output.u.RGBA.rgba : output.u.YUVA.y;
  ------------------
  |  Branch (673:10): [True: 630, False: 121]
  ------------------
  674|  2.80k|}
webp_dec.c:GetFeatures:
  734|  8.33k|                                 WebPBitstreamFeatures* const features) {
  735|  8.33k|  if (features == NULL || data == NULL) {
  ------------------
  |  Branch (735:7): [True: 0, False: 8.33k]
  |  Branch (735:27): [True: 2, False: 8.33k]
  ------------------
  736|      2|    return VP8_STATUS_INVALID_PARAM;
  737|      2|  }
  738|  8.33k|  DefaultFeatures(features);
  739|       |
  740|       |  // Only parse enough of the data to retrieve the features.
  741|  8.33k|  return ParseHeadersInternal(
  742|  8.33k|      data, data_size, &features->width, &features->height,
  743|       |      &features->has_alpha, &features->has_animation, &features->format, NULL);
  744|  8.33k|}
webp_dec.c:DefaultFeatures:
  726|  8.33k|static void DefaultFeatures(WebPBitstreamFeatures* const features) {
  727|  8.33k|  assert(features != NULL);
  728|  8.33k|  WEBP_UNSAFE_MEMSET(features, 0, sizeof(*features));
  ------------------
  |  |  175|  8.33k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  729|  8.33k|}

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

WebPInitAlphaProcessingSSE2:
  407|      1|WEBP_TSAN_IGNORE_FUNCTION void WebPInitAlphaProcessingSSE2(void) {
  408|      1|  WebPMultARGBRow = MultARGBRow_SSE2;
  409|      1|  WebPMultRow = MultRow_SSE2;
  410|      1|  WebPApplyAlphaMultiply = ApplyAlphaMultiply_SSE2;
  411|      1|  WebPDispatchAlpha = DispatchAlpha_SSE2;
  412|      1|  WebPDispatchAlphaToGreen = DispatchAlphaToGreen_SSE2;
  413|      1|  WebPExtractAlpha = ExtractAlpha_SSE2;
  414|      1|  WebPExtractGreen = ExtractGreen_SSE2;
  415|       |
  416|      1|  WebPHasAlpha8b = HasAlpha8b_SSE2;
  417|      1|  WebPHasAlpha32b = HasAlpha32b_SSE2;
  418|      1|  WebPAlphaReplace = AlphaReplace_SSE2;
  419|      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|  87.3k|    __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|  87.3k|  const __m128i transpose0_0 = _mm_unpacklo_epi16(*in0, *in1);
   78|  87.3k|  const __m128i transpose0_1 = _mm_unpacklo_epi16(*in2, *in3);
   79|  87.3k|  const __m128i transpose0_2 = _mm_unpackhi_epi16(*in0, *in1);
   80|  87.3k|  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|  87.3k|  const __m128i transpose1_0 = _mm_unpacklo_epi32(transpose0_0, transpose0_1);
   86|  87.3k|  const __m128i transpose1_1 = _mm_unpacklo_epi32(transpose0_2, transpose0_3);
   87|  87.3k|  const __m128i transpose1_2 = _mm_unpackhi_epi32(transpose0_0, transpose0_1);
   88|  87.3k|  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|  87.3k|  *out0 = _mm_unpacklo_epi64(transpose1_0, transpose1_1);
   94|  87.3k|  *out1 = _mm_unpackhi_epi64(transpose1_0, transpose1_1);
   95|  87.3k|  *out2 = _mm_unpacklo_epi64(transpose1_2, transpose1_3);
   96|  87.3k|  *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|  87.3k|}

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

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: 15, False: 0]
  ------------------
  133|     15|                cpu_info[2] == VENDOR_ID_INTEL_ECX &&
  ------------------
  |  Branch (133:17): [True: 15, False: 0]
  ------------------
  134|     15|                cpu_info[3] == VENDOR_ID_INTEL_EDX);  // genuine Intel?
  ------------------
  |  Branch (134:17): [True: 15, 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: 1, False: 0]
  |  Branch (145:21): [True: 1, False: 0]
  ------------------
  146|      1|      return CheckSlowModel(cpu_info[0]);
  147|      1|    }
  148|      0|    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:CheckSlowModel:
   99|      1|static int CheckSlowModel(int info) {
  100|       |  // Table listing display models with longer latencies for the bsr instruction
  101|       |  // (ie 2 cycles vs 10/16 cycles) and some SSSE3 instructions like pshufb.
  102|       |  // Refer to Intel 64 and IA-32 Architectures Optimization Reference Manual.
  103|      1|  static const uint8_t kSlowModels[] = {
  104|      1|      0x37, 0x4a, 0x4d,  // Silvermont Microarchitecture
  105|      1|      0x1c, 0x26, 0x27   // Atom Microarchitecture
  106|      1|  };
  107|      1|  const uint32_t model = ((info & 0xf0000) >> 12) | ((info >> 4) & 0xf);
  108|      1|  const uint32_t family = (info >> 8) & 0xf;
  109|      1|  if (family == 0x06) {
  ------------------
  |  Branch (109:7): [True: 1, False: 0]
  ------------------
  110|      1|    size_t i;
  111|      7|    for (i = 0; i < sizeof(kSlowModels) / sizeof(kSlowModels[0]); ++i) {
  ------------------
  |  Branch (111:17): [True: 6, False: 1]
  ------------------
  112|      6|      if (model == kSlowModels[i]) return 1;
  ------------------
  |  Branch (112:11): [True: 0, False: 6]
  ------------------
  113|      6|    }
  114|      1|  }
  115|      1|  return 0;
  116|      1|}
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:
  266|  2.86k|  WEBP_TSAN_IGNORE_FUNCTION void name(void) { WEBP_DSP_INIT(name##_body); } \
  ------------------
  |  |  234|  2.86k|  do {                                                     \
  |  |  235|  2.86k|    if (pthread_mutex_lock(&func##_lock)) break;           \
  |  |  ------------------
  |  |  |  Branch (235:9): [True: 0, False: 2.86k]
  |  |  ------------------
  |  |  236|  2.86k|    if (func##_last_cpuinfo_used != VP8GetCPUInfo) func(); \
  |  |  ------------------
  |  |  |  Branch (236:9): [True: 1, False: 2.86k]
  |  |  ------------------
  |  |  237|  2.86k|    func##_last_cpuinfo_used = VP8GetCPUInfo;              \
  |  |  238|  2.86k|    (void)pthread_mutex_unlock(&func##_lock);              \
  |  |  239|  2.86k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (239:12): [Folded, False: 2.86k]
  |  |  ------------------
  ------------------
WebPInitAlphaProcessing:
  266|  1.30k|  WEBP_TSAN_IGNORE_FUNCTION void name(void) { WEBP_DSP_INIT(name##_body); } \
  ------------------
  |  |  234|  1.30k|  do {                                                     \
  |  |  235|  1.30k|    if (pthread_mutex_lock(&func##_lock)) break;           \
  |  |  ------------------
  |  |  |  Branch (235:9): [True: 0, False: 1.30k]
  |  |  ------------------
  |  |  236|  1.30k|    if (func##_last_cpuinfo_used != VP8GetCPUInfo) func(); \
  |  |  ------------------
  |  |  |  Branch (236:9): [True: 1, False: 1.30k]
  |  |  ------------------
  |  |  237|  1.30k|    func##_last_cpuinfo_used = VP8GetCPUInfo;              \
  |  |  238|  1.30k|    (void)pthread_mutex_unlock(&func##_lock);              \
  |  |  239|  1.30k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (239:12): [Folded, False: 1.30k]
  |  |  ------------------
  ------------------
VP8DspInit:
  266|  2.66k|  WEBP_TSAN_IGNORE_FUNCTION void name(void) { WEBP_DSP_INIT(name##_body); } \
  ------------------
  |  |  234|  2.66k|  do {                                                     \
  |  |  235|  2.66k|    if (pthread_mutex_lock(&func##_lock)) break;           \
  |  |  ------------------
  |  |  |  Branch (235:9): [True: 0, False: 2.66k]
  |  |  ------------------
  |  |  236|  2.66k|    if (func##_last_cpuinfo_used != VP8GetCPUInfo) func(); \
  |  |  ------------------
  |  |  |  Branch (236:9): [True: 1, False: 2.66k]
  |  |  ------------------
  |  |  237|  2.66k|    func##_last_cpuinfo_used = VP8GetCPUInfo;              \
  |  |  238|  2.66k|    (void)pthread_mutex_unlock(&func##_lock);              \
  |  |  239|  2.66k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (239:12): [Folded, False: 2.66k]
  |  |  ------------------
  ------------------
VP8LDspInit:
  266|  2.27k|  WEBP_TSAN_IGNORE_FUNCTION void name(void) { WEBP_DSP_INIT(name##_body); } \
  ------------------
  |  |  234|  2.27k|  do {                                                     \
  |  |  235|  2.27k|    if (pthread_mutex_lock(&func##_lock)) break;           \
  |  |  ------------------
  |  |  |  Branch (235:9): [True: 0, False: 2.27k]
  |  |  ------------------
  |  |  236|  2.27k|    if (func##_last_cpuinfo_used != VP8GetCPUInfo) func(); \
  |  |  ------------------
  |  |  |  Branch (236:9): [True: 1, False: 2.27k]
  |  |  ------------------
  |  |  237|  2.27k|    func##_last_cpuinfo_used = VP8GetCPUInfo;              \
  |  |  238|  2.27k|    (void)pthread_mutex_unlock(&func##_lock);              \
  |  |  239|  2.27k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (239:12): [Folded, False: 2.27k]
  |  |  ------------------
  ------------------
WebPInitUpsamplers:
  266|  2.30k|  WEBP_TSAN_IGNORE_FUNCTION void name(void) { WEBP_DSP_INIT(name##_body); } \
  ------------------
  |  |  234|  2.30k|  do {                                                     \
  |  |  235|  2.30k|    if (pthread_mutex_lock(&func##_lock)) break;           \
  |  |  ------------------
  |  |  |  Branch (235:9): [True: 0, False: 2.30k]
  |  |  ------------------
  |  |  236|  2.30k|    if (func##_last_cpuinfo_used != VP8GetCPUInfo) func(); \
  |  |  ------------------
  |  |  |  Branch (236:9): [True: 1, False: 2.30k]
  |  |  ------------------
  |  |  237|  2.30k|    func##_last_cpuinfo_used = VP8GetCPUInfo;              \
  |  |  238|  2.30k|    (void)pthread_mutex_unlock(&func##_lock);              \
  |  |  239|  2.30k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (239:12): [Folded, False: 2.30k]
  |  |  ------------------
  ------------------
WebPInitSamplers:
  266|  2.30k|  WEBP_TSAN_IGNORE_FUNCTION void name(void) { WEBP_DSP_INIT(name##_body); } \
  ------------------
  |  |  234|  2.30k|  do {                                                     \
  |  |  235|  2.30k|    if (pthread_mutex_lock(&func##_lock)) break;           \
  |  |  ------------------
  |  |  |  Branch (235:9): [True: 0, False: 2.30k]
  |  |  ------------------
  |  |  236|  2.30k|    if (func##_last_cpuinfo_used != VP8GetCPUInfo) func(); \
  |  |  ------------------
  |  |  |  Branch (236:9): [True: 1, False: 2.30k]
  |  |  ------------------
  |  |  237|  2.30k|    func##_last_cpuinfo_used = VP8GetCPUInfo;              \
  |  |  238|  2.30k|    (void)pthread_mutex_unlock(&func##_lock);              \
  |  |  239|  2.30k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (239:12): [Folded, False: 2.30k]
  |  |  ------------------
  ------------------
WebPInitGammaTables:
  266|  13.9k|  WEBP_TSAN_IGNORE_FUNCTION void name(void) { WEBP_DSP_INIT(name##_body); } \
  ------------------
  |  |  234|  13.9k|  do {                                                     \
  |  |  235|  13.9k|    if (pthread_mutex_lock(&func##_lock)) break;           \
  |  |  ------------------
  |  |  |  Branch (235:9): [True: 0, False: 13.9k]
  |  |  ------------------
  |  |  236|  13.9k|    if (func##_last_cpuinfo_used != VP8GetCPUInfo) func(); \
  |  |  ------------------
  |  |  |  Branch (236:9): [True: 1, False: 13.9k]
  |  |  ------------------
  |  |  237|  13.9k|    func##_last_cpuinfo_used = VP8GetCPUInfo;              \
  |  |  238|  13.9k|    (void)pthread_mutex_unlock(&func##_lock);              \
  |  |  239|  13.9k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (239:12): [Folded, False: 13.9k]
  |  |  ------------------
  ------------------
WebPInitConvertARGBToYUV:
  266|    297|  WEBP_TSAN_IGNORE_FUNCTION void name(void) { WEBP_DSP_INIT(name##_body); } \
  ------------------
  |  |  234|    297|  do {                                                     \
  |  |  235|    297|    if (pthread_mutex_lock(&func##_lock)) break;           \
  |  |  ------------------
  |  |  |  Branch (235:9): [True: 0, False: 297]
  |  |  ------------------
  |  |  236|    297|    if (func##_last_cpuinfo_used != VP8GetCPUInfo) func(); \
  |  |  ------------------
  |  |  |  Branch (236:9): [True: 1, False: 296]
  |  |  ------------------
  |  |  237|    297|    func##_last_cpuinfo_used = VP8GetCPUInfo;              \
  |  |  238|    297|    (void)pthread_mutex_unlock(&func##_lock);              \
  |  |  239|    297|  } while (0)
  |  |  ------------------
  |  |  |  Branch (239:12): [Folded, False: 297]
  |  |  ------------------
  ------------------

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.87k|                           int16_t* WEBP_RESTRICT out) {
  150|  2.87k|  int tmp[16];
  151|  2.87k|  int i;
  152|  14.3k|  for (i = 0; i < 4; ++i) {
  ------------------
  |  Branch (152:15): [True: 11.4k, False: 2.87k]
  ------------------
  153|  11.4k|    const int a0 = in[0 + i] + in[12 + i];
  154|  11.4k|    const int a1 = in[4 + i] + in[8 + i];
  155|  11.4k|    const int a2 = in[4 + i] - in[8 + i];
  156|  11.4k|    const int a3 = in[0 + i] - in[12 + i];
  157|  11.4k|    tmp[0 + i] = a0 + a1;
  158|  11.4k|    tmp[8 + i] = a0 - a1;
  159|  11.4k|    tmp[4 + i] = a3 + a2;
  160|  11.4k|    tmp[12 + i] = a3 - a2;
  161|  11.4k|  }
  162|  14.3k|  for (i = 0; i < 4; ++i) {
  ------------------
  |  Branch (162:15): [True: 11.4k, False: 2.87k]
  ------------------
  163|  11.4k|    const int dc = tmp[0 + i * 4] + 3;  // w/ rounder
  164|  11.4k|    const int a0 = dc + tmp[3 + i * 4];
  165|  11.4k|    const int a1 = tmp[1 + i * 4] + tmp[2 + i * 4];
  166|  11.4k|    const int a2 = tmp[1 + i * 4] - tmp[2 + i * 4];
  167|  11.4k|    const int a3 = dc - tmp[3 + i * 4];
  168|  11.4k|    out[0] = (a0 + a1) >> 3;
  169|  11.4k|    out[16] = (a3 + a2) >> 3;
  170|  11.4k|    out[32] = (a0 - a1) >> 3;
  171|  11.4k|    out[48] = (a3 - a2) >> 3;
  172|  11.4k|    out += 64;
  173|  11.4k|  }
  174|  2.87k|}
dec.c:clip_8b:
   27|  2.16M|static WEBP_INLINE uint8_t clip_8b(int v) {
   28|  2.16M|  return (!(v & ~0xff)) ? v : (v < 0) ? 0 : 255;
  ------------------
  |  Branch (28:10): [True: 1.95M, False: 208k]
  |  Branch (28:31): [True: 101k, False: 106k]
  ------------------
   29|  2.16M|}
dec.c:TransformDC_C:
  123|   116k|                          uint8_t* WEBP_RESTRICT dst) {
  124|   116k|  const int DC = in[0] + 4;
  125|   116k|  int i, j;
  126|   584k|  for (j = 0; j < 4; ++j) {
  ------------------
  |  Branch (126:15): [True: 467k, False: 116k]
  ------------------
  127|  2.33M|    for (i = 0; i < 4; ++i) {
  ------------------
  |  Branch (127:17): [True: 1.87M, False: 467k]
  ------------------
  128|  1.87M|      STORE(i, j, DC);
  ------------------
  |  |   35|  1.87M|  dst[(x) + (y) * BPS] = clip_8b(dst[(x) + (y) * BPS] + ((v) >> 3))
  |  |  ------------------
  |  |  |  |   33|  1.87M|#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.87M|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
  129|  1.87M|    }
  130|   467k|  }
  131|   116k|}
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]);
  ------------------
  |  |  229|  18.5k|#define WEBP_TRANSFORM_AC3_MUL2(a) (((a) * WEBP_TRANSFORM_AC3_C2) >> 16)
  |  |  ------------------
  |  |  |  |  227|  18.5k|#define WEBP_TRANSFORM_AC3_C2 35468
  |  |  ------------------
  ------------------
   96|  18.5k|  const int d4 = WEBP_TRANSFORM_AC3_MUL1(in[4]);
  ------------------
  |  |  228|  18.5k|#define WEBP_TRANSFORM_AC3_MUL1(a) ((((a) * WEBP_TRANSFORM_AC3_C1) >> 16) + (a))
  |  |  ------------------
  |  |  |  |  226|  18.5k|#define WEBP_TRANSFORM_AC3_C1 20091
  |  |  ------------------
  ------------------
   97|  18.5k|  const int c1 = WEBP_TRANSFORM_AC3_MUL2(in[1]);
  ------------------
  |  |  229|  18.5k|#define WEBP_TRANSFORM_AC3_MUL2(a) (((a) * WEBP_TRANSFORM_AC3_C2) >> 16)
  |  |  ------------------
  |  |  |  |  227|  18.5k|#define WEBP_TRANSFORM_AC3_C2 35468
  |  |  ------------------
  ------------------
   98|  18.5k|  const int d1 = WEBP_TRANSFORM_AC3_MUL1(in[1]);
  ------------------
  |  |  228|  18.5k|#define WEBP_TRANSFORM_AC3_MUL1(a) ((((a) * WEBP_TRANSFORM_AC3_C1) >> 16) + (a))
  |  |  ------------------
  |  |  |  |  226|  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|  13.6k|                          uint8_t* WEBP_RESTRICT dst) {
  117|  13.6k|  VP8Transform(in + 0 * 16, dst, 1);
  118|  13.6k|  VP8Transform(in + 2 * 16, dst + 4 * BPS, 1);
  ------------------
  |  |   33|  13.6k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  119|  13.6k|}
dec.c:TransformDCUV_C:
  135|  12.1k|                            uint8_t* WEBP_RESTRICT dst) {
  136|  12.1k|  if (in[0 * 16]) VP8TransformDC(in + 0 * 16, dst);
  ------------------
  |  Branch (136:7): [True: 5.86k, False: 6.28k]
  ------------------
  137|  12.1k|  if (in[1 * 16]) VP8TransformDC(in + 1 * 16, dst + 4);
  ------------------
  |  Branch (137:7): [True: 5.80k, False: 6.33k]
  ------------------
  138|  12.1k|  if (in[2 * 16]) VP8TransformDC(in + 2 * 16, dst + 4 * BPS);
  ------------------
  |  |   33|  5.63k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  |  Branch (138:7): [True: 5.63k, False: 6.51k]
  ------------------
  139|  12.1k|  if (in[3 * 16]) VP8TransformDC(in + 3 * 16, dst + 4 * BPS + 4);
  ------------------
  |  |   33|  5.97k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  |  Branch (139:7): [True: 5.97k, False: 6.17k]
  ------------------
  140|  12.1k|}
dec.c:DC4_C:
  296|   223k|static void DC4_C(uint8_t* dst) {  // DC
  297|   223k|  uint32_t dc = 4;
  298|   223k|  int i;
  299|  1.11M|  for (i = 0; i < 4; ++i) dc += dst[i - BPS] + dst[-1 + i * BPS];
  ------------------
  |  |   33|   893k|#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|   893k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  |  Branch (299:15): [True: 893k, False: 223k]
  ------------------
  300|   223k|  dc >>= 3;
  301|  1.11M|  for (i = 0; i < 4; ++i) memset(dst + i * BPS, dc, 4);
  ------------------
  |  |   33|   893k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  |  Branch (301:15): [True: 893k, False: 223k]
  ------------------
  302|   223k|}
dec.c:HE4_C:
  283|  5.22k|static void HE4_C(uint8_t* dst) {  // horizontal
  284|  5.22k|  const int A = dst[-1 - BPS];
  ------------------
  |  |   33|  5.22k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  285|  5.22k|  const int B = dst[-1];
  286|  5.22k|  const int C = dst[-1 + BPS];
  ------------------
  |  |   33|  5.22k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  287|  5.22k|  const int D = dst[-1 + 2 * BPS];
  ------------------
  |  |   33|  5.22k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  288|  5.22k|  const int E = dst[-1 + 3 * BPS];
  ------------------
  |  |   33|  5.22k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  289|  5.22k|  WebPUint32ToMem(dst + 0 * BPS, 0x01010101U * AVG3(A, B, C));
  ------------------
  |  |   33|  5.22k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
                WebPUint32ToMem(dst + 0 * BPS, 0x01010101U * AVG3(A, B, C));
  ------------------
  |  |  264|  5.22k|#define AVG3(a, b, c) ((uint8_t)(((a) + 2 * (b) + (c) + 2) >> 2))
  ------------------
  290|  5.22k|  WebPUint32ToMem(dst + 1 * BPS, 0x01010101U * AVG3(B, C, D));
  ------------------
  |  |   33|  5.22k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
                WebPUint32ToMem(dst + 1 * BPS, 0x01010101U * AVG3(B, C, D));
  ------------------
  |  |  264|  5.22k|#define AVG3(a, b, c) ((uint8_t)(((a) + 2 * (b) + (c) + 2) >> 2))
  ------------------
  291|  5.22k|  WebPUint32ToMem(dst + 2 * BPS, 0x01010101U * AVG3(C, D, E));
  ------------------
  |  |   33|  5.22k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
                WebPUint32ToMem(dst + 2 * BPS, 0x01010101U * AVG3(C, D, E));
  ------------------
  |  |  264|  5.22k|#define AVG3(a, b, c) ((uint8_t)(((a) + 2 * (b) + (c) + 2) >> 2))
  ------------------
  292|  5.22k|  WebPUint32ToMem(dst + 3 * BPS, 0x01010101U * AVG3(D, E, E));
  ------------------
  |  |   33|  5.22k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
                WebPUint32ToMem(dst + 3 * BPS, 0x01010101U * AVG3(D, E, E));
  ------------------
  |  |  264|  5.22k|#define AVG3(a, b, c) ((uint8_t)(((a) + 2 * (b) + (c) + 2) >> 2))
  ------------------
  293|  5.22k|}
dec.c:HD4_C:
  400|  2.27k|static void HD4_C(uint8_t* dst) {  // Horizontal-Down
  401|  2.27k|  const int I = dst[-1 + 0 * BPS];
  ------------------
  |  |   33|  2.27k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  402|  2.27k|  const int J = dst[-1 + 1 * BPS];
  ------------------
  |  |   33|  2.27k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  403|  2.27k|  const int K = dst[-1 + 2 * BPS];
  ------------------
  |  |   33|  2.27k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  404|  2.27k|  const int L = dst[-1 + 3 * BPS];
  ------------------
  |  |   33|  2.27k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  405|  2.27k|  const int X = dst[-1 - BPS];
  ------------------
  |  |   33|  2.27k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  406|  2.27k|  const int A = dst[0 - BPS];
  ------------------
  |  |   33|  2.27k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  407|  2.27k|  const int B = dst[1 - BPS];
  ------------------
  |  |   33|  2.27k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  408|  2.27k|  const int C = dst[2 - BPS];
  ------------------
  |  |   33|  2.27k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  409|       |
  410|  2.27k|  DST(0, 0) = DST(2, 1) = AVG2(I, X);
  ------------------
  |  |  182|  2.27k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  2.27k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(0, 0) = DST(2, 1) = AVG2(I, X);
  ------------------
  |  |  182|  2.27k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  2.27k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(0, 0) = DST(2, 1) = AVG2(I, X);
  ------------------
  |  |  265|  2.27k|#define AVG2(a, b) (((a) + (b) + 1) >> 1)
  ------------------
  411|  2.27k|  DST(0, 1) = DST(2, 2) = AVG2(J, I);
  ------------------
  |  |  182|  2.27k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  2.27k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(0, 1) = DST(2, 2) = AVG2(J, I);
  ------------------
  |  |  182|  2.27k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  2.27k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(0, 1) = DST(2, 2) = AVG2(J, I);
  ------------------
  |  |  265|  2.27k|#define AVG2(a, b) (((a) + (b) + 1) >> 1)
  ------------------
  412|  2.27k|  DST(0, 2) = DST(2, 3) = AVG2(K, J);
  ------------------
  |  |  182|  2.27k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  2.27k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(0, 2) = DST(2, 3) = AVG2(K, J);
  ------------------
  |  |  182|  2.27k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  2.27k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(0, 2) = DST(2, 3) = AVG2(K, J);
  ------------------
  |  |  265|  2.27k|#define AVG2(a, b) (((a) + (b) + 1) >> 1)
  ------------------
  413|  2.27k|  DST(0, 3) = AVG2(L, K);
  ------------------
  |  |  182|  2.27k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  2.27k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(0, 3) = AVG2(L, K);
  ------------------
  |  |  265|  2.27k|#define AVG2(a, b) (((a) + (b) + 1) >> 1)
  ------------------
  414|       |
  415|  2.27k|  DST(3, 0) = AVG3(A, B, C);
  ------------------
  |  |  182|  2.27k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  2.27k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(3, 0) = AVG3(A, B, C);
  ------------------
  |  |  264|  2.27k|#define AVG3(a, b, c) ((uint8_t)(((a) + 2 * (b) + (c) + 2) >> 2))
  ------------------
  416|  2.27k|  DST(2, 0) = AVG3(X, A, B);
  ------------------
  |  |  182|  2.27k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  2.27k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(2, 0) = AVG3(X, A, B);
  ------------------
  |  |  264|  2.27k|#define AVG3(a, b, c) ((uint8_t)(((a) + 2 * (b) + (c) + 2) >> 2))
  ------------------
  417|  2.27k|  DST(1, 0) = DST(3, 1) = AVG3(I, X, A);
  ------------------
  |  |  182|  2.27k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  2.27k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(1, 0) = DST(3, 1) = AVG3(I, X, A);
  ------------------
  |  |  182|  2.27k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  2.27k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(1, 0) = DST(3, 1) = AVG3(I, X, A);
  ------------------
  |  |  264|  2.27k|#define AVG3(a, b, c) ((uint8_t)(((a) + 2 * (b) + (c) + 2) >> 2))
  ------------------
  418|  2.27k|  DST(1, 1) = DST(3, 2) = AVG3(J, I, X);
  ------------------
  |  |  182|  2.27k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  2.27k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(1, 1) = DST(3, 2) = AVG3(J, I, X);
  ------------------
  |  |  182|  2.27k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  2.27k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(1, 1) = DST(3, 2) = AVG3(J, I, X);
  ------------------
  |  |  264|  2.27k|#define AVG3(a, b, c) ((uint8_t)(((a) + 2 * (b) + (c) + 2) >> 2))
  ------------------
  419|  2.27k|  DST(1, 2) = DST(3, 3) = AVG3(K, J, I);
  ------------------
  |  |  182|  2.27k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  2.27k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(1, 2) = DST(3, 3) = AVG3(K, J, I);
  ------------------
  |  |  182|  2.27k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  2.27k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(1, 2) = DST(3, 3) = AVG3(K, J, I);
  ------------------
  |  |  264|  2.27k|#define AVG3(a, b, c) ((uint8_t)(((a) + 2 * (b) + (c) + 2) >> 2))
  ------------------
  420|  2.27k|  DST(1, 3) = AVG3(L, K, J);
  ------------------
  |  |  182|  2.27k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  2.27k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(1, 3) = AVG3(L, K, J);
  ------------------
  |  |  264|  2.27k|#define AVG3(a, b, c) ((uint8_t)(((a) + 2 * (b) + (c) + 2) >> 2))
  ------------------
  421|  2.27k|}
dec.c:HU4_C:
  386|  3.93k|static void HU4_C(uint8_t* dst) {  // Horizontal-Up
  387|  3.93k|  const int I = dst[-1 + 0 * BPS];
  ------------------
  |  |   33|  3.93k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  388|  3.93k|  const int J = dst[-1 + 1 * BPS];
  ------------------
  |  |   33|  3.93k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  389|  3.93k|  const int K = dst[-1 + 2 * BPS];
  ------------------
  |  |   33|  3.93k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  390|  3.93k|  const int L = dst[-1 + 3 * BPS];
  ------------------
  |  |   33|  3.93k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  391|  3.93k|  DST(0, 0) = AVG2(I, J);
  ------------------
  |  |  182|  3.93k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  3.93k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(0, 0) = AVG2(I, J);
  ------------------
  |  |  265|  3.93k|#define AVG2(a, b) (((a) + (b) + 1) >> 1)
  ------------------
  392|  3.93k|  DST(2, 0) = DST(0, 1) = AVG2(J, K);
  ------------------
  |  |  182|  3.93k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  3.93k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(2, 0) = DST(0, 1) = AVG2(J, K);
  ------------------
  |  |  182|  3.93k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  3.93k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(2, 0) = DST(0, 1) = AVG2(J, K);
  ------------------
  |  |  265|  3.93k|#define AVG2(a, b) (((a) + (b) + 1) >> 1)
  ------------------
  393|  3.93k|  DST(2, 1) = DST(0, 2) = AVG2(K, L);
  ------------------
  |  |  182|  3.93k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  3.93k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(2, 1) = DST(0, 2) = AVG2(K, L);
  ------------------
  |  |  182|  3.93k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  3.93k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(2, 1) = DST(0, 2) = AVG2(K, L);
  ------------------
  |  |  265|  3.93k|#define AVG2(a, b) (((a) + (b) + 1) >> 1)
  ------------------
  394|  3.93k|  DST(1, 0) = AVG3(I, J, K);
  ------------------
  |  |  182|  3.93k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  3.93k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(1, 0) = AVG3(I, J, K);
  ------------------
  |  |  264|  3.93k|#define AVG3(a, b, c) ((uint8_t)(((a) + 2 * (b) + (c) + 2) >> 2))
  ------------------
  395|  3.93k|  DST(3, 0) = DST(1, 1) = AVG3(J, K, L);
  ------------------
  |  |  182|  3.93k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  3.93k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(3, 0) = DST(1, 1) = AVG3(J, K, L);
  ------------------
  |  |  182|  3.93k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  3.93k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(3, 0) = DST(1, 1) = AVG3(J, K, L);
  ------------------
  |  |  264|  3.93k|#define AVG3(a, b, c) ((uint8_t)(((a) + 2 * (b) + (c) + 2) >> 2))
  ------------------
  396|  3.93k|  DST(3, 1) = DST(1, 2) = AVG3(K, L, L);
  ------------------
  |  |  182|  3.93k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  3.93k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(3, 1) = DST(1, 2) = AVG3(K, L, L);
  ------------------
  |  |  182|  3.93k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  3.93k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(3, 1) = DST(1, 2) = AVG3(K, L, L);
  ------------------
  |  |  264|  3.93k|#define AVG3(a, b, c) ((uint8_t)(((a) + 2 * (b) + (c) + 2) >> 2))
  ------------------
  397|  3.93k|  DST(3, 2) = DST(2, 2) = DST(0, 3) = DST(1, 3) = DST(2, 3) = DST(3, 3) = L;
  ------------------
  |  |  182|  3.93k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  3.93k|#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|  3.93k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  3.93k|#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|  3.93k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  3.93k|#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|  3.93k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  3.93k|#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|  3.93k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  3.93k|#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|  3.93k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  3.93k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
  398|  3.93k|}
dec.c:HE8uv_C:
  440|  12.0k|static void HE8uv_C(uint8_t* dst) {  // horizontal
  441|  12.0k|  int j;
  442|   108k|  for (j = 0; j < 8; ++j) {
  ------------------
  |  Branch (442:15): [True: 96.7k, False: 12.0k]
  ------------------
  443|  96.7k|    memset(dst, dst[-1], 8);
  444|  96.7k|    dst += BPS;
  ------------------
  |  |   33|  96.7k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  445|  96.7k|  }
  446|  12.0k|}

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|  43.6k|                           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 = 85267  =>  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|  43.6k|  const __m128i k1 = _mm_set1_epi16(20091);
   55|  43.6k|  const __m128i k2 = _mm_set1_epi16(-30068);
   56|  43.6k|  __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|  43.6k|  __m128i in0, in1, in2, in3;
   62|  43.6k|  {
   63|  43.6k|    in0 = _mm_loadl_epi64((const __m128i*)&in[0]);
   64|  43.6k|    in1 = _mm_loadl_epi64((const __m128i*)&in[4]);
   65|  43.6k|    in2 = _mm_loadl_epi64((const __m128i*)&in[8]);
   66|  43.6k|    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|  43.6k|    if (do_two) {
  ------------------
  |  Branch (71:9): [True: 27.2k, False: 16.3k]
  ------------------
   72|  27.2k|      const __m128i inB0 = _mm_loadl_epi64((const __m128i*)&in[16]);
   73|  27.2k|      const __m128i inB1 = _mm_loadl_epi64((const __m128i*)&in[20]);
   74|  27.2k|      const __m128i inB2 = _mm_loadl_epi64((const __m128i*)&in[24]);
   75|  27.2k|      const __m128i inB3 = _mm_loadl_epi64((const __m128i*)&in[28]);
   76|  27.2k|      in0 = _mm_unpacklo_epi64(in0, inB0);
   77|  27.2k|      in1 = _mm_unpacklo_epi64(in1, inB1);
   78|  27.2k|      in2 = _mm_unpacklo_epi64(in2, inB2);
   79|  27.2k|      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|  27.2k|    }
   85|  43.6k|  }
   86|       |
   87|       |  // Vertical pass and subsequent transpose.
   88|  43.6k|  {
   89|       |    // First pass, c and d calculations are longer because of the "trick"
   90|       |    // multiplications.
   91|  43.6k|    const __m128i a = _mm_add_epi16(in0, in2);
   92|  43.6k|    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|  43.6k|    const __m128i c1 = _mm_mulhi_epi16(in1, k2);
   95|  43.6k|    const __m128i c2 = _mm_mulhi_epi16(in3, k1);
   96|  43.6k|    const __m128i c3 = _mm_sub_epi16(in1, in3);
   97|  43.6k|    const __m128i c4 = _mm_sub_epi16(c1, c2);
   98|  43.6k|    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|  43.6k|    const __m128i d1 = _mm_mulhi_epi16(in1, k1);
  101|  43.6k|    const __m128i d2 = _mm_mulhi_epi16(in3, k2);
  102|  43.6k|    const __m128i d3 = _mm_add_epi16(in1, in3);
  103|  43.6k|    const __m128i d4 = _mm_add_epi16(d1, d2);
  104|  43.6k|    const __m128i d = _mm_add_epi16(d3, d4);
  105|       |
  106|       |    // Second pass.
  107|  43.6k|    const __m128i tmp0 = _mm_add_epi16(a, d);
  108|  43.6k|    const __m128i tmp1 = _mm_add_epi16(b, c);
  109|  43.6k|    const __m128i tmp2 = _mm_sub_epi16(b, c);
  110|  43.6k|    const __m128i tmp3 = _mm_sub_epi16(a, d);
  111|       |
  112|       |    // Transpose the two 4x4.
  113|  43.6k|    VP8Transpose_2_4x4_16b(&tmp0, &tmp1, &tmp2, &tmp3, &T0, &T1, &T2, &T3);
  114|  43.6k|  }
  115|       |
  116|       |  // Horizontal pass and subsequent transpose.
  117|  43.6k|  {
  118|       |    // First pass, c and d calculations are longer because of the "trick"
  119|       |    // multiplications.
  120|  43.6k|    const __m128i four = _mm_set1_epi16(4);
  121|  43.6k|    const __m128i dc = _mm_add_epi16(T0, four);
  122|  43.6k|    const __m128i a = _mm_add_epi16(dc, T2);
  123|  43.6k|    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|  43.6k|    const __m128i c1 = _mm_mulhi_epi16(T1, k2);
  126|  43.6k|    const __m128i c2 = _mm_mulhi_epi16(T3, k1);
  127|  43.6k|    const __m128i c3 = _mm_sub_epi16(T1, T3);
  128|  43.6k|    const __m128i c4 = _mm_sub_epi16(c1, c2);
  129|  43.6k|    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|  43.6k|    const __m128i d1 = _mm_mulhi_epi16(T1, k1);
  132|  43.6k|    const __m128i d2 = _mm_mulhi_epi16(T3, k2);
  133|  43.6k|    const __m128i d3 = _mm_add_epi16(T1, T3);
  134|  43.6k|    const __m128i d4 = _mm_add_epi16(d1, d2);
  135|  43.6k|    const __m128i d = _mm_add_epi16(d3, d4);
  136|       |
  137|       |    // Second pass.
  138|  43.6k|    const __m128i tmp0 = _mm_add_epi16(a, d);
  139|  43.6k|    const __m128i tmp1 = _mm_add_epi16(b, c);
  140|  43.6k|    const __m128i tmp2 = _mm_sub_epi16(b, c);
  141|  43.6k|    const __m128i tmp3 = _mm_sub_epi16(a, d);
  142|  43.6k|    const __m128i shifted0 = _mm_srai_epi16(tmp0, 3);
  143|  43.6k|    const __m128i shifted1 = _mm_srai_epi16(tmp1, 3);
  144|  43.6k|    const __m128i shifted2 = _mm_srai_epi16(tmp2, 3);
  145|  43.6k|    const __m128i shifted3 = _mm_srai_epi16(tmp3, 3);
  146|       |
  147|       |    // Transpose the two 4x4.
  148|  43.6k|    VP8Transpose_2_4x4_16b(&shifted0, &shifted1, &shifted2, &shifted3, &T0, &T1,
  149|  43.6k|                           &T2, &T3);
  150|  43.6k|  }
  151|       |
  152|       |  // Add inverse transform to 'dst' and store.
  153|  43.6k|  {
  154|  43.6k|    const __m128i zero = _mm_setzero_si128();
  155|       |    // Load the reference(s).
  156|  43.6k|    __m128i dst0, dst1, dst2, dst3;
  157|  43.6k|    if (do_two) {
  ------------------
  |  Branch (157:9): [True: 27.2k, False: 16.3k]
  ------------------
  158|       |      // Load eight bytes/pixels per line.
  159|  27.2k|      dst0 = _mm_loadl_epi64((__m128i*)(dst + 0 * BPS));
  ------------------
  |  |   33|  27.2k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  160|  27.2k|      dst1 = _mm_loadl_epi64((__m128i*)(dst + 1 * BPS));
  ------------------
  |  |   33|  27.2k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  161|  27.2k|      dst2 = _mm_loadl_epi64((__m128i*)(dst + 2 * BPS));
  ------------------
  |  |   33|  27.2k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  162|  27.2k|      dst3 = _mm_loadl_epi64((__m128i*)(dst + 3 * BPS));
  ------------------
  |  |   33|  27.2k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  163|  27.2k|    } else {
  164|       |      // Load four bytes/pixels per line.
  165|  16.3k|      dst0 = _mm_cvtsi32_si128(WebPMemToInt32(dst + 0 * BPS));
  ------------------
  |  |   33|  16.3k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  166|  16.3k|      dst1 = _mm_cvtsi32_si128(WebPMemToInt32(dst + 1 * BPS));
  ------------------
  |  |   33|  16.3k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  167|  16.3k|      dst2 = _mm_cvtsi32_si128(WebPMemToInt32(dst + 2 * BPS));
  ------------------
  |  |   33|  16.3k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  168|  16.3k|      dst3 = _mm_cvtsi32_si128(WebPMemToInt32(dst + 3 * BPS));
  ------------------
  |  |   33|  16.3k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  169|  16.3k|    }
  170|       |    // Convert to 16b.
  171|  43.6k|    dst0 = _mm_unpacklo_epi8(dst0, zero);
  172|  43.6k|    dst1 = _mm_unpacklo_epi8(dst1, zero);
  173|  43.6k|    dst2 = _mm_unpacklo_epi8(dst2, zero);
  174|  43.6k|    dst3 = _mm_unpacklo_epi8(dst3, zero);
  175|       |    // Add the inverse transform(s).
  176|  43.6k|    dst0 = _mm_add_epi16(dst0, T0);
  177|  43.6k|    dst1 = _mm_add_epi16(dst1, T1);
  178|  43.6k|    dst2 = _mm_add_epi16(dst2, T2);
  179|  43.6k|    dst3 = _mm_add_epi16(dst3, T3);
  180|       |    // Unsigned saturate to 8b.
  181|  43.6k|    dst0 = _mm_packus_epi16(dst0, dst0);
  182|  43.6k|    dst1 = _mm_packus_epi16(dst1, dst1);
  183|  43.6k|    dst2 = _mm_packus_epi16(dst2, dst2);
  184|  43.6k|    dst3 = _mm_packus_epi16(dst3, dst3);
  185|       |    // Store the results.
  186|  43.6k|    if (do_two) {
  ------------------
  |  Branch (186:9): [True: 27.2k, False: 16.3k]
  ------------------
  187|       |      // Store eight bytes/pixels per line.
  188|  27.2k|      _mm_storel_epi64((__m128i*)(dst + 0 * BPS), dst0);
  ------------------
  |  |   33|  27.2k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  189|  27.2k|      _mm_storel_epi64((__m128i*)(dst + 1 * BPS), dst1);
  ------------------
  |  |   33|  27.2k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  190|  27.2k|      _mm_storel_epi64((__m128i*)(dst + 2 * BPS), dst2);
  ------------------
  |  |   33|  27.2k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  191|  27.2k|      _mm_storel_epi64((__m128i*)(dst + 3 * BPS), dst3);
  ------------------
  |  |   33|  27.2k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  192|  27.2k|    } else {
  193|       |      // Store four bytes/pixels per line.
  194|  16.3k|      WebPInt32ToMem(dst + 0 * BPS, _mm_cvtsi128_si32(dst0));
  ------------------
  |  |   33|  16.3k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  195|  16.3k|      WebPInt32ToMem(dst + 1 * BPS, _mm_cvtsi128_si32(dst1));
  ------------------
  |  |   33|  16.3k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  196|  16.3k|      WebPInt32ToMem(dst + 2 * BPS, _mm_cvtsi128_si32(dst2));
  ------------------
  |  |   33|  16.3k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  197|  16.3k|      WebPInt32ToMem(dst + 3 * BPS, _mm_cvtsi128_si32(dst3));
  ------------------
  |  |   33|  16.3k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  198|  16.3k|    }
  199|  43.6k|  }
  200|  43.6k|}
dec_sse2.c:VFilter16_SSE2:
  697|  18.6k|                           int hev_thresh) {
  698|  18.6k|  __m128i t1;
  699|  18.6k|  __m128i mask;
  700|  18.6k|  __m128i p2, p1, p0, q0, q1, q2;
  701|       |
  702|       |  // Load p3, p2, p1, p0
  703|  18.6k|  LOAD_H_EDGES4(p - 4 * stride, stride, t1, p2, p1, p0);
  ------------------
  |  |  653|  18.6k|  do {                                                    \
  |  |  654|  18.6k|    (e1) = _mm_loadu_si128((__m128i*)&(p)[0 * (stride)]); \
  |  |  655|  18.6k|    (e2) = _mm_loadu_si128((__m128i*)&(p)[1 * (stride)]); \
  |  |  656|  18.6k|    (e3) = _mm_loadu_si128((__m128i*)&(p)[2 * (stride)]); \
  |  |  657|  18.6k|    (e4) = _mm_loadu_si128((__m128i*)&(p)[3 * (stride)]); \
  |  |  658|  18.6k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (658:12): [Folded, False: 18.6k]
  |  |  ------------------
  ------------------
  704|  18.6k|  MAX_DIFF1(t1, p2, p1, p0, mask);
  ------------------
  |  |  639|  18.6k|  do {                                     \
  |  |  640|  18.6k|    (m) = MM_ABS(p1, p0);                  \
  |  |  ------------------
  |  |  |  |  252|  18.6k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  641|  18.6k|    (m) = _mm_max_epu8(m, MM_ABS(p3, p2)); \
  |  |  ------------------
  |  |  |  |  252|  18.6k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  642|  18.6k|    (m) = _mm_max_epu8(m, MM_ABS(p2, p1)); \
  |  |  ------------------
  |  |  |  |  252|  18.6k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  643|  18.6k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (643:12): [Folded, False: 18.6k]
  |  |  ------------------
  ------------------
  705|       |
  706|       |  // Load q0, q1, q2, q3
  707|  18.6k|  LOAD_H_EDGES4(p, stride, q0, q1, q2, t1);
  ------------------
  |  |  653|  18.6k|  do {                                                    \
  |  |  654|  18.6k|    (e1) = _mm_loadu_si128((__m128i*)&(p)[0 * (stride)]); \
  |  |  655|  18.6k|    (e2) = _mm_loadu_si128((__m128i*)&(p)[1 * (stride)]); \
  |  |  656|  18.6k|    (e3) = _mm_loadu_si128((__m128i*)&(p)[2 * (stride)]); \
  |  |  657|  18.6k|    (e4) = _mm_loadu_si128((__m128i*)&(p)[3 * (stride)]); \
  |  |  658|  18.6k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (658:12): [Folded, False: 18.6k]
  |  |  ------------------
  ------------------
  708|  18.6k|  MAX_DIFF2(t1, q2, q1, q0, mask);
  ------------------
  |  |  646|  18.6k|  do {                                     \
  |  |  647|  18.6k|    (m) = _mm_max_epu8(m, MM_ABS(p1, p0)); \
  |  |  ------------------
  |  |  |  |  252|  18.6k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  648|  18.6k|    (m) = _mm_max_epu8(m, MM_ABS(p3, p2)); \
  |  |  ------------------
  |  |  |  |  252|  18.6k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  649|  18.6k|    (m) = _mm_max_epu8(m, MM_ABS(p2, p1)); \
  |  |  ------------------
  |  |  |  |  252|  18.6k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  650|  18.6k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (650:12): [Folded, False: 18.6k]
  |  |  ------------------
  ------------------
  709|       |
  710|  18.6k|  ComplexMask_SSE2(&p1, &p0, &q0, &q1, thresh, ithresh, &mask);
  711|  18.6k|  DoFilter6_SSE2(&p2, &p1, &p0, &q0, &q1, &q2, &mask, hev_thresh);
  712|       |
  713|       |  // Store
  714|  18.6k|  _mm_storeu_si128((__m128i*)&p[-3 * stride], p2);
  715|  18.6k|  _mm_storeu_si128((__m128i*)&p[-2 * stride], p1);
  716|  18.6k|  _mm_storeu_si128((__m128i*)&p[-1 * stride], p0);
  717|  18.6k|  _mm_storeu_si128((__m128i*)&p[+0 * stride], q0);
  718|  18.6k|  _mm_storeu_si128((__m128i*)&p[+1 * stride], q1);
  719|  18.6k|  _mm_storeu_si128((__m128i*)&p[+2 * stride], q2);
  720|  18.6k|}
dec_sse2.c:ComplexMask_SSE2:
  686|   184k|                                         int ithresh, __m128i* const mask) {
  687|   184k|  const __m128i it = _mm_set1_epi8(ithresh);
  688|   184k|  const __m128i diff = _mm_subs_epu8(*mask, it);
  689|   184k|  const __m128i thresh_mask = _mm_cmpeq_epi8(diff, _mm_setzero_si128());
  690|   184k|  __m128i filter_mask;
  691|   184k|  NeedsFilter_SSE2(p1, p0, q0, q1, thresh, &filter_mask);
  692|   184k|  *mask = _mm_and_si128(thresh_mask, filter_mask);
  693|   184k|}
dec_sse2.c:NeedsFilter_SSE2:
  344|   245k|                                         __m128i* const mask) {
  345|   245k|  const __m128i m_thresh = _mm_set1_epi8((char)thresh);
  346|   245k|  const __m128i t1 = MM_ABS(*p1, *q1);  // abs(p1 - q1)
  ------------------
  |  |  252|   245k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  ------------------
  347|   245k|  const __m128i kFE = _mm_set1_epi8((char)0xFE);
  348|   245k|  const __m128i t2 = _mm_and_si128(t1, kFE);  // set lsb of each byte to zero
  349|   245k|  const __m128i t3 = _mm_srli_epi16(t2, 1);   // abs(p1 - q1) / 2
  350|       |
  351|   245k|  const __m128i t4 = MM_ABS(*p0, *q0);       // abs(p0 - q0)
  ------------------
  |  |  252|   245k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  ------------------
  352|   245k|  const __m128i t5 = _mm_adds_epu8(t4, t4);  // abs(p0 - q0) * 2
  353|   245k|  const __m128i t6 = _mm_adds_epu8(t5, t3);  // abs(p0-q0)*2 + abs(p1-q1)/2
  354|       |
  355|   245k|  const __m128i t7 = _mm_subs_epu8(t6, m_thresh);  // mask <= m_thresh
  356|   245k|  *mask = _mm_cmpeq_epi8(t7, _mm_setzero_si128());
  357|   245k|}
dec_sse2.c:DoFilter6_SSE2:
  432|  50.7k|                                       int hev_thresh) {
  433|  50.7k|  const __m128i zero = _mm_setzero_si128();
  434|  50.7k|  const __m128i sign_bit = _mm_set1_epi8((char)0x80);
  435|  50.7k|  __m128i a, not_hev;
  436|       |
  437|       |  // compute hev mask
  438|  50.7k|  GetNotHEV_SSE2(p1, p0, q0, q1, hev_thresh, &not_hev);
  439|       |
  440|  50.7k|  FLIP_SIGN_BIT4(*p1, *p0, *q0, *q1);
  ------------------
  |  |  271|  50.7k|  do {                             \
  |  |  272|  50.7k|    FLIP_SIGN_BIT2(a, b);          \
  |  |  ------------------
  |  |  |  |  265|  50.7k|  do {                                \
  |  |  |  |  266|  50.7k|    (a) = _mm_xor_si128(a, sign_bit); \
  |  |  |  |  267|  50.7k|    (b) = _mm_xor_si128(b, sign_bit); \
  |  |  |  |  268|  50.7k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (268:12): [Folded, False: 50.7k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  273|  50.7k|    FLIP_SIGN_BIT2(c, d);          \
  |  |  ------------------
  |  |  |  |  265|  50.7k|  do {                                \
  |  |  |  |  266|  50.7k|    (a) = _mm_xor_si128(a, sign_bit); \
  |  |  |  |  267|  50.7k|    (b) = _mm_xor_si128(b, sign_bit); \
  |  |  |  |  268|  50.7k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (268:12): [Folded, False: 50.7k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  274|  50.7k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (274:12): [Folded, False: 50.7k]
  |  |  ------------------
  ------------------
  441|  50.7k|  FLIP_SIGN_BIT2(*p2, *q2);
  ------------------
  |  |  265|  50.7k|  do {                                \
  |  |  266|  50.7k|    (a) = _mm_xor_si128(a, sign_bit); \
  |  |  267|  50.7k|    (b) = _mm_xor_si128(b, sign_bit); \
  |  |  268|  50.7k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (268:12): [Folded, False: 50.7k]
  |  |  ------------------
  ------------------
  442|  50.7k|  GetBaseDelta_SSE2(p1, p0, q0, q1, &a);
  443|       |
  444|  50.7k|  {  // do simple filter on pixels with hev
  445|  50.7k|    const __m128i m = _mm_andnot_si128(not_hev, *mask);
  446|  50.7k|    const __m128i f = _mm_and_si128(a, m);
  447|  50.7k|    DoSimpleFilter_SSE2(p0, q0, &f);
  448|  50.7k|  }
  449|       |
  450|  50.7k|  {  // do strong filter on pixels with not hev
  451|  50.7k|    const __m128i k9 = _mm_set1_epi16(0x0900);
  452|  50.7k|    const __m128i k63 = _mm_set1_epi16(63);
  453|       |
  454|  50.7k|    const __m128i m = _mm_and_si128(not_hev, *mask);
  455|  50.7k|    const __m128i f = _mm_and_si128(a, m);
  456|       |
  457|  50.7k|    const __m128i f_lo = _mm_unpacklo_epi8(zero, f);
  458|  50.7k|    const __m128i f_hi = _mm_unpackhi_epi8(zero, f);
  459|       |
  460|  50.7k|    const __m128i f9_lo = _mm_mulhi_epi16(f_lo, k9);  // Filter (lo) * 9
  461|  50.7k|    const __m128i f9_hi = _mm_mulhi_epi16(f_hi, k9);  // Filter (hi) * 9
  462|       |
  463|  50.7k|    const __m128i a2_lo = _mm_add_epi16(f9_lo, k63);  // Filter * 9 + 63
  464|  50.7k|    const __m128i a2_hi = _mm_add_epi16(f9_hi, k63);  // Filter * 9 + 63
  465|       |
  466|  50.7k|    const __m128i a1_lo = _mm_add_epi16(a2_lo, f9_lo);  // Filter * 18 + 63
  467|  50.7k|    const __m128i a1_hi = _mm_add_epi16(a2_hi, f9_hi);  // Filter * 18 + 63
  468|       |
  469|  50.7k|    const __m128i a0_lo = _mm_add_epi16(a1_lo, f9_lo);  // Filter * 27 + 63
  470|  50.7k|    const __m128i a0_hi = _mm_add_epi16(a1_hi, f9_hi);  // Filter * 27 + 63
  471|       |
  472|  50.7k|    Update2Pixels_SSE2(p2, q2, &a2_lo, &a2_hi);
  473|  50.7k|    Update2Pixels_SSE2(p1, q1, &a1_lo, &a1_hi);
  474|  50.7k|    Update2Pixels_SSE2(p0, q0, &a0_lo, &a0_hi);
  475|  50.7k|  }
  476|  50.7k|}
dec_sse2.c:GetNotHEV_SSE2:
  281|   184k|                                       __m128i* const not_hev) {
  282|   184k|  const __m128i zero = _mm_setzero_si128();
  283|   184k|  const __m128i t_1 = MM_ABS(*p1, *p0);
  ------------------
  |  |  252|   184k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  ------------------
  284|   184k|  const __m128i t_2 = MM_ABS(*q1, *q0);
  ------------------
  |  |  252|   184k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  ------------------
  285|       |
  286|   184k|  const __m128i h = _mm_set1_epi8(hev_thresh);
  287|   184k|  const __m128i t_max = _mm_max_epu8(t_1, t_2);
  288|       |
  289|   184k|  const __m128i t_max_h = _mm_subs_epu8(t_max, h);
  290|   184k|  *not_hev = _mm_cmpeq_epi8(t_max_h, zero);  // not_hev <= t1 && not_hev <= t2
  291|   184k|}
dec_sse2.c:GetBaseDelta_SSE2:
  298|   111k|                                          __m128i* const delta) {
  299|       |  // beware of addition order, for saturation!
  300|   111k|  const __m128i p1_q1 = _mm_subs_epi8(*p1, *q1);   // p1 - q1
  301|   111k|  const __m128i q0_p0 = _mm_subs_epi8(*q0, *p0);   // q0 - p0
  302|   111k|  const __m128i s1 = _mm_adds_epi8(p1_q1, q0_p0);  // p1 - q1 + 1 * (q0 - p0)
  303|   111k|  const __m128i s2 = _mm_adds_epi8(q0_p0, s1);     // p1 - q1 + 2 * (q0 - p0)
  304|   111k|  const __m128i s3 = _mm_adds_epi8(q0_p0, s2);     // p1 - q1 + 3 * (q0 - p0)
  305|   111k|  *delta = s3;
  306|   111k|}
dec_sse2.c:DoSimpleFilter_SSE2:
  311|   111k|                                            const __m128i* const fl) {
  312|   111k|  const __m128i k3 = _mm_set1_epi8(3);
  313|   111k|  const __m128i k4 = _mm_set1_epi8(4);
  314|   111k|  __m128i v3 = _mm_adds_epi8(*fl, k3);
  315|   111k|  __m128i v4 = _mm_adds_epi8(*fl, k4);
  316|       |
  317|   111k|  SignedShift8b_SSE2(&v4);       // v4 >> 3
  318|   111k|  SignedShift8b_SSE2(&v3);       // v3 >> 3
  319|   111k|  *q0 = _mm_subs_epi8(*q0, v4);  // q0 -= v4
  320|   111k|  *p0 = _mm_adds_epi8(*p0, v3);  // p0 += v3
  321|   111k|}
dec_sse2.c:SignedShift8b_SSE2:
  255|   491k|static WEBP_INLINE void SignedShift8b_SSE2(__m128i* const x) {
  256|   491k|  const __m128i zero = _mm_setzero_si128();
  257|   491k|  const __m128i lo_0 = _mm_unpacklo_epi8(zero, *x);
  258|   491k|  const __m128i hi_0 = _mm_unpackhi_epi8(zero, *x);
  259|   491k|  const __m128i lo_1 = _mm_srai_epi16(lo_0, 3 + 8);
  260|   491k|  const __m128i hi_1 = _mm_srai_epi16(hi_0, 3 + 8);
  261|   491k|  *x = _mm_packs_epi16(lo_1, hi_1);
  262|   491k|}
dec_sse2.c:Update2Pixels_SSE2:
  329|   152k|                                           const __m128i* const a0_hi) {
  330|   152k|  const __m128i a1_lo = _mm_srai_epi16(*a0_lo, 7);
  331|   152k|  const __m128i a1_hi = _mm_srai_epi16(*a0_hi, 7);
  332|   152k|  const __m128i delta = _mm_packs_epi16(a1_lo, a1_hi);
  333|   152k|  const __m128i sign_bit = _mm_set1_epi8((char)0x80);
  334|   152k|  *pi = _mm_adds_epi8(*pi, delta);
  335|   152k|  *qi = _mm_subs_epi8(*qi, delta);
  336|   152k|  FLIP_SIGN_BIT2(*pi, *qi);
  ------------------
  |  |  265|   152k|  do {                                \
  |  |  266|   152k|    (a) = _mm_xor_si128(a, sign_bit); \
  |  |  267|   152k|    (b) = _mm_xor_si128(b, sign_bit); \
  |  |  268|   152k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (268:12): [Folded, False: 152k]
  |  |  ------------------
  ------------------
  337|   152k|}
dec_sse2.c:HFilter16_SSE2:
  723|  6.71k|                           int hev_thresh) {
  724|  6.71k|  __m128i mask;
  725|  6.71k|  __m128i p3, p2, p1, p0, q0, q1, q2, q3;
  726|       |
  727|  6.71k|  uint8_t* const b = p - 4;
  728|  6.71k|  Load16x4_SSE2(b, b + 8 * stride, stride, &p3, &p2, &p1, &p0);
  729|  6.71k|  MAX_DIFF1(p3, p2, p1, p0, mask);
  ------------------
  |  |  639|  6.71k|  do {                                     \
  |  |  640|  6.71k|    (m) = MM_ABS(p1, p0);                  \
  |  |  ------------------
  |  |  |  |  252|  6.71k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  641|  6.71k|    (m) = _mm_max_epu8(m, MM_ABS(p3, p2)); \
  |  |  ------------------
  |  |  |  |  252|  6.71k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  642|  6.71k|    (m) = _mm_max_epu8(m, MM_ABS(p2, p1)); \
  |  |  ------------------
  |  |  |  |  252|  6.71k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  643|  6.71k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (643:12): [Folded, False: 6.71k]
  |  |  ------------------
  ------------------
  730|       |
  731|  6.71k|  Load16x4_SSE2(p, p + 8 * stride, stride, &q0, &q1, &q2, &q3);
  732|  6.71k|  MAX_DIFF2(q3, q2, q1, q0, mask);
  ------------------
  |  |  646|  6.71k|  do {                                     \
  |  |  647|  6.71k|    (m) = _mm_max_epu8(m, MM_ABS(p1, p0)); \
  |  |  ------------------
  |  |  |  |  252|  6.71k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  648|  6.71k|    (m) = _mm_max_epu8(m, MM_ABS(p3, p2)); \
  |  |  ------------------
  |  |  |  |  252|  6.71k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  649|  6.71k|    (m) = _mm_max_epu8(m, MM_ABS(p2, p1)); \
  |  |  ------------------
  |  |  |  |  252|  6.71k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  650|  6.71k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (650:12): [Folded, False: 6.71k]
  |  |  ------------------
  ------------------
  733|       |
  734|  6.71k|  ComplexMask_SSE2(&p1, &p0, &q0, &q1, thresh, ithresh, &mask);
  735|  6.71k|  DoFilter6_SSE2(&p2, &p1, &p0, &q0, &q1, &q2, &mask, hev_thresh);
  736|       |
  737|  6.71k|  Store16x4_SSE2(&p3, &p2, &p1, &p0, b, b + 8 * stride, stride);
  738|  6.71k|  Store16x4_SSE2(&q0, &q1, &q2, &q3, p, p + 8 * stride, stride);
  739|  6.71k|}
dec_sse2.c:Load16x4_SSE2:
  509|   155k|                                      __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|   155k|  Load8x4_SSE2(r0, stride, p1, q0);
  526|   155k|  Load8x4_SSE2(r8, stride, p0, q1);
  527|       |
  528|   155k|  {
  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|   155k|    const __m128i t1 = *p1;
  534|   155k|    const __m128i t2 = *q0;
  535|   155k|    *p1 = _mm_unpacklo_epi64(t1, *p0);
  536|   155k|    *p0 = _mm_unpackhi_epi64(t1, *p0);
  537|   155k|    *q0 = _mm_unpacklo_epi64(t2, *q1);
  538|   155k|    *q1 = _mm_unpackhi_epi64(t2, *q1);
  539|   155k|  }
  540|   155k|}
dec_sse2.c:Load8x4_SSE2:
  480|   311k|                                     __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|   311k|  const __m128i A0 = _mm_set_epi32(
  484|   311k|      WebPMemToInt32(&b[6 * stride]), WebPMemToInt32(&b[2 * stride]),
  485|   311k|      WebPMemToInt32(&b[4 * stride]), WebPMemToInt32(&b[0 * stride]));
  486|   311k|  const __m128i A1 = _mm_set_epi32(
  487|   311k|      WebPMemToInt32(&b[7 * stride]), WebPMemToInt32(&b[3 * stride]),
  488|   311k|      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|   311k|  const __m128i B0 = _mm_unpacklo_epi8(A0, A1);
  493|   311k|  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|   311k|  const __m128i C0 = _mm_unpacklo_epi16(B0, B1);
  498|   311k|  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|   311k|  *p = _mm_unpacklo_epi32(C0, C1);
  503|   311k|  *q = _mm_unpackhi_epi32(C0, C1);
  504|   311k|}
dec_sse2.c:Store16x4_SSE2:
  556|   122k|                                       uint8_t* r8, int stride) {
  557|   122k|  __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|   122k|  t1 = *p0;
  562|   122k|  p0_s = _mm_unpacklo_epi8(*p1, t1);
  563|   122k|  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|   122k|  t1 = *q0;
  568|   122k|  q0_s = _mm_unpacklo_epi8(t1, *q1);
  569|   122k|  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|   122k|  t1 = p0_s;
  574|   122k|  p0_s = _mm_unpacklo_epi16(t1, q0_s);
  575|   122k|  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|   122k|  t1 = p1_s;
  580|   122k|  p1_s = _mm_unpacklo_epi16(t1, q1_s);
  581|   122k|  q1_s = _mm_unpackhi_epi16(t1, q1_s);
  582|       |
  583|   122k|  Store4x4_SSE2(&p0_s, r0, stride);
  584|   122k|  r0 += 4 * stride;
  585|   122k|  Store4x4_SSE2(&q0_s, r0, stride);
  586|       |
  587|   122k|  Store4x4_SSE2(&p1_s, r8, stride);
  588|   122k|  r8 += 4 * stride;
  589|   122k|  Store4x4_SSE2(&q1_s, r8, stride);
  590|   122k|}
dec_sse2.c:Store4x4_SSE2:
  543|   489k|                                      int stride) {
  544|   489k|  int i;
  545|  2.44M|  for (i = 0; i < 4; ++i, dst += stride) {
  ------------------
  |  Branch (545:15): [True: 1.95M, False: 489k]
  ------------------
  546|  1.95M|    WebPInt32ToMem(dst, _mm_cvtsi128_si32(*x));
  547|       |    *x = _mm_srli_si128(*x, 4);
  548|  1.95M|  }
  549|   489k|}
dec_sse2.c:VFilter8_SSE2:
  805|  18.6k|                          int stride, int thresh, int ithresh, int hev_thresh) {
  806|  18.6k|  __m128i mask;
  807|  18.6k|  __m128i t1, p2, p1, p0, q0, q1, q2;
  808|       |
  809|       |  // Load p3, p2, p1, p0
  810|  18.6k|  LOADUV_H_EDGES4(u - 4 * stride, v - 4 * stride, stride, t1, p2, p1, p0);
  ------------------
  |  |  668|  18.6k|  do {                                                \
  |  |  669|  18.6k|    LOADUV_H_EDGE(e1, u, v, 0 * (stride));            \
  |  |  ------------------
  |  |  |  |  661|  18.6k|  do {                                                           \
  |  |  |  |  662|  18.6k|    const __m128i U = _mm_loadl_epi64((__m128i*)&(u)[(stride)]); \
  |  |  |  |  663|  18.6k|    const __m128i V = _mm_loadl_epi64((__m128i*)&(v)[(stride)]); \
  |  |  |  |  664|  18.6k|    (p) = _mm_unpacklo_epi64(U, V);                              \
  |  |  |  |  665|  18.6k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (665:12): [Folded, False: 18.6k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  670|  18.6k|    LOADUV_H_EDGE(e2, u, v, 1 * (stride));            \
  |  |  ------------------
  |  |  |  |  661|  18.6k|  do {                                                           \
  |  |  |  |  662|  18.6k|    const __m128i U = _mm_loadl_epi64((__m128i*)&(u)[(stride)]); \
  |  |  |  |  663|  18.6k|    const __m128i V = _mm_loadl_epi64((__m128i*)&(v)[(stride)]); \
  |  |  |  |  664|  18.6k|    (p) = _mm_unpacklo_epi64(U, V);                              \
  |  |  |  |  665|  18.6k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (665:12): [Folded, False: 18.6k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  671|  18.6k|    LOADUV_H_EDGE(e3, u, v, 2 * (stride));            \
  |  |  ------------------
  |  |  |  |  661|  18.6k|  do {                                                           \
  |  |  |  |  662|  18.6k|    const __m128i U = _mm_loadl_epi64((__m128i*)&(u)[(stride)]); \
  |  |  |  |  663|  18.6k|    const __m128i V = _mm_loadl_epi64((__m128i*)&(v)[(stride)]); \
  |  |  |  |  664|  18.6k|    (p) = _mm_unpacklo_epi64(U, V);                              \
  |  |  |  |  665|  18.6k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (665:12): [Folded, False: 18.6k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  672|  18.6k|    LOADUV_H_EDGE(e4, u, v, 3 * (stride));            \
  |  |  ------------------
  |  |  |  |  661|  18.6k|  do {                                                           \
  |  |  |  |  662|  18.6k|    const __m128i U = _mm_loadl_epi64((__m128i*)&(u)[(stride)]); \
  |  |  |  |  663|  18.6k|    const __m128i V = _mm_loadl_epi64((__m128i*)&(v)[(stride)]); \
  |  |  |  |  664|  18.6k|    (p) = _mm_unpacklo_epi64(U, V);                              \
  |  |  |  |  665|  18.6k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (665:12): [Folded, False: 18.6k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  673|  18.6k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (673:12): [Folded, False: 18.6k]
  |  |  ------------------
  ------------------
  811|  18.6k|  MAX_DIFF1(t1, p2, p1, p0, mask);
  ------------------
  |  |  639|  18.6k|  do {                                     \
  |  |  640|  18.6k|    (m) = MM_ABS(p1, p0);                  \
  |  |  ------------------
  |  |  |  |  252|  18.6k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  641|  18.6k|    (m) = _mm_max_epu8(m, MM_ABS(p3, p2)); \
  |  |  ------------------
  |  |  |  |  252|  18.6k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  642|  18.6k|    (m) = _mm_max_epu8(m, MM_ABS(p2, p1)); \
  |  |  ------------------
  |  |  |  |  252|  18.6k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  643|  18.6k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (643:12): [Folded, False: 18.6k]
  |  |  ------------------
  ------------------
  812|       |
  813|       |  // Load q0, q1, q2, q3
  814|  18.6k|  LOADUV_H_EDGES4(u, v, stride, q0, q1, q2, t1);
  ------------------
  |  |  668|  18.6k|  do {                                                \
  |  |  669|  18.6k|    LOADUV_H_EDGE(e1, u, v, 0 * (stride));            \
  |  |  ------------------
  |  |  |  |  661|  18.6k|  do {                                                           \
  |  |  |  |  662|  18.6k|    const __m128i U = _mm_loadl_epi64((__m128i*)&(u)[(stride)]); \
  |  |  |  |  663|  18.6k|    const __m128i V = _mm_loadl_epi64((__m128i*)&(v)[(stride)]); \
  |  |  |  |  664|  18.6k|    (p) = _mm_unpacklo_epi64(U, V);                              \
  |  |  |  |  665|  18.6k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (665:12): [Folded, False: 18.6k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  670|  18.6k|    LOADUV_H_EDGE(e2, u, v, 1 * (stride));            \
  |  |  ------------------
  |  |  |  |  661|  18.6k|  do {                                                           \
  |  |  |  |  662|  18.6k|    const __m128i U = _mm_loadl_epi64((__m128i*)&(u)[(stride)]); \
  |  |  |  |  663|  18.6k|    const __m128i V = _mm_loadl_epi64((__m128i*)&(v)[(stride)]); \
  |  |  |  |  664|  18.6k|    (p) = _mm_unpacklo_epi64(U, V);                              \
  |  |  |  |  665|  18.6k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (665:12): [Folded, False: 18.6k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  671|  18.6k|    LOADUV_H_EDGE(e3, u, v, 2 * (stride));            \
  |  |  ------------------
  |  |  |  |  661|  18.6k|  do {                                                           \
  |  |  |  |  662|  18.6k|    const __m128i U = _mm_loadl_epi64((__m128i*)&(u)[(stride)]); \
  |  |  |  |  663|  18.6k|    const __m128i V = _mm_loadl_epi64((__m128i*)&(v)[(stride)]); \
  |  |  |  |  664|  18.6k|    (p) = _mm_unpacklo_epi64(U, V);                              \
  |  |  |  |  665|  18.6k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (665:12): [Folded, False: 18.6k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  672|  18.6k|    LOADUV_H_EDGE(e4, u, v, 3 * (stride));            \
  |  |  ------------------
  |  |  |  |  661|  18.6k|  do {                                                           \
  |  |  |  |  662|  18.6k|    const __m128i U = _mm_loadl_epi64((__m128i*)&(u)[(stride)]); \
  |  |  |  |  663|  18.6k|    const __m128i V = _mm_loadl_epi64((__m128i*)&(v)[(stride)]); \
  |  |  |  |  664|  18.6k|    (p) = _mm_unpacklo_epi64(U, V);                              \
  |  |  |  |  665|  18.6k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (665:12): [Folded, False: 18.6k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  673|  18.6k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (673:12): [Folded, False: 18.6k]
  |  |  ------------------
  ------------------
  815|  18.6k|  MAX_DIFF2(t1, q2, q1, q0, mask);
  ------------------
  |  |  646|  18.6k|  do {                                     \
  |  |  647|  18.6k|    (m) = _mm_max_epu8(m, MM_ABS(p1, p0)); \
  |  |  ------------------
  |  |  |  |  252|  18.6k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  648|  18.6k|    (m) = _mm_max_epu8(m, MM_ABS(p3, p2)); \
  |  |  ------------------
  |  |  |  |  252|  18.6k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  649|  18.6k|    (m) = _mm_max_epu8(m, MM_ABS(p2, p1)); \
  |  |  ------------------
  |  |  |  |  252|  18.6k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  650|  18.6k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (650:12): [Folded, False: 18.6k]
  |  |  ------------------
  ------------------
  816|       |
  817|  18.6k|  ComplexMask_SSE2(&p1, &p0, &q0, &q1, thresh, ithresh, &mask);
  818|  18.6k|  DoFilter6_SSE2(&p2, &p1, &p0, &q0, &q1, &q2, &mask, hev_thresh);
  819|       |
  820|       |  // Store
  821|  18.6k|  STOREUV(p2, u, v, -3 * stride);
  ------------------
  |  |  676|  18.6k|  do {                                             \
  |  |  677|  18.6k|    _mm_storel_epi64((__m128i*)&(u)[(stride)], p); \
  |  |  678|  18.6k|    (p) = _mm_srli_si128(p, 8);                    \
  |  |  679|  18.6k|    _mm_storel_epi64((__m128i*)&(v)[(stride)], p); \
  |  |  680|  18.6k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (680:12): [Folded, False: 18.6k]
  |  |  ------------------
  ------------------
  822|  18.6k|  STOREUV(p1, u, v, -2 * stride);
  ------------------
  |  |  676|  18.6k|  do {                                             \
  |  |  677|  18.6k|    _mm_storel_epi64((__m128i*)&(u)[(stride)], p); \
  |  |  678|  18.6k|    (p) = _mm_srli_si128(p, 8);                    \
  |  |  679|  18.6k|    _mm_storel_epi64((__m128i*)&(v)[(stride)], p); \
  |  |  680|  18.6k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (680:12): [Folded, False: 18.6k]
  |  |  ------------------
  ------------------
  823|  18.6k|  STOREUV(p0, u, v, -1 * stride);
  ------------------
  |  |  676|  18.6k|  do {                                             \
  |  |  677|  18.6k|    _mm_storel_epi64((__m128i*)&(u)[(stride)], p); \
  |  |  678|  18.6k|    (p) = _mm_srli_si128(p, 8);                    \
  |  |  679|  18.6k|    _mm_storel_epi64((__m128i*)&(v)[(stride)], p); \
  |  |  680|  18.6k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (680:12): [Folded, False: 18.6k]
  |  |  ------------------
  ------------------
  824|  18.6k|  STOREUV(q0, u, v, 0 * stride);
  ------------------
  |  |  676|  18.6k|  do {                                             \
  |  |  677|  18.6k|    _mm_storel_epi64((__m128i*)&(u)[(stride)], p); \
  |  |  678|  18.6k|    (p) = _mm_srli_si128(p, 8);                    \
  |  |  679|  18.6k|    _mm_storel_epi64((__m128i*)&(v)[(stride)], p); \
  |  |  680|  18.6k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (680:12): [Folded, False: 18.6k]
  |  |  ------------------
  ------------------
  825|  18.6k|  STOREUV(q1, u, v, 1 * stride);
  ------------------
  |  |  676|  18.6k|  do {                                             \
  |  |  677|  18.6k|    _mm_storel_epi64((__m128i*)&(u)[(stride)], p); \
  |  |  678|  18.6k|    (p) = _mm_srli_si128(p, 8);                    \
  |  |  679|  18.6k|    _mm_storel_epi64((__m128i*)&(v)[(stride)], p); \
  |  |  680|  18.6k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (680:12): [Folded, False: 18.6k]
  |  |  ------------------
  ------------------
  826|       |  STOREUV(q2, u, v, 2 * stride);
  ------------------
  |  |  676|  18.6k|  do {                                             \
  |  |  677|  18.6k|    _mm_storel_epi64((__m128i*)&(u)[(stride)], p); \
  |  |  678|  18.6k|    (p) = _mm_srli_si128(p, 8);                    \
  |  |  679|  18.6k|    _mm_storel_epi64((__m128i*)&(v)[(stride)], p); \
  |  |  680|  18.6k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (680:12): [Folded, False: 18.6k]
  |  |  ------------------
  ------------------
  827|  18.6k|}
dec_sse2.c:HFilter8_SSE2:
  830|  6.71k|                          int stride, int thresh, int ithresh, int hev_thresh) {
  831|  6.71k|  __m128i mask;
  832|  6.71k|  __m128i p3, p2, p1, p0, q0, q1, q2, q3;
  833|       |
  834|  6.71k|  uint8_t* const tu = u - 4;
  835|  6.71k|  uint8_t* const tv = v - 4;
  836|  6.71k|  Load16x4_SSE2(tu, tv, stride, &p3, &p2, &p1, &p0);
  837|  6.71k|  MAX_DIFF1(p3, p2, p1, p0, mask);
  ------------------
  |  |  639|  6.71k|  do {                                     \
  |  |  640|  6.71k|    (m) = MM_ABS(p1, p0);                  \
  |  |  ------------------
  |  |  |  |  252|  6.71k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  641|  6.71k|    (m) = _mm_max_epu8(m, MM_ABS(p3, p2)); \
  |  |  ------------------
  |  |  |  |  252|  6.71k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  642|  6.71k|    (m) = _mm_max_epu8(m, MM_ABS(p2, p1)); \
  |  |  ------------------
  |  |  |  |  252|  6.71k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  643|  6.71k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (643:12): [Folded, False: 6.71k]
  |  |  ------------------
  ------------------
  838|       |
  839|  6.71k|  Load16x4_SSE2(u, v, stride, &q0, &q1, &q2, &q3);
  840|  6.71k|  MAX_DIFF2(q3, q2, q1, q0, mask);
  ------------------
  |  |  646|  6.71k|  do {                                     \
  |  |  647|  6.71k|    (m) = _mm_max_epu8(m, MM_ABS(p1, p0)); \
  |  |  ------------------
  |  |  |  |  252|  6.71k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  648|  6.71k|    (m) = _mm_max_epu8(m, MM_ABS(p3, p2)); \
  |  |  ------------------
  |  |  |  |  252|  6.71k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  649|  6.71k|    (m) = _mm_max_epu8(m, MM_ABS(p2, p1)); \
  |  |  ------------------
  |  |  |  |  252|  6.71k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  650|  6.71k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (650:12): [Folded, False: 6.71k]
  |  |  ------------------
  ------------------
  841|       |
  842|  6.71k|  ComplexMask_SSE2(&p1, &p0, &q0, &q1, thresh, ithresh, &mask);
  843|  6.71k|  DoFilter6_SSE2(&p2, &p1, &p0, &q0, &q1, &q2, &mask, hev_thresh);
  844|       |
  845|  6.71k|  Store16x4_SSE2(&p3, &p2, &p1, &p0, tu, tv, stride);
  846|  6.71k|  Store16x4_SSE2(&q0, &q1, &q2, &q3, u, v, stride);
  847|  6.71k|}
dec_sse2.c:VFilter16i_SSE2:
  743|  16.7k|                            int hev_thresh) {
  744|  16.7k|  int k;
  745|  16.7k|  __m128i p3, p2, p1, p0;  // loop invariants
  746|       |
  747|  16.7k|  LOAD_H_EDGES4(p, stride, p3, p2, p1, p0);  // prologue
  ------------------
  |  |  653|  16.7k|  do {                                                    \
  |  |  654|  16.7k|    (e1) = _mm_loadu_si128((__m128i*)&(p)[0 * (stride)]); \
  |  |  655|  16.7k|    (e2) = _mm_loadu_si128((__m128i*)&(p)[1 * (stride)]); \
  |  |  656|  16.7k|    (e3) = _mm_loadu_si128((__m128i*)&(p)[2 * (stride)]); \
  |  |  657|  16.7k|    (e4) = _mm_loadu_si128((__m128i*)&(p)[3 * (stride)]); \
  |  |  658|  16.7k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (658:12): [Folded, False: 16.7k]
  |  |  ------------------
  ------------------
  748|       |
  749|  66.8k|  for (k = 3; k > 0; --k) {
  ------------------
  |  Branch (749:15): [True: 50.1k, False: 16.7k]
  ------------------
  750|  50.1k|    __m128i mask, tmp1, tmp2;
  751|  50.1k|    uint8_t* const b = p + 2 * stride;  // beginning of p1
  752|  50.1k|    p += 4 * stride;
  753|       |
  754|  50.1k|    MAX_DIFF1(p3, p2, p1, p0, mask);  // compute partial mask
  ------------------
  |  |  639|  50.1k|  do {                                     \
  |  |  640|  50.1k|    (m) = MM_ABS(p1, p0);                  \
  |  |  ------------------
  |  |  |  |  252|  50.1k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  641|  50.1k|    (m) = _mm_max_epu8(m, MM_ABS(p3, p2)); \
  |  |  ------------------
  |  |  |  |  252|  50.1k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  642|  50.1k|    (m) = _mm_max_epu8(m, MM_ABS(p2, p1)); \
  |  |  ------------------
  |  |  |  |  252|  50.1k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  643|  50.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (643:12): [Folded, False: 50.1k]
  |  |  ------------------
  ------------------
  755|  50.1k|    LOAD_H_EDGES4(p, stride, p3, p2, tmp1, tmp2);
  ------------------
  |  |  653|  50.1k|  do {                                                    \
  |  |  654|  50.1k|    (e1) = _mm_loadu_si128((__m128i*)&(p)[0 * (stride)]); \
  |  |  655|  50.1k|    (e2) = _mm_loadu_si128((__m128i*)&(p)[1 * (stride)]); \
  |  |  656|  50.1k|    (e3) = _mm_loadu_si128((__m128i*)&(p)[2 * (stride)]); \
  |  |  657|  50.1k|    (e4) = _mm_loadu_si128((__m128i*)&(p)[3 * (stride)]); \
  |  |  658|  50.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (658:12): [Folded, False: 50.1k]
  |  |  ------------------
  ------------------
  756|  50.1k|    MAX_DIFF2(p3, p2, tmp1, tmp2, mask);
  ------------------
  |  |  646|  50.1k|  do {                                     \
  |  |  647|  50.1k|    (m) = _mm_max_epu8(m, MM_ABS(p1, p0)); \
  |  |  ------------------
  |  |  |  |  252|  50.1k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  648|  50.1k|    (m) = _mm_max_epu8(m, MM_ABS(p3, p2)); \
  |  |  ------------------
  |  |  |  |  252|  50.1k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  649|  50.1k|    (m) = _mm_max_epu8(m, MM_ABS(p2, p1)); \
  |  |  ------------------
  |  |  |  |  252|  50.1k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  650|  50.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (650:12): [Folded, False: 50.1k]
  |  |  ------------------
  ------------------
  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|  50.1k|    ComplexMask_SSE2(&p1, &p0, &p3, &p2, thresh, ithresh, &mask);
  761|  50.1k|    DoFilter4_SSE2(&p1, &p0, &p3, &p2, &mask, hev_thresh);
  762|       |
  763|       |    // Store
  764|  50.1k|    _mm_storeu_si128((__m128i*)&b[0 * stride], p1);
  765|  50.1k|    _mm_storeu_si128((__m128i*)&b[1 * stride], p0);
  766|  50.1k|    _mm_storeu_si128((__m128i*)&b[2 * stride], p3);
  767|  50.1k|    _mm_storeu_si128((__m128i*)&b[3 * stride], p2);
  768|       |
  769|       |    // rotate samples
  770|  50.1k|    p1 = tmp1;
  771|  50.1k|    p0 = tmp2;
  772|  50.1k|  }
  773|  16.7k|}
dec_sse2.c:DoFilter4_SSE2:
  385|   133k|                                       int hev_thresh) {
  386|   133k|  const __m128i zero = _mm_setzero_si128();
  387|   133k|  const __m128i sign_bit = _mm_set1_epi8((char)0x80);
  388|   133k|  const __m128i k64 = _mm_set1_epi8(64);
  389|   133k|  const __m128i k3 = _mm_set1_epi8(3);
  390|   133k|  const __m128i k4 = _mm_set1_epi8(4);
  391|   133k|  __m128i not_hev;
  392|   133k|  __m128i t1, t2, t3;
  393|       |
  394|       |  // compute hev mask
  395|   133k|  GetNotHEV_SSE2(p1, p0, q0, q1, hev_thresh, &not_hev);
  396|       |
  397|       |  // convert to signed values
  398|   133k|  FLIP_SIGN_BIT4(*p1, *p0, *q0, *q1);
  ------------------
  |  |  271|   133k|  do {                             \
  |  |  272|   133k|    FLIP_SIGN_BIT2(a, b);          \
  |  |  ------------------
  |  |  |  |  265|   133k|  do {                                \
  |  |  |  |  266|   133k|    (a) = _mm_xor_si128(a, sign_bit); \
  |  |  |  |  267|   133k|    (b) = _mm_xor_si128(b, sign_bit); \
  |  |  |  |  268|   133k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (268:12): [Folded, False: 133k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  273|   133k|    FLIP_SIGN_BIT2(c, d);          \
  |  |  ------------------
  |  |  |  |  265|   133k|  do {                                \
  |  |  |  |  266|   133k|    (a) = _mm_xor_si128(a, sign_bit); \
  |  |  |  |  267|   133k|    (b) = _mm_xor_si128(b, sign_bit); \
  |  |  |  |  268|   133k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (268:12): [Folded, False: 133k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  274|   133k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (274:12): [Folded, False: 133k]
  |  |  ------------------
  ------------------
  399|       |
  400|   133k|  t1 = _mm_subs_epi8(*p1, *q1);        // p1 - q1
  401|   133k|  t1 = _mm_andnot_si128(not_hev, t1);  // hev(p1 - q1)
  402|   133k|  t2 = _mm_subs_epi8(*q0, *p0);        // q0 - p0
  403|   133k|  t1 = _mm_adds_epi8(t1, t2);          // hev(p1 - q1) + 1 * (q0 - p0)
  404|   133k|  t1 = _mm_adds_epi8(t1, t2);          // hev(p1 - q1) + 2 * (q0 - p0)
  405|   133k|  t1 = _mm_adds_epi8(t1, t2);          // hev(p1 - q1) + 3 * (q0 - p0)
  406|   133k|  t1 = _mm_and_si128(t1, *mask);       // mask filter values we don't care about
  407|       |
  408|   133k|  t2 = _mm_adds_epi8(t1, k3);    // 3 * (q0 - p0) + hev(p1 - q1) + 3
  409|   133k|  t3 = _mm_adds_epi8(t1, k4);    // 3 * (q0 - p0) + hev(p1 - q1) + 4
  410|   133k|  SignedShift8b_SSE2(&t2);       // (3 * (q0 - p0) + hev(p1 - q1) + 3) >> 3
  411|   133k|  SignedShift8b_SSE2(&t3);       // (3 * (q0 - p0) + hev(p1 - q1) + 4) >> 3
  412|   133k|  *p0 = _mm_adds_epi8(*p0, t2);  // p0 += t2
  413|   133k|  *q0 = _mm_subs_epi8(*q0, t3);  // q0 -= t3
  414|   133k|  FLIP_SIGN_BIT2(*p0, *q0);
  ------------------
  |  |  265|   133k|  do {                                \
  |  |  266|   133k|    (a) = _mm_xor_si128(a, sign_bit); \
  |  |  267|   133k|    (b) = _mm_xor_si128(b, sign_bit); \
  |  |  268|   133k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (268:12): [Folded, False: 133k]
  |  |  ------------------
  ------------------
  415|       |
  416|       |  // this is equivalent to signed (a + 1) >> 1 calculation
  417|   133k|  t2 = _mm_add_epi8(t3, sign_bit);
  418|   133k|  t3 = _mm_avg_epu8(t2, zero);
  419|   133k|  t3 = _mm_sub_epi8(t3, k64);
  420|       |
  421|   133k|  t3 = _mm_and_si128(not_hev, t3);  // if !hev
  422|   133k|  *q1 = _mm_subs_epi8(*q1, t3);     // q1 -= t3
  423|   133k|  *p1 = _mm_adds_epi8(*p1, t3);     // p1 += t3
  424|   133k|  FLIP_SIGN_BIT2(*p1, *q1);
  ------------------
  |  |  265|   133k|  do {                                \
  |  |  266|   133k|    (a) = _mm_xor_si128(a, sign_bit); \
  |  |  267|   133k|    (b) = _mm_xor_si128(b, sign_bit); \
  |  |  268|   133k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (268:12): [Folded, False: 133k]
  |  |  ------------------
  ------------------
  425|   133k|}
dec_sse2.c:HFilter16i_SSE2:
  776|  16.7k|                            int hev_thresh) {
  777|  16.7k|  int k;
  778|  16.7k|  __m128i p3, p2, p1, p0;  // loop invariants
  779|       |
  780|  16.7k|  Load16x4_SSE2(p, p + 8 * stride, stride, &p3, &p2, &p1, &p0);  // prologue
  781|       |
  782|  66.8k|  for (k = 3; k > 0; --k) {
  ------------------
  |  Branch (782:15): [True: 50.1k, False: 16.7k]
  ------------------
  783|  50.1k|    __m128i mask, tmp1, tmp2;
  784|  50.1k|    uint8_t* const b = p + 2;  // beginning of p1
  785|       |
  786|  50.1k|    p += 4;  // beginning of q0 (and next span)
  787|       |
  788|  50.1k|    MAX_DIFF1(p3, p2, p1, p0, mask);  // compute partial mask
  ------------------
  |  |  639|  50.1k|  do {                                     \
  |  |  640|  50.1k|    (m) = MM_ABS(p1, p0);                  \
  |  |  ------------------
  |  |  |  |  252|  50.1k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  641|  50.1k|    (m) = _mm_max_epu8(m, MM_ABS(p3, p2)); \
  |  |  ------------------
  |  |  |  |  252|  50.1k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  642|  50.1k|    (m) = _mm_max_epu8(m, MM_ABS(p2, p1)); \
  |  |  ------------------
  |  |  |  |  252|  50.1k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  643|  50.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (643:12): [Folded, False: 50.1k]
  |  |  ------------------
  ------------------
  789|  50.1k|    Load16x4_SSE2(p, p + 8 * stride, stride, &p3, &p2, &tmp1, &tmp2);
  790|  50.1k|    MAX_DIFF2(p3, p2, tmp1, tmp2, mask);
  ------------------
  |  |  646|  50.1k|  do {                                     \
  |  |  647|  50.1k|    (m) = _mm_max_epu8(m, MM_ABS(p1, p0)); \
  |  |  ------------------
  |  |  |  |  252|  50.1k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  648|  50.1k|    (m) = _mm_max_epu8(m, MM_ABS(p3, p2)); \
  |  |  ------------------
  |  |  |  |  252|  50.1k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  649|  50.1k|    (m) = _mm_max_epu8(m, MM_ABS(p2, p1)); \
  |  |  ------------------
  |  |  |  |  252|  50.1k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  650|  50.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (650:12): [Folded, False: 50.1k]
  |  |  ------------------
  ------------------
  791|       |
  792|  50.1k|    ComplexMask_SSE2(&p1, &p0, &p3, &p2, thresh, ithresh, &mask);
  793|  50.1k|    DoFilter4_SSE2(&p1, &p0, &p3, &p2, &mask, hev_thresh);
  794|       |
  795|  50.1k|    Store16x4_SSE2(&p1, &p0, &p3, &p2, b, b + 8 * stride, stride);
  796|       |
  797|       |    // rotate samples
  798|  50.1k|    p1 = tmp1;
  799|  50.1k|    p0 = tmp2;
  800|  50.1k|  }
  801|  16.7k|}
dec_sse2.c:VFilter8i_SSE2:
  851|  16.7k|                           int hev_thresh) {
  852|  16.7k|  __m128i mask;
  853|  16.7k|  __m128i t1, t2, p1, p0, q0, q1;
  854|       |
  855|       |  // Load p3, p2, p1, p0
  856|  16.7k|  LOADUV_H_EDGES4(u, v, stride, t2, t1, p1, p0);
  ------------------
  |  |  668|  16.7k|  do {                                                \
  |  |  669|  16.7k|    LOADUV_H_EDGE(e1, u, v, 0 * (stride));            \
  |  |  ------------------
  |  |  |  |  661|  16.7k|  do {                                                           \
  |  |  |  |  662|  16.7k|    const __m128i U = _mm_loadl_epi64((__m128i*)&(u)[(stride)]); \
  |  |  |  |  663|  16.7k|    const __m128i V = _mm_loadl_epi64((__m128i*)&(v)[(stride)]); \
  |  |  |  |  664|  16.7k|    (p) = _mm_unpacklo_epi64(U, V);                              \
  |  |  |  |  665|  16.7k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (665:12): [Folded, False: 16.7k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  670|  16.7k|    LOADUV_H_EDGE(e2, u, v, 1 * (stride));            \
  |  |  ------------------
  |  |  |  |  661|  16.7k|  do {                                                           \
  |  |  |  |  662|  16.7k|    const __m128i U = _mm_loadl_epi64((__m128i*)&(u)[(stride)]); \
  |  |  |  |  663|  16.7k|    const __m128i V = _mm_loadl_epi64((__m128i*)&(v)[(stride)]); \
  |  |  |  |  664|  16.7k|    (p) = _mm_unpacklo_epi64(U, V);                              \
  |  |  |  |  665|  16.7k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (665:12): [Folded, False: 16.7k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  671|  16.7k|    LOADUV_H_EDGE(e3, u, v, 2 * (stride));            \
  |  |  ------------------
  |  |  |  |  661|  16.7k|  do {                                                           \
  |  |  |  |  662|  16.7k|    const __m128i U = _mm_loadl_epi64((__m128i*)&(u)[(stride)]); \
  |  |  |  |  663|  16.7k|    const __m128i V = _mm_loadl_epi64((__m128i*)&(v)[(stride)]); \
  |  |  |  |  664|  16.7k|    (p) = _mm_unpacklo_epi64(U, V);                              \
  |  |  |  |  665|  16.7k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (665:12): [Folded, False: 16.7k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  672|  16.7k|    LOADUV_H_EDGE(e4, u, v, 3 * (stride));            \
  |  |  ------------------
  |  |  |  |  661|  16.7k|  do {                                                           \
  |  |  |  |  662|  16.7k|    const __m128i U = _mm_loadl_epi64((__m128i*)&(u)[(stride)]); \
  |  |  |  |  663|  16.7k|    const __m128i V = _mm_loadl_epi64((__m128i*)&(v)[(stride)]); \
  |  |  |  |  664|  16.7k|    (p) = _mm_unpacklo_epi64(U, V);                              \
  |  |  |  |  665|  16.7k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (665:12): [Folded, False: 16.7k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  673|  16.7k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (673:12): [Folded, False: 16.7k]
  |  |  ------------------
  ------------------
  857|  16.7k|  MAX_DIFF1(t2, t1, p1, p0, mask);
  ------------------
  |  |  639|  16.7k|  do {                                     \
  |  |  640|  16.7k|    (m) = MM_ABS(p1, p0);                  \
  |  |  ------------------
  |  |  |  |  252|  16.7k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  641|  16.7k|    (m) = _mm_max_epu8(m, MM_ABS(p3, p2)); \
  |  |  ------------------
  |  |  |  |  252|  16.7k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  642|  16.7k|    (m) = _mm_max_epu8(m, MM_ABS(p2, p1)); \
  |  |  ------------------
  |  |  |  |  252|  16.7k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  643|  16.7k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (643:12): [Folded, False: 16.7k]
  |  |  ------------------
  ------------------
  858|       |
  859|  16.7k|  u += 4 * stride;
  860|  16.7k|  v += 4 * stride;
  861|       |
  862|       |  // Load q0, q1, q2, q3
  863|  16.7k|  LOADUV_H_EDGES4(u, v, stride, q0, q1, t1, t2);
  ------------------
  |  |  668|  16.7k|  do {                                                \
  |  |  669|  16.7k|    LOADUV_H_EDGE(e1, u, v, 0 * (stride));            \
  |  |  ------------------
  |  |  |  |  661|  16.7k|  do {                                                           \
  |  |  |  |  662|  16.7k|    const __m128i U = _mm_loadl_epi64((__m128i*)&(u)[(stride)]); \
  |  |  |  |  663|  16.7k|    const __m128i V = _mm_loadl_epi64((__m128i*)&(v)[(stride)]); \
  |  |  |  |  664|  16.7k|    (p) = _mm_unpacklo_epi64(U, V);                              \
  |  |  |  |  665|  16.7k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (665:12): [Folded, False: 16.7k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  670|  16.7k|    LOADUV_H_EDGE(e2, u, v, 1 * (stride));            \
  |  |  ------------------
  |  |  |  |  661|  16.7k|  do {                                                           \
  |  |  |  |  662|  16.7k|    const __m128i U = _mm_loadl_epi64((__m128i*)&(u)[(stride)]); \
  |  |  |  |  663|  16.7k|    const __m128i V = _mm_loadl_epi64((__m128i*)&(v)[(stride)]); \
  |  |  |  |  664|  16.7k|    (p) = _mm_unpacklo_epi64(U, V);                              \
  |  |  |  |  665|  16.7k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (665:12): [Folded, False: 16.7k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  671|  16.7k|    LOADUV_H_EDGE(e3, u, v, 2 * (stride));            \
  |  |  ------------------
  |  |  |  |  661|  16.7k|  do {                                                           \
  |  |  |  |  662|  16.7k|    const __m128i U = _mm_loadl_epi64((__m128i*)&(u)[(stride)]); \
  |  |  |  |  663|  16.7k|    const __m128i V = _mm_loadl_epi64((__m128i*)&(v)[(stride)]); \
  |  |  |  |  664|  16.7k|    (p) = _mm_unpacklo_epi64(U, V);                              \
  |  |  |  |  665|  16.7k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (665:12): [Folded, False: 16.7k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  672|  16.7k|    LOADUV_H_EDGE(e4, u, v, 3 * (stride));            \
  |  |  ------------------
  |  |  |  |  661|  16.7k|  do {                                                           \
  |  |  |  |  662|  16.7k|    const __m128i U = _mm_loadl_epi64((__m128i*)&(u)[(stride)]); \
  |  |  |  |  663|  16.7k|    const __m128i V = _mm_loadl_epi64((__m128i*)&(v)[(stride)]); \
  |  |  |  |  664|  16.7k|    (p) = _mm_unpacklo_epi64(U, V);                              \
  |  |  |  |  665|  16.7k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (665:12): [Folded, False: 16.7k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  673|  16.7k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (673:12): [Folded, False: 16.7k]
  |  |  ------------------
  ------------------
  864|  16.7k|  MAX_DIFF2(t2, t1, q1, q0, mask);
  ------------------
  |  |  646|  16.7k|  do {                                     \
  |  |  647|  16.7k|    (m) = _mm_max_epu8(m, MM_ABS(p1, p0)); \
  |  |  ------------------
  |  |  |  |  252|  16.7k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  648|  16.7k|    (m) = _mm_max_epu8(m, MM_ABS(p3, p2)); \
  |  |  ------------------
  |  |  |  |  252|  16.7k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  649|  16.7k|    (m) = _mm_max_epu8(m, MM_ABS(p2, p1)); \
  |  |  ------------------
  |  |  |  |  252|  16.7k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  650|  16.7k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (650:12): [Folded, False: 16.7k]
  |  |  ------------------
  ------------------
  865|       |
  866|  16.7k|  ComplexMask_SSE2(&p1, &p0, &q0, &q1, thresh, ithresh, &mask);
  867|  16.7k|  DoFilter4_SSE2(&p1, &p0, &q0, &q1, &mask, hev_thresh);
  868|       |
  869|       |  // Store
  870|  16.7k|  STOREUV(p1, u, v, -2 * stride);
  ------------------
  |  |  676|  16.7k|  do {                                             \
  |  |  677|  16.7k|    _mm_storel_epi64((__m128i*)&(u)[(stride)], p); \
  |  |  678|  16.7k|    (p) = _mm_srli_si128(p, 8);                    \
  |  |  679|  16.7k|    _mm_storel_epi64((__m128i*)&(v)[(stride)], p); \
  |  |  680|  16.7k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (680:12): [Folded, False: 16.7k]
  |  |  ------------------
  ------------------
  871|  16.7k|  STOREUV(p0, u, v, -1 * stride);
  ------------------
  |  |  676|  16.7k|  do {                                             \
  |  |  677|  16.7k|    _mm_storel_epi64((__m128i*)&(u)[(stride)], p); \
  |  |  678|  16.7k|    (p) = _mm_srli_si128(p, 8);                    \
  |  |  679|  16.7k|    _mm_storel_epi64((__m128i*)&(v)[(stride)], p); \
  |  |  680|  16.7k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (680:12): [Folded, False: 16.7k]
  |  |  ------------------
  ------------------
  872|  16.7k|  STOREUV(q0, u, v, 0 * stride);
  ------------------
  |  |  676|  16.7k|  do {                                             \
  |  |  677|  16.7k|    _mm_storel_epi64((__m128i*)&(u)[(stride)], p); \
  |  |  678|  16.7k|    (p) = _mm_srli_si128(p, 8);                    \
  |  |  679|  16.7k|    _mm_storel_epi64((__m128i*)&(v)[(stride)], p); \
  |  |  680|  16.7k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (680:12): [Folded, False: 16.7k]
  |  |  ------------------
  ------------------
  873|       |  STOREUV(q1, u, v, 1 * stride);
  ------------------
  |  |  676|  16.7k|  do {                                             \
  |  |  677|  16.7k|    _mm_storel_epi64((__m128i*)&(u)[(stride)], p); \
  |  |  678|  16.7k|    (p) = _mm_srli_si128(p, 8);                    \
  |  |  679|  16.7k|    _mm_storel_epi64((__m128i*)&(v)[(stride)], p); \
  |  |  680|  16.7k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (680:12): [Folded, False: 16.7k]
  |  |  ------------------
  ------------------
  874|  16.7k|}
dec_sse2.c:HFilter8i_SSE2:
  878|  16.7k|                           int hev_thresh) {
  879|  16.7k|  __m128i mask;
  880|  16.7k|  __m128i t1, t2, p1, p0, q0, q1;
  881|  16.7k|  Load16x4_SSE2(u, v, stride, &t2, &t1, &p1, &p0);  // p3, p2, p1, p0
  882|  16.7k|  MAX_DIFF1(t2, t1, p1, p0, mask);
  ------------------
  |  |  639|  16.7k|  do {                                     \
  |  |  640|  16.7k|    (m) = MM_ABS(p1, p0);                  \
  |  |  ------------------
  |  |  |  |  252|  16.7k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  641|  16.7k|    (m) = _mm_max_epu8(m, MM_ABS(p3, p2)); \
  |  |  ------------------
  |  |  |  |  252|  16.7k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  642|  16.7k|    (m) = _mm_max_epu8(m, MM_ABS(p2, p1)); \
  |  |  ------------------
  |  |  |  |  252|  16.7k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  643|  16.7k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (643:12): [Folded, False: 16.7k]
  |  |  ------------------
  ------------------
  883|       |
  884|  16.7k|  u += 4;  // beginning of q0
  885|  16.7k|  v += 4;
  886|  16.7k|  Load16x4_SSE2(u, v, stride, &q0, &q1, &t1, &t2);  // q0, q1, q2, q3
  887|  16.7k|  MAX_DIFF2(t2, t1, q1, q0, mask);
  ------------------
  |  |  646|  16.7k|  do {                                     \
  |  |  647|  16.7k|    (m) = _mm_max_epu8(m, MM_ABS(p1, p0)); \
  |  |  ------------------
  |  |  |  |  252|  16.7k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  648|  16.7k|    (m) = _mm_max_epu8(m, MM_ABS(p3, p2)); \
  |  |  ------------------
  |  |  |  |  252|  16.7k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  649|  16.7k|    (m) = _mm_max_epu8(m, MM_ABS(p2, p1)); \
  |  |  ------------------
  |  |  |  |  252|  16.7k|  _mm_or_si128(_mm_subs_epu8((q), (p)), _mm_subs_epu8((p), (q)))
  |  |  ------------------
  |  |  650|  16.7k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (650:12): [Folded, False: 16.7k]
  |  |  ------------------
  ------------------
  888|       |
  889|  16.7k|  ComplexMask_SSE2(&p1, &p0, &q0, &q1, thresh, ithresh, &mask);
  890|  16.7k|  DoFilter4_SSE2(&p1, &p0, &q0, &q1, &mask, hev_thresh);
  891|       |
  892|  16.7k|  u -= 2;  // beginning of p1
  893|  16.7k|  v -= 2;
  894|  16.7k|  Store16x4_SSE2(&p1, &p0, &q0, &q1, u, v, stride);
  895|  16.7k|}
dec_sse2.c:SimpleVFilter16_SSE2:
  595|  32.3k|static void SimpleVFilter16_SSE2(uint8_t* p, int stride, int thresh) {
  596|       |  // Load
  597|  32.3k|  __m128i p1 = _mm_loadu_si128((__m128i*)&p[-2 * stride]);
  598|  32.3k|  __m128i p0 = _mm_loadu_si128((__m128i*)&p[-stride]);
  599|  32.3k|  __m128i q0 = _mm_loadu_si128((__m128i*)&p[0]);
  600|  32.3k|  __m128i q1 = _mm_loadu_si128((__m128i*)&p[stride]);
  601|       |
  602|  32.3k|  DoFilter2_SSE2(&p1, &p0, &q0, &q1, thresh);
  603|       |
  604|       |  // Store
  605|  32.3k|  _mm_storeu_si128((__m128i*)&p[-stride], p0);
  606|  32.3k|  _mm_storeu_si128((__m128i*)&p[0], q0);
  607|  32.3k|}
dec_sse2.c:DoFilter2_SSE2:
  365|  60.9k|                                       int thresh) {
  366|  60.9k|  __m128i a, mask;
  367|  60.9k|  const __m128i sign_bit = _mm_set1_epi8((char)0x80);
  368|       |  // convert p1/q1 to int8_t (for GetBaseDelta_SSE2)
  369|  60.9k|  const __m128i p1s = _mm_xor_si128(*p1, sign_bit);
  370|  60.9k|  const __m128i q1s = _mm_xor_si128(*q1, sign_bit);
  371|       |
  372|  60.9k|  NeedsFilter_SSE2(p1, p0, q0, q1, thresh, &mask);
  373|       |
  374|  60.9k|  FLIP_SIGN_BIT2(*p0, *q0);
  ------------------
  |  |  265|  60.9k|  do {                                \
  |  |  266|  60.9k|    (a) = _mm_xor_si128(a, sign_bit); \
  |  |  267|  60.9k|    (b) = _mm_xor_si128(b, sign_bit); \
  |  |  268|  60.9k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (268:12): [Folded, False: 60.9k]
  |  |  ------------------
  ------------------
  375|  60.9k|  GetBaseDelta_SSE2(&p1s, p0, q0, &q1s, &a);
  376|  60.9k|  a = _mm_and_si128(a, mask);  // mask filter values we don't care about
  377|  60.9k|  DoSimpleFilter_SSE2(p0, q0, &a);
  378|  60.9k|  FLIP_SIGN_BIT2(*p0, *q0);
  ------------------
  |  |  265|  60.9k|  do {                                \
  |  |  266|  60.9k|    (a) = _mm_xor_si128(a, sign_bit); \
  |  |  267|  60.9k|    (b) = _mm_xor_si128(b, sign_bit); \
  |  |  268|  60.9k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (268:12): [Folded, False: 60.9k]
  |  |  ------------------
  ------------------
  379|  60.9k|}
dec_sse2.c:SimpleHFilter16_SSE2:
  609|  28.6k|static void SimpleHFilter16_SSE2(uint8_t* p, int stride, int thresh) {
  610|  28.6k|  __m128i p1, p0, q0, q1;
  611|       |
  612|  28.6k|  p -= 2;  // beginning of p1
  613|       |
  614|  28.6k|  Load16x4_SSE2(p, p + 8 * stride, stride, &p1, &p0, &q0, &q1);
  615|  28.6k|  DoFilter2_SSE2(&p1, &p0, &q0, &q1, thresh);
  616|  28.6k|  Store16x4_SSE2(&p1, &p0, &q0, &q1, p, p + 8 * stride, stride);
  617|  28.6k|}
dec_sse2.c:SimpleVFilter16i_SSE2:
  619|  8.07k|static void SimpleVFilter16i_SSE2(uint8_t* p, int stride, int thresh) {
  620|  8.07k|  int k;
  621|  32.2k|  for (k = 3; k > 0; --k) {
  ------------------
  |  Branch (621:15): [True: 24.2k, False: 8.07k]
  ------------------
  622|  24.2k|    p += 4 * stride;
  623|  24.2k|    SimpleVFilter16_SSE2(p, stride, thresh);
  624|  24.2k|  }
  625|  8.07k|}
dec_sse2.c:SimpleHFilter16i_SSE2:
  627|  8.07k|static void SimpleHFilter16i_SSE2(uint8_t* p, int stride, int thresh) {
  628|  8.07k|  int k;
  629|  32.2k|  for (k = 3; k > 0; --k) {
  ------------------
  |  Branch (629:15): [True: 24.2k, False: 8.07k]
  ------------------
  630|  24.2k|    p += 4;
  631|  24.2k|    SimpleHFilter16_SSE2(p, stride, thresh);
  632|  24.2k|  }
  633|  8.07k|}
dec_sse2.c:TM4_SSE2:
 1060|  20.1k|static void TM4_SSE2(uint8_t* dst) { TrueMotion_SSE2(dst, 4); }
dec_sse2.c:TrueMotion_SSE2:
 1023|  50.9k|static WEBP_INLINE void TrueMotion_SSE2(uint8_t* dst, int size) {
 1024|  50.9k|  const uint8_t* top = dst - BPS;
  ------------------
  |  |   33|  50.9k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
 1025|  50.9k|  const __m128i zero = _mm_setzero_si128();
 1026|  50.9k|  int y;
 1027|  50.9k|  if (size == 4) {
  ------------------
  |  Branch (1027:7): [True: 20.1k, False: 30.7k]
  ------------------
 1028|  20.1k|    const __m128i top_values = _mm_cvtsi32_si128(WebPMemToInt32(top));
 1029|  20.1k|    const __m128i top_base = _mm_unpacklo_epi8(top_values, zero);
 1030|   100k|    for (y = 0; y < 4; ++y, dst += BPS) {
  ------------------
  |  |   33|  80.5k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  |  Branch (1030:17): [True: 80.5k, False: 20.1k]
  ------------------
 1031|  80.5k|      const int val = dst[-1] - top[-1];
 1032|  80.5k|      const __m128i base = _mm_set1_epi16(val);
 1033|  80.5k|      const __m128i out = _mm_packus_epi16(_mm_add_epi16(base, top_base), zero);
 1034|  80.5k|      WebPInt32ToMem(dst, _mm_cvtsi128_si32(out));
 1035|  80.5k|    }
 1036|  30.7k|  } else if (size == 8) {
  ------------------
  |  Branch (1036:14): [True: 19.1k, False: 11.6k]
  ------------------
 1037|  19.1k|    const __m128i top_values = _mm_loadl_epi64((const __m128i*)top);
 1038|  19.1k|    const __m128i top_base = _mm_unpacklo_epi8(top_values, zero);
 1039|   172k|    for (y = 0; y < 8; ++y, dst += BPS) {
  ------------------
  |  |   33|   152k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  |  Branch (1039:17): [True: 152k, False: 19.1k]
  ------------------
 1040|   152k|      const int val = dst[-1] - top[-1];
 1041|   152k|      const __m128i base = _mm_set1_epi16(val);
 1042|   152k|      const __m128i out = _mm_packus_epi16(_mm_add_epi16(base, top_base), zero);
 1043|   152k|      _mm_storel_epi64((__m128i*)dst, out);
 1044|   152k|    }
 1045|  19.1k|  } else {
 1046|  11.6k|    const __m128i top_values = _mm_loadu_si128((const __m128i*)top);
 1047|  11.6k|    const __m128i top_base_0 = _mm_unpacklo_epi8(top_values, zero);
 1048|  11.6k|    const __m128i top_base_1 = _mm_unpackhi_epi8(top_values, zero);
 1049|   198k|    for (y = 0; y < 16; ++y, dst += BPS) {
  ------------------
  |  |   33|   186k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  |  Branch (1049:17): [True: 186k, False: 11.6k]
  ------------------
 1050|   186k|      const int val = dst[-1] - top[-1];
 1051|   186k|      const __m128i base = _mm_set1_epi16(val);
 1052|   186k|      const __m128i out_0 = _mm_add_epi16(base, top_base_0);
 1053|   186k|      const __m128i out_1 = _mm_add_epi16(base, top_base_1);
 1054|   186k|      const __m128i out = _mm_packus_epi16(out_0, out_1);
 1055|   186k|      _mm_storeu_si128((__m128i*)dst, out);
 1056|   186k|    }
 1057|  11.6k|  }
 1058|  50.9k|}
dec_sse2.c:VE4_SSE2:
  911|  7.54k|static void VE4_SSE2(uint8_t* dst) {  // vertical
  912|  7.54k|  const __m128i one = _mm_set1_epi8(1);
  913|  7.54k|  const __m128i ABCDEFGH = _mm_loadl_epi64((__m128i*)(dst - BPS - 1));
  ------------------
  |  |   33|  7.54k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  914|  7.54k|  const __m128i BCDEFGH0 = _mm_srli_si128(ABCDEFGH, 1);
  915|  7.54k|  const __m128i CDEFGH00 = _mm_srli_si128(ABCDEFGH, 2);
  916|  7.54k|  const __m128i a = _mm_avg_epu8(ABCDEFGH, CDEFGH00);
  917|  7.54k|  const __m128i lsb = _mm_and_si128(_mm_xor_si128(ABCDEFGH, CDEFGH00), one);
  918|  7.54k|  const __m128i b = _mm_subs_epu8(a, lsb);
  919|  7.54k|  const __m128i avg = _mm_avg_epu8(b, BCDEFGH0);
  920|  7.54k|  const int vals = _mm_cvtsi128_si32(avg);
  921|  7.54k|  int i;
  922|  37.7k|  for (i = 0; i < 4; ++i) {
  ------------------
  |  Branch (922:15): [True: 30.1k, False: 7.54k]
  ------------------
  923|  30.1k|    WebPInt32ToMem(dst + i * BPS, vals);
  ------------------
  |  |   33|  30.1k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  924|  30.1k|  }
  925|  7.54k|}
dec_sse2.c:RD4_SSE2:
  994|  2.05k|static void RD4_SSE2(uint8_t* dst) {  // Down-right
  995|  2.05k|  const __m128i one = _mm_set1_epi8(1);
  996|  2.05k|  const __m128i XABCD = _mm_loadl_epi64((__m128i*)(dst - BPS - 1));
  ------------------
  |  |   33|  2.05k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  997|  2.05k|  const __m128i ____XABCD = _mm_slli_si128(XABCD, 4);
  998|  2.05k|  const uint32_t I = dst[-1 + 0 * BPS];
  ------------------
  |  |   33|  2.05k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  999|  2.05k|  const uint32_t J = dst[-1 + 1 * BPS];
  ------------------
  |  |   33|  2.05k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
 1000|  2.05k|  const uint32_t K = dst[-1 + 2 * BPS];
  ------------------
  |  |   33|  2.05k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
 1001|  2.05k|  const uint32_t L = dst[-1 + 3 * BPS];
  ------------------
  |  |   33|  2.05k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
 1002|  2.05k|  const __m128i LKJI_____ =
 1003|  2.05k|      _mm_cvtsi32_si128((int)(L | (K << 8) | (J << 16) | (I << 24)));
 1004|  2.05k|  const __m128i LKJIXABCD = _mm_or_si128(LKJI_____, ____XABCD);
 1005|  2.05k|  const __m128i KJIXABCD_ = _mm_srli_si128(LKJIXABCD, 1);
 1006|  2.05k|  const __m128i JIXABCD__ = _mm_srli_si128(LKJIXABCD, 2);
 1007|  2.05k|  const __m128i avg1 = _mm_avg_epu8(JIXABCD__, LKJIXABCD);
 1008|  2.05k|  const __m128i lsb = _mm_and_si128(_mm_xor_si128(JIXABCD__, LKJIXABCD), one);
 1009|  2.05k|  const __m128i avg2 = _mm_subs_epu8(avg1, lsb);
 1010|  2.05k|  const __m128i abcdefg = _mm_avg_epu8(avg2, KJIXABCD_);
 1011|  2.05k|  WebPInt32ToMem(dst + 3 * BPS, _mm_cvtsi128_si32(abcdefg));
  ------------------
  |  |   33|  2.05k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
 1012|  2.05k|  WebPInt32ToMem(dst + 2 * BPS, _mm_cvtsi128_si32(_mm_srli_si128(abcdefg, 1)));
  ------------------
  |  |   33|  2.05k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
 1013|  2.05k|  WebPInt32ToMem(dst + 1 * BPS, _mm_cvtsi128_si32(_mm_srli_si128(abcdefg, 2)));
  ------------------
  |  |   33|  2.05k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
 1014|  2.05k|  WebPInt32ToMem(dst + 0 * BPS, _mm_cvtsi128_si32(_mm_srli_si128(abcdefg, 3)));
  ------------------
  |  |   33|  2.05k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
 1015|  2.05k|}
dec_sse2.c:VR4_SSE2:
  943|  2.79k|static void VR4_SSE2(uint8_t* dst) {  // Vertical-Right
  944|  2.79k|  const __m128i one = _mm_set1_epi8(1);
  945|  2.79k|  const int I = dst[-1 + 0 * BPS];
  ------------------
  |  |   33|  2.79k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  946|  2.79k|  const int J = dst[-1 + 1 * BPS];
  ------------------
  |  |   33|  2.79k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  947|  2.79k|  const int K = dst[-1 + 2 * BPS];
  ------------------
  |  |   33|  2.79k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  948|  2.79k|  const int X = dst[-1 - BPS];
  ------------------
  |  |   33|  2.79k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  949|  2.79k|  const __m128i XABCD = _mm_loadl_epi64((__m128i*)(dst - BPS - 1));
  ------------------
  |  |   33|  2.79k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  950|  2.79k|  const __m128i ABCD0 = _mm_srli_si128(XABCD, 1);
  951|  2.79k|  const __m128i abcd = _mm_avg_epu8(XABCD, ABCD0);
  952|  2.79k|  const __m128i _XABCD = _mm_slli_si128(XABCD, 1);
  953|  2.79k|  const __m128i IXABCD = _mm_insert_epi16(_XABCD, (short)(I | (X << 8)), 0);
  954|  2.79k|  const __m128i avg1 = _mm_avg_epu8(IXABCD, ABCD0);
  955|  2.79k|  const __m128i lsb = _mm_and_si128(_mm_xor_si128(IXABCD, ABCD0), one);
  956|  2.79k|  const __m128i avg2 = _mm_subs_epu8(avg1, lsb);
  957|  2.79k|  const __m128i efgh = _mm_avg_epu8(avg2, XABCD);
  958|  2.79k|  WebPInt32ToMem(dst + 0 * BPS, _mm_cvtsi128_si32(abcd));
  ------------------
  |  |   33|  2.79k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  959|  2.79k|  WebPInt32ToMem(dst + 1 * BPS, _mm_cvtsi128_si32(efgh));
  ------------------
  |  |   33|  2.79k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  960|  2.79k|  WebPInt32ToMem(dst + 2 * BPS, _mm_cvtsi128_si32(_mm_slli_si128(abcd, 1)));
  ------------------
  |  |   33|  2.79k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  961|  2.79k|  WebPInt32ToMem(dst + 3 * BPS, _mm_cvtsi128_si32(_mm_slli_si128(efgh, 1)));
  ------------------
  |  |   33|  2.79k|#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|  2.79k|  DST(0, 2) = AVG3(J, I, X);
  ------------------
  |  |  900|  2.79k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  2.79k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(0, 2) = AVG3(J, I, X);
  ------------------
  |  |  901|  2.79k|#define AVG3(a, b, c) (((a) + 2 * (b) + (c) + 2) >> 2)
  ------------------
  965|  2.79k|  DST(0, 3) = AVG3(K, J, I);
  ------------------
  |  |  900|  2.79k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  2.79k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
                DST(0, 3) = AVG3(K, J, I);
  ------------------
  |  |  901|  2.79k|#define AVG3(a, b, c) (((a) + 2 * (b) + (c) + 2) >> 2)
  ------------------
  966|  2.79k|}
dec_sse2.c:LD4_SSE2:
  927|  2.96k|static void LD4_SSE2(uint8_t* dst) {  // Down-Left
  928|  2.96k|  const __m128i one = _mm_set1_epi8(1);
  929|  2.96k|  const __m128i ABCDEFGH = _mm_loadl_epi64((__m128i*)(dst - BPS));
  ------------------
  |  |   33|  2.96k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  930|  2.96k|  const __m128i BCDEFGH0 = _mm_srli_si128(ABCDEFGH, 1);
  931|  2.96k|  const __m128i CDEFGH00 = _mm_srli_si128(ABCDEFGH, 2);
  932|  2.96k|  const __m128i CDEFGHH0 = _mm_insert_epi16(CDEFGH00, dst[-BPS + 7], 3);
  933|  2.96k|  const __m128i avg1 = _mm_avg_epu8(ABCDEFGH, CDEFGHH0);
  934|  2.96k|  const __m128i lsb = _mm_and_si128(_mm_xor_si128(ABCDEFGH, CDEFGHH0), one);
  935|  2.96k|  const __m128i avg2 = _mm_subs_epu8(avg1, lsb);
  936|  2.96k|  const __m128i abcdefg = _mm_avg_epu8(avg2, BCDEFGH0);
  937|  2.96k|  WebPInt32ToMem(dst + 0 * BPS, _mm_cvtsi128_si32(abcdefg));
  ------------------
  |  |   33|  2.96k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  938|  2.96k|  WebPInt32ToMem(dst + 1 * BPS, _mm_cvtsi128_si32(_mm_srli_si128(abcdefg, 1)));
  ------------------
  |  |   33|  2.96k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  939|  2.96k|  WebPInt32ToMem(dst + 2 * BPS, _mm_cvtsi128_si32(_mm_srli_si128(abcdefg, 2)));
  ------------------
  |  |   33|  2.96k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  940|  2.96k|  WebPInt32ToMem(dst + 3 * BPS, _mm_cvtsi128_si32(_mm_srli_si128(abcdefg, 3)));
  ------------------
  |  |   33|  2.96k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  941|  2.96k|}
dec_sse2.c:VL4_SSE2:
  968|  3.48k|static void VL4_SSE2(uint8_t* dst) {  // Vertical-Left
  969|  3.48k|  const __m128i one = _mm_set1_epi8(1);
  970|  3.48k|  const __m128i ABCDEFGH = _mm_loadl_epi64((__m128i*)(dst - BPS));
  ------------------
  |  |   33|  3.48k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  971|  3.48k|  const __m128i BCDEFGH_ = _mm_srli_si128(ABCDEFGH, 1);
  972|  3.48k|  const __m128i CDEFGH__ = _mm_srli_si128(ABCDEFGH, 2);
  973|  3.48k|  const __m128i avg1 = _mm_avg_epu8(ABCDEFGH, BCDEFGH_);
  974|  3.48k|  const __m128i avg2 = _mm_avg_epu8(CDEFGH__, BCDEFGH_);
  975|  3.48k|  const __m128i avg3 = _mm_avg_epu8(avg1, avg2);
  976|  3.48k|  const __m128i lsb1 = _mm_and_si128(_mm_xor_si128(avg1, avg2), one);
  977|  3.48k|  const __m128i ab = _mm_xor_si128(ABCDEFGH, BCDEFGH_);
  978|  3.48k|  const __m128i bc = _mm_xor_si128(CDEFGH__, BCDEFGH_);
  979|  3.48k|  const __m128i abbc = _mm_or_si128(ab, bc);
  980|  3.48k|  const __m128i lsb2 = _mm_and_si128(abbc, lsb1);
  981|  3.48k|  const __m128i avg4 = _mm_subs_epu8(avg3, lsb2);
  982|  3.48k|  const uint32_t extra_out =
  983|  3.48k|      (uint32_t)_mm_cvtsi128_si32(_mm_srli_si128(avg4, 4));
  984|  3.48k|  WebPInt32ToMem(dst + 0 * BPS, _mm_cvtsi128_si32(avg1));
  ------------------
  |  |   33|  3.48k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  985|  3.48k|  WebPInt32ToMem(dst + 1 * BPS, _mm_cvtsi128_si32(avg4));
  ------------------
  |  |   33|  3.48k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  986|  3.48k|  WebPInt32ToMem(dst + 2 * BPS, _mm_cvtsi128_si32(_mm_srli_si128(avg1, 1)));
  ------------------
  |  |   33|  3.48k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  987|  3.48k|  WebPInt32ToMem(dst + 3 * BPS, _mm_cvtsi128_si32(_mm_srli_si128(avg4, 1)));
  ------------------
  |  |   33|  3.48k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  988|       |
  989|       |  // these two are hard to get and irregular
  990|  3.48k|  DST(3, 2) = (extra_out >> 0) & 0xff;
  ------------------
  |  |  900|  3.48k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  3.48k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
  991|  3.48k|  DST(3, 3) = (extra_out >> 8) & 0xff;
  ------------------
  |  |  900|  3.48k|#define DST(x, y) dst[(x) + (y) * BPS]
  |  |  ------------------
  |  |  |  |   33|  3.48k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
  992|  3.48k|}
dec_sse2.c:DC16_SSE2:
 1089|    517|static void DC16_SSE2(uint8_t* dst) {  // DC
 1090|    517|  const __m128i zero = _mm_setzero_si128();
 1091|    517|  const __m128i top = _mm_loadu_si128((const __m128i*)(dst - BPS));
  ------------------
  |  |   33|    517|#define BPS 32  // this is the common stride for enc/dec
  ------------------
 1092|    517|  const __m128i sad8x2 = _mm_sad_epu8(top, zero);
 1093|       |  // sum the two sads: sad8x2[0:1] + sad8x2[8:9]
 1094|    517|  const __m128i sum = _mm_add_epi16(sad8x2, _mm_shuffle_epi32(sad8x2, 2));
 1095|    517|  int left = 0;
 1096|    517|  int j;
 1097|  8.78k|  for (j = 0; j < 16; ++j) {
  ------------------
  |  Branch (1097:15): [True: 8.27k, False: 517]
  ------------------
 1098|  8.27k|    left += dst[-1 + j * BPS];
  ------------------
  |  |   33|  8.27k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
 1099|  8.27k|  }
 1100|    517|  {
 1101|    517|    const int DC = _mm_cvtsi128_si32(sum) + left + 16;
 1102|    517|    Put16_SSE2(DC >> 5, dst);
 1103|    517|  }
 1104|    517|}
dec_sse2.c:Put16_SSE2:
 1081|  13.0k|static WEBP_INLINE void Put16_SSE2(uint8_t v, uint8_t* dst) {
 1082|  13.0k|  int j;
 1083|  13.0k|  const __m128i values = _mm_set1_epi8((char)v);
 1084|   221k|  for (j = 0; j < 16; ++j) {
  ------------------
  |  Branch (1084:15): [True: 208k, False: 13.0k]
  ------------------
 1085|   208k|    _mm_storeu_si128((__m128i*)(dst + j * BPS), values);
  ------------------
  |  |   33|   208k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
 1086|   208k|  }
 1087|  13.0k|}
dec_sse2.c:TM16_SSE2:
 1062|  11.6k|static void TM16_SSE2(uint8_t* dst) { TrueMotion_SSE2(dst, 16); }
dec_sse2.c:VE16_SSE2:
 1064|  3.33k|static void VE16_SSE2(uint8_t* dst) {
 1065|  3.33k|  const __m128i top = _mm_loadu_si128((const __m128i*)(dst - BPS));
  ------------------
  |  |   33|  3.33k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
 1066|  3.33k|  int j;
 1067|  56.7k|  for (j = 0; j < 16; ++j) {
  ------------------
  |  Branch (1067:15): [True: 53.4k, False: 3.33k]
  ------------------
 1068|  53.4k|    _mm_storeu_si128((__m128i*)(dst + j * BPS), top);
  ------------------
  |  |   33|  53.4k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
 1069|  53.4k|  }
 1070|  3.33k|}
dec_sse2.c:DC16NoTop_SSE2:
 1106|  4.30k|static void DC16NoTop_SSE2(uint8_t* dst) {  // DC with top samples unavailable
 1107|  4.30k|  int DC = 8;
 1108|  4.30k|  int j;
 1109|  73.1k|  for (j = 0; j < 16; ++j) {
  ------------------
  |  Branch (1109:15): [True: 68.8k, False: 4.30k]
  ------------------
 1110|  68.8k|    DC += dst[-1 + j * BPS];
  ------------------
  |  |   33|  68.8k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
 1111|  68.8k|  }
 1112|  4.30k|  Put16_SSE2(DC >> 4, dst);
 1113|  4.30k|}
dec_sse2.c:DC16NoLeft_SSE2:
 1115|  7.78k|static void DC16NoLeft_SSE2(uint8_t* dst) {  // DC with left samples unavailable
 1116|  7.78k|  const __m128i zero = _mm_setzero_si128();
 1117|  7.78k|  const __m128i top = _mm_loadu_si128((const __m128i*)(dst - BPS));
  ------------------
  |  |   33|  7.78k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
 1118|  7.78k|  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.78k|  const int DC = _mm_cvtsi128_si32(sum) + 8;
 1122|  7.78k|  Put16_SSE2(DC >> 4, dst);
 1123|  7.78k|}
dec_sse2.c:DC16NoTopLeft_SSE2:
 1125|    434|static void DC16NoTopLeft_SSE2(uint8_t* dst) {  // DC with no top & left samples
 1126|    434|  Put16_SSE2(0x80, dst);
 1127|    434|}
dec_sse2.c:DC8uv_SSE2:
 1149|  2.19k|static void DC8uv_SSE2(uint8_t* dst) {  // DC
 1150|  2.19k|  const __m128i zero = _mm_setzero_si128();
 1151|  2.19k|  const __m128i top = _mm_loadl_epi64((const __m128i*)(dst - BPS));
  ------------------
  |  |   33|  2.19k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
 1152|  2.19k|  const __m128i sum = _mm_sad_epu8(top, zero);
 1153|  2.19k|  int left = 0;
 1154|  2.19k|  int j;
 1155|  19.7k|  for (j = 0; j < 8; ++j) {
  ------------------
  |  Branch (1155:15): [True: 17.5k, False: 2.19k]
  ------------------
 1156|  17.5k|    left += dst[-1 + j * BPS];
  ------------------
  |  |   33|  17.5k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
 1157|  17.5k|  }
 1158|  2.19k|  {
 1159|  2.19k|    const int DC = _mm_cvtsi128_si32(sum) + left + 8;
 1160|  2.19k|    Put8x8uv_SSE2(DC >> 4, dst);
 1161|  2.19k|  }
 1162|  2.19k|}
dec_sse2.c:Put8x8uv_SSE2:
 1141|  55.7k|static WEBP_INLINE void Put8x8uv_SSE2(uint8_t v, uint8_t* dst) {
 1142|  55.7k|  int j;
 1143|  55.7k|  const __m128i values = _mm_set1_epi8((char)v);
 1144|   501k|  for (j = 0; j < 8; ++j) {
  ------------------
  |  Branch (1144:15): [True: 445k, False: 55.7k]
  ------------------
 1145|   445k|    _mm_storel_epi64((__m128i*)(dst + j * BPS), values);
  ------------------
  |  |   33|   445k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
 1146|   445k|  }
 1147|  55.7k|}
dec_sse2.c:TM8uv_SSE2:
 1061|  19.1k|static void TM8uv_SSE2(uint8_t* dst) { TrueMotion_SSE2(dst, 8); }
dec_sse2.c:VE8uv_SSE2:
 1132|  12.9k|static void VE8uv_SSE2(uint8_t* dst) {  // vertical
 1133|  12.9k|  int j;
 1134|  12.9k|  const __m128i top = _mm_loadl_epi64((const __m128i*)(dst - BPS));
  ------------------
  |  |   33|  12.9k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
 1135|   116k|  for (j = 0; j < 8; ++j) {
  ------------------
  |  Branch (1135:15): [True: 103k, False: 12.9k]
  ------------------
 1136|   103k|    _mm_storel_epi64((__m128i*)(dst + j * BPS), top);
  ------------------
  |  |   33|   103k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
 1137|   103k|  }
 1138|  12.9k|}
dec_sse2.c:DC8uvNoTop_SSE2:
 1172|  16.9k|static void DC8uvNoTop_SSE2(uint8_t* dst) {  // DC with no top samples
 1173|  16.9k|  int dc0 = 4;
 1174|  16.9k|  int i;
 1175|   152k|  for (i = 0; i < 8; ++i) {
  ------------------
  |  Branch (1175:15): [True: 135k, False: 16.9k]
  ------------------
 1176|   135k|    dc0 += dst[-1 + i * BPS];
  ------------------
  |  |   33|   135k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
 1177|   135k|  }
 1178|  16.9k|  Put8x8uv_SSE2(dc0 >> 3, dst);
 1179|  16.9k|}
dec_sse2.c:DC8uvNoLeft_SSE2:
 1164|  34.2k|static void DC8uvNoLeft_SSE2(uint8_t* dst) {  // DC with no left samples
 1165|  34.2k|  const __m128i zero = _mm_setzero_si128();
 1166|  34.2k|  const __m128i top = _mm_loadl_epi64((const __m128i*)(dst - BPS));
  ------------------
  |  |   33|  34.2k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
 1167|  34.2k|  const __m128i sum = _mm_sad_epu8(top, zero);
 1168|  34.2k|  const int DC = _mm_cvtsi128_si32(sum) + 4;
 1169|  34.2k|  Put8x8uv_SSE2(DC >> 3, dst);
 1170|  34.2k|}
dec_sse2.c:DC8uvNoTopLeft_SSE2:
 1181|  2.33k|static void DC8uvNoTopLeft_SSE2(uint8_t* dst) {  // DC with nothing
 1182|  2.33k|  Put8x8uv_SSE2(0x80, dst);
 1183|  2.33k|}

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.77k|static void HE16_SSE41(uint8_t* dst) {  // horizontal
   26|  4.77k|  int j;
   27|  4.77k|  const __m128i kShuffle3 = _mm_set1_epi8(3);
   28|  81.1k|  for (j = 16; j > 0; --j) {
  ------------------
  |  Branch (28:16): [True: 76.3k, False: 4.77k]
  ------------------
   29|  76.3k|    const __m128i in = _mm_cvtsi32_si128(WebPMemToInt32(dst - 4));
   30|  76.3k|    const __m128i values = _mm_shuffle_epi8(in, kShuffle3);
   31|  76.3k|    _mm_storeu_si128((__m128i*)dst, values);
   32|  76.3k|    dst += BPS;
  ------------------
  |  |   33|  76.3k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
   33|  76.3k|  }
   34|  4.77k|}

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

VP8LDspInitAVX2:
  421|      1|WEBP_TSAN_IGNORE_FUNCTION void VP8LDspInitAVX2(void) {
  422|      1|  VP8LPredictorsAdd[0] = PredictorAdd0_AVX2;
  423|      1|  VP8LPredictorsAdd[1] = PredictorAdd1_AVX2;
  424|      1|  VP8LPredictorsAdd[2] = PredictorAdd2_AVX2;
  425|      1|  VP8LPredictorsAdd[3] = PredictorAdd3_AVX2;
  426|      1|  VP8LPredictorsAdd[4] = PredictorAdd4_AVX2;
  427|      1|  VP8LPredictorsAdd[8] = PredictorAdd8_AVX2;
  428|      1|  VP8LPredictorsAdd[9] = PredictorAdd9_AVX2;
  429|      1|  VP8LPredictorsAdd[10] = PredictorAdd10_AVX2;
  430|      1|  VP8LPredictorsAdd[11] = PredictorAdd11_AVX2;
  431|      1|  VP8LPredictorsAdd[12] = PredictorAdd12_AVX2;
  432|       |
  433|      1|  VP8LAddGreenToBlueAndRed = AddGreenToBlueAndRed_AVX2;
  434|      1|  VP8LTransformColorInverse = TransformColorInverse_AVX2;
  435|      1|  VP8LConvertBGRAToRGBA = ConvertBGRAToRGBA_AVX2;
  436|      1|}
lossless_avx2.c:PredictorAdd0_AVX2:
   43|   133k|                               int num_pixels, uint32_t* WEBP_RESTRICT out) {
   44|   133k|  int i;
   45|   133k|  const __m256i black = _mm256_set1_epi32((int)ARGB_BLACK);
  ------------------
  |  |   38|   133k|#define ARGB_BLACK 0xff000000
  ------------------
   46|   271k|  for (i = 0; i + 8 <= num_pixels; i += 8) {
  ------------------
  |  Branch (46:15): [True: 138k, False: 133k]
  ------------------
   47|   138k|    const __m256i src = _mm256_loadu_si256((const __m256i*)&in[i]);
   48|   138k|    const __m256i res = _mm256_add_epi8(src, black);
   49|   138k|    _mm256_storeu_si256((__m256i*)&out[i], res);
   50|   138k|  }
   51|   133k|  if (i != num_pixels) {
  ------------------
  |  Branch (51:7): [True: 102k, False: 31.6k]
  ------------------
   52|       |    VP8LPredictorsAdd_SSE[0](in + i, NULL, num_pixels - i, out + i);
   53|   102k|  }
   54|   133k|  (void)upper;
   55|   133k|}
lossless_avx2.c:PredictorAdd1_AVX2:
   59|  91.7k|                               int num_pixels, uint32_t* WEBP_RESTRICT out) {
   60|  91.7k|  int i;
   61|  91.7k|  __m256i prev = _mm256_set1_epi32((int)out[-1]);
   62|   159k|  for (i = 0; i + 8 <= num_pixels; i += 8) {
  ------------------
  |  Branch (62:15): [True: 67.3k, False: 91.7k]
  ------------------
   63|       |    // h | g | f | e | d | c | b | a
   64|  67.3k|    const __m256i src = _mm256_loadu_si256((const __m256i*)&in[i]);
   65|       |    // g | f | e | 0 | c | b | a | 0
   66|  67.3k|    const __m256i shift0 = _mm256_slli_si256(src, 4);
   67|       |    // g + h | f + g | e + f | e | c + d | b + c | a + b | a
   68|  67.3k|    const __m256i sum0 = _mm256_add_epi8(src, shift0);
   69|       |    // e + f | e | 0 | 0 | a + b | a | 0 | 0
   70|  67.3k|    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|  67.3k|    const __m256i sum1 = _mm256_add_epi8(sum0, shift1);
   74|       |    // Add a + b + c + d to the upper lane.
   75|  67.3k|    const int32_t sum_abcd = _mm256_extract_epi32(sum1, 3);
   76|  67.3k|    const __m256i sum2 = _mm256_add_epi8(
   77|  67.3k|        sum1,
   78|  67.3k|        _mm256_set_epi32(sum_abcd, sum_abcd, sum_abcd, sum_abcd, 0, 0, 0, 0));
   79|       |
   80|  67.3k|    const __m256i res = _mm256_add_epi8(sum2, prev);
   81|  67.3k|    _mm256_storeu_si256((__m256i*)&out[i], res);
   82|       |    // replicate last res output in prev.
   83|  67.3k|    prev = _mm256_permutevar8x32_epi32(
   84|  67.3k|        res, _mm256_set_epi32(7, 7, 7, 7, 7, 7, 7, 7));
   85|  67.3k|  }
   86|  91.7k|  if (i != num_pixels) {
  ------------------
  |  Branch (86:7): [True: 72.3k, False: 19.4k]
  ------------------
   87|  72.3k|    VP8LPredictorsAdd_SSE[1](in + i, upper + i, num_pixels - i, out + i);
   88|  72.3k|  }
   89|  91.7k|}
lossless_avx2.c:PredictorAdd2_AVX2:
   96|  30.6k|                                     uint32_t* WEBP_RESTRICT out) {           \
   97|  30.6k|    int i;                                                                    \
   98|  64.8k|    for (i = 0; i + 8 <= num_pixels; i += 8) {                                \
  ------------------
  |  Branch (98:17): [True: 34.2k, False: 30.6k]
  ------------------
   99|  34.2k|      const __m256i src = _mm256_loadu_si256((const __m256i*)&in[i]);         \
  100|  34.2k|      const __m256i other = _mm256_loadu_si256((const __m256i*)&(IN));        \
  101|  34.2k|      const __m256i res = _mm256_add_epi8(src, other);                        \
  102|  34.2k|      _mm256_storeu_si256((__m256i*)&out[i], res);                            \
  103|  34.2k|    }                                                                         \
  104|  30.6k|    if (i != num_pixels) {                                                    \
  ------------------
  |  Branch (104:9): [True: 15.3k, False: 15.3k]
  ------------------
  105|  15.3k|      VP8LPredictorsAdd_SSE[(X)](in + i, upper + i, num_pixels - i, out + i); \
  106|  15.3k|    }                                                                         \
  107|  30.6k|  }
lossless_avx2.c:PredictorAdd3_AVX2:
   96|  30.6k|                                     uint32_t* WEBP_RESTRICT out) {           \
   97|  30.6k|    int i;                                                                    \
   98|  92.7k|    for (i = 0; i + 8 <= num_pixels; i += 8) {                                \
  ------------------
  |  Branch (98:17): [True: 62.0k, False: 30.6k]
  ------------------
   99|  62.0k|      const __m256i src = _mm256_loadu_si256((const __m256i*)&in[i]);         \
  100|  62.0k|      const __m256i other = _mm256_loadu_si256((const __m256i*)&(IN));        \
  101|  62.0k|      const __m256i res = _mm256_add_epi8(src, other);                        \
  102|  62.0k|      _mm256_storeu_si256((__m256i*)&out[i], res);                            \
  103|  62.0k|    }                                                                         \
  104|  30.6k|    if (i != num_pixels) {                                                    \
  ------------------
  |  Branch (104:9): [True: 18.2k, False: 12.4k]
  ------------------
  105|  18.2k|      VP8LPredictorsAdd_SSE[(X)](in + i, upper + i, num_pixels - i, out + i); \
  106|  18.2k|    }                                                                         \
  107|  30.6k|  }
lossless_avx2.c:PredictorAdd4_AVX2:
   96|  62.8k|                                     uint32_t* WEBP_RESTRICT out) {           \
   97|  62.8k|    int i;                                                                    \
   98|  87.7k|    for (i = 0; i + 8 <= num_pixels; i += 8) {                                \
  ------------------
  |  Branch (98:17): [True: 24.9k, False: 62.8k]
  ------------------
   99|  24.9k|      const __m256i src = _mm256_loadu_si256((const __m256i*)&in[i]);         \
  100|  24.9k|      const __m256i other = _mm256_loadu_si256((const __m256i*)&(IN));        \
  101|  24.9k|      const __m256i res = _mm256_add_epi8(src, other);                        \
  102|  24.9k|      _mm256_storeu_si256((__m256i*)&out[i], res);                            \
  103|  24.9k|    }                                                                         \
  104|  62.8k|    if (i != num_pixels) {                                                    \
  ------------------
  |  Branch (104:9): [True: 48.8k, False: 14.0k]
  ------------------
  105|  48.8k|      VP8LPredictorsAdd_SSE[(X)](in + i, upper + i, num_pixels - i, out + i); \
  106|  48.8k|    }                                                                         \
  107|  62.8k|  }
lossless_avx2.c:PredictorAdd8_AVX2:
  123|  39.4k|                                     uint32_t* WEBP_RESTRICT out) {           \
  124|  39.4k|    int i;                                                                    \
  125|   113k|    for (i = 0; i + 8 <= num_pixels; i += 8) {                                \
  ------------------
  |  Branch (125:17): [True: 73.7k, False: 39.4k]
  ------------------
  126|  73.7k|      const __m256i Tother = _mm256_loadu_si256((const __m256i*)&(IN));       \
  127|  73.7k|      const __m256i T = _mm256_loadu_si256((const __m256i*)&upper[i]);        \
  128|  73.7k|      const __m256i src = _mm256_loadu_si256((const __m256i*)&in[i]);         \
  129|  73.7k|      __m256i avg, res;                                                       \
  130|  73.7k|      Average2_m256i(&T, &Tother, &avg);                                      \
  131|  73.7k|      res = _mm256_add_epi8(avg, src);                                        \
  132|  73.7k|      _mm256_storeu_si256((__m256i*)&out[i], res);                            \
  133|  73.7k|    }                                                                         \
  134|  39.4k|    if (i != num_pixels) {                                                    \
  ------------------
  |  Branch (134:9): [True: 23.5k, False: 15.8k]
  ------------------
  135|  23.5k|      VP8LPredictorsAdd_SSE[(X)](in + i, upper + i, num_pixels - i, out + i); \
  136|  23.5k|    }                                                                         \
  137|  39.4k|  }
lossless_avx2.c:Average2_m256i:
   31|  1.15M|                                       __m256i* const avg) {
   32|       |  // (a + b) >> 1 = ((a + b + 1) >> 1) - ((a ^ b) & 1)
   33|  1.15M|  const __m256i ones = _mm256_set1_epi8(1);
   34|  1.15M|  const __m256i avg1 = _mm256_avg_epu8(*a0, *a1);
   35|  1.15M|  const __m256i one = _mm256_and_si256(_mm256_xor_si256(*a0, *a1), ones);
   36|  1.15M|  *avg = _mm256_sub_epi8(avg1, one);
   37|  1.15M|}
lossless_avx2.c:PredictorAdd9_AVX2:
  123|  29.9k|                                     uint32_t* WEBP_RESTRICT out) {           \
  124|  29.9k|    int i;                                                                    \
  125|  85.5k|    for (i = 0; i + 8 <= num_pixels; i += 8) {                                \
  ------------------
  |  Branch (125:17): [True: 55.6k, False: 29.9k]
  ------------------
  126|  55.6k|      const __m256i Tother = _mm256_loadu_si256((const __m256i*)&(IN));       \
  127|  55.6k|      const __m256i T = _mm256_loadu_si256((const __m256i*)&upper[i]);        \
  128|  55.6k|      const __m256i src = _mm256_loadu_si256((const __m256i*)&in[i]);         \
  129|  55.6k|      __m256i avg, res;                                                       \
  130|  55.6k|      Average2_m256i(&T, &Tother, &avg);                                      \
  131|  55.6k|      res = _mm256_add_epi8(avg, src);                                        \
  132|  55.6k|      _mm256_storeu_si256((__m256i*)&out[i], res);                            \
  133|  55.6k|    }                                                                         \
  134|  29.9k|    if (i != num_pixels) {                                                    \
  ------------------
  |  Branch (134:9): [True: 14.3k, False: 15.6k]
  ------------------
  135|  14.3k|      VP8LPredictorsAdd_SSE[(X)](in + i, upper + i, num_pixels - i, out + i); \
  136|  14.3k|    }                                                                         \
  137|  29.9k|  }
lossless_avx2.c:PredictorAdd10_AVX2:
  163|  43.7k|                                int num_pixels, uint32_t* WEBP_RESTRICT out) {
  164|  43.7k|  int i, j;
  165|  43.7k|  __m256i L = _mm256_setr_epi32((int)out[-1], 0, 0, 0, 0, 0, 0, 0);
  166|   104k|  for (i = 0; i + 8 <= num_pixels; i += 8) {
  ------------------
  |  Branch (166:15): [True: 60.2k, False: 43.7k]
  ------------------
  167|  60.2k|    __m256i src = _mm256_loadu_si256((const __m256i*)&in[i]);
  168|  60.2k|    __m256i TL = _mm256_loadu_si256((const __m256i*)&upper[i - 1]);
  169|  60.2k|    const __m256i T = _mm256_loadu_si256((const __m256i*)&upper[i]);
  170|  60.2k|    const __m256i TR = _mm256_loadu_si256((const __m256i*)&upper[i + 1]);
  171|  60.2k|    __m256i avgTTR;
  172|  60.2k|    Average2_m256i(&T, &TR, &avgTTR);
  173|  60.2k|    {
  174|  60.2k|      const __m256i avgTTR_bak = avgTTR;
  175|  60.2k|      const __m256i TL_bak = TL;
  176|  60.2k|      const __m256i src_bak = src;
  177|   301k|      for (j = 0; j < 4; ++j) {
  ------------------
  |  Branch (177:19): [True: 241k, False: 60.2k]
  ------------------
  178|   241k|        DO_PRED10(j);
  ------------------
  |  |  146|   241k|  do {                                                  \
  |  |  147|   241k|    __m256i avgLTL, avg;                                \
  |  |  148|   241k|    Average2_m256i(&L, &TL, &avgLTL);                   \
  |  |  149|   241k|    Average2_m256i(&avgTTR, &avgLTL, &avg);             \
  |  |  150|   241k|    L = _mm256_add_epi8(avg, src);                      \
  |  |  151|   241k|    out[i + (OUT)] = (uint32_t)_mm256_cvtsi256_si32(L); \
  |  |  152|   241k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (152:12): [Folded, False: 241k]
  |  |  ------------------
  ------------------
  179|   241k|        DO_PRED10_SHIFT;
  ------------------
  |  |  155|   241k|  do {                                                          \
  |  |  156|   241k|    /* Rotate the pre-computed values for the next iteration.*/ \
  |  |  157|   241k|    avgTTR = _mm256_srli_si256(avgTTR, 4);                      \
  |  |  158|   241k|    TL = _mm256_srli_si256(TL, 4);                              \
  |  |  159|   241k|    src = _mm256_srli_si256(src, 4);                            \
  |  |  160|   241k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (160:12): [Folded, False: 241k]
  |  |  ------------------
  ------------------
  180|   241k|      }
  181|  60.2k|      avgTTR = _mm256_permute2x128_si256(avgTTR_bak, avgTTR_bak, 1);
  182|  60.2k|      TL = _mm256_permute2x128_si256(TL_bak, TL_bak, 1);
  183|  60.2k|      src = _mm256_permute2x128_si256(src_bak, src_bak, 1);
  184|   301k|      for (; j < 8; ++j) {
  ------------------
  |  Branch (184:14): [True: 241k, False: 60.2k]
  ------------------
  185|   241k|        DO_PRED10(j);
  ------------------
  |  |  146|   241k|  do {                                                  \
  |  |  147|   241k|    __m256i avgLTL, avg;                                \
  |  |  148|   241k|    Average2_m256i(&L, &TL, &avgLTL);                   \
  |  |  149|   241k|    Average2_m256i(&avgTTR, &avgLTL, &avg);             \
  |  |  150|   241k|    L = _mm256_add_epi8(avg, src);                      \
  |  |  151|   241k|    out[i + (OUT)] = (uint32_t)_mm256_cvtsi256_si32(L); \
  |  |  152|   241k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (152:12): [Folded, False: 241k]
  |  |  ------------------
  ------------------
  186|   241k|        DO_PRED10_SHIFT;
  ------------------
  |  |  155|   241k|  do {                                                          \
  |  |  156|   241k|    /* Rotate the pre-computed values for the next iteration.*/ \
  |  |  157|   241k|    avgTTR = _mm256_srli_si256(avgTTR, 4);                      \
  |  |  158|   241k|    TL = _mm256_srli_si256(TL, 4);                              \
  |  |  159|   241k|    src = _mm256_srli_si256(src, 4);                            \
  |  |  160|   241k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (160:12): [Folded, False: 241k]
  |  |  ------------------
  ------------------
  187|   241k|      }
  188|  60.2k|    }
  189|  60.2k|  }
  190|  43.7k|  if (i != num_pixels) {
  ------------------
  |  Branch (190:7): [True: 23.8k, False: 19.9k]
  ------------------
  191|  23.8k|    VP8LPredictorsAdd_SSE[10](in + i, upper + i, num_pixels - i, out + i);
  192|  23.8k|  }
  193|  43.7k|}
lossless_avx2.c:PredictorAdd11_AVX2:
  221|  32.1k|                                int num_pixels, uint32_t* WEBP_RESTRICT out) {
  222|  32.1k|  int i, j;
  223|  32.1k|  __m256i pa;
  224|  32.1k|  __m256i L = _mm256_setr_epi32((int)out[-1], 0, 0, 0, 0, 0, 0, 0);
  225|   108k|  for (i = 0; i + 8 <= num_pixels; i += 8) {
  ------------------
  |  Branch (225:15): [True: 75.8k, False: 32.1k]
  ------------------
  226|  75.8k|    __m256i T = _mm256_loadu_si256((const __m256i*)&upper[i]);
  227|  75.8k|    __m256i TL = _mm256_loadu_si256((const __m256i*)&upper[i - 1]);
  228|  75.8k|    __m256i src = _mm256_loadu_si256((const __m256i*)&in[i]);
  229|  75.8k|    {
  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|  75.8k|      const __m256i T_lo = _mm256_unpacklo_epi32(T, T);
  234|  75.8k|      const __m256i TL_lo = _mm256_unpacklo_epi32(TL, T);
  235|  75.8k|      const __m256i T_hi = _mm256_unpackhi_epi32(T, T);
  236|  75.8k|      const __m256i TL_hi = _mm256_unpackhi_epi32(TL, T);
  237|  75.8k|      const __m256i s_lo = _mm256_sad_epu8(T_lo, TL_lo);
  238|  75.8k|      const __m256i s_hi = _mm256_sad_epu8(T_hi, TL_hi);
  239|  75.8k|      pa = _mm256_packs_epi32(s_lo, s_hi);  // pa = sum |T-TL|
  240|  75.8k|    }
  241|  75.8k|    {
  242|  75.8k|      const __m256i T_bak = T;
  243|  75.8k|      const __m256i TL_bak = TL;
  244|  75.8k|      const __m256i src_bak = src;
  245|  75.8k|      const __m256i pa_bak = pa;
  246|   379k|      for (j = 0; j < 4; ++j) {
  ------------------
  |  Branch (246:19): [True: 303k, False: 75.8k]
  ------------------
  247|   303k|        DO_PRED11(j);
  ------------------
  |  |  199|   303k|  do {                                                                      \
  |  |  200|   303k|    const __m256i L_lo = _mm256_unpacklo_epi32(L, T);                       \
  |  |  201|   303k|    const __m256i TL_lo = _mm256_unpacklo_epi32(TL, T);                     \
  |  |  202|   303k|    const __m256i pb = _mm256_sad_epu8(L_lo, TL_lo); /* pb = sum |L-TL|*/   \
  |  |  203|   303k|    const __m256i mask = _mm256_cmpgt_epi32(pb, pa);                        \
  |  |  204|   303k|    const __m256i A = _mm256_and_si256(mask, L);                            \
  |  |  205|   303k|    const __m256i B = _mm256_andnot_si256(mask, T);                         \
  |  |  206|   303k|    const __m256i pred = _mm256_or_si256(A, B); /* pred = (pa > b)? L : T*/ \
  |  |  207|   303k|    L = _mm256_add_epi8(src, pred);                                         \
  |  |  208|   303k|    out[i + (OUT)] = (uint32_t)_mm256_cvtsi256_si32(L);                     \
  |  |  209|   303k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (209:12): [Folded, False: 303k]
  |  |  ------------------
  ------------------
  248|   303k|        DO_PRED11_SHIFT;
  ------------------
  |  |  212|   303k|  do {                                                        \
  |  |  213|   303k|    /* Shift the pre-computed value for the next iteration.*/ \
  |  |  214|   303k|    T = _mm256_srli_si256(T, 4);                              \
  |  |  215|   303k|    TL = _mm256_srli_si256(TL, 4);                            \
  |  |  216|   303k|    src = _mm256_srli_si256(src, 4);                          \
  |  |  217|   303k|    pa = _mm256_srli_si256(pa, 4);                            \
  |  |  218|   303k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (218:12): [Folded, False: 303k]
  |  |  ------------------
  ------------------
  249|   303k|      }
  250|  75.8k|      T = _mm256_permute2x128_si256(T_bak, T_bak, 1);
  251|  75.8k|      TL = _mm256_permute2x128_si256(TL_bak, TL_bak, 1);
  252|  75.8k|      src = _mm256_permute2x128_si256(src_bak, src_bak, 1);
  253|  75.8k|      pa = _mm256_permute2x128_si256(pa_bak, pa_bak, 1);
  254|   379k|      for (; j < 8; ++j) {
  ------------------
  |  Branch (254:14): [True: 303k, False: 75.8k]
  ------------------
  255|   303k|        DO_PRED11(j);
  ------------------
  |  |  199|   303k|  do {                                                                      \
  |  |  200|   303k|    const __m256i L_lo = _mm256_unpacklo_epi32(L, T);                       \
  |  |  201|   303k|    const __m256i TL_lo = _mm256_unpacklo_epi32(TL, T);                     \
  |  |  202|   303k|    const __m256i pb = _mm256_sad_epu8(L_lo, TL_lo); /* pb = sum |L-TL|*/   \
  |  |  203|   303k|    const __m256i mask = _mm256_cmpgt_epi32(pb, pa);                        \
  |  |  204|   303k|    const __m256i A = _mm256_and_si256(mask, L);                            \
  |  |  205|   303k|    const __m256i B = _mm256_andnot_si256(mask, T);                         \
  |  |  206|   303k|    const __m256i pred = _mm256_or_si256(A, B); /* pred = (pa > b)? L : T*/ \
  |  |  207|   303k|    L = _mm256_add_epi8(src, pred);                                         \
  |  |  208|   303k|    out[i + (OUT)] = (uint32_t)_mm256_cvtsi256_si32(L);                     \
  |  |  209|   303k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (209:12): [Folded, False: 303k]
  |  |  ------------------
  ------------------
  256|   303k|        DO_PRED11_SHIFT;
  ------------------
  |  |  212|   303k|  do {                                                        \
  |  |  213|   303k|    /* Shift the pre-computed value for the next iteration.*/ \
  |  |  214|   303k|    T = _mm256_srli_si256(T, 4);                              \
  |  |  215|   303k|    TL = _mm256_srli_si256(TL, 4);                            \
  |  |  216|   303k|    src = _mm256_srli_si256(src, 4);                          \
  |  |  217|   303k|    pa = _mm256_srli_si256(pa, 4);                            \
  |  |  218|   303k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (218:12): [Folded, False: 303k]
  |  |  ------------------
  ------------------
  257|   303k|      }
  258|  75.8k|    }
  259|  75.8k|  }
  260|  32.1k|  if (i != num_pixels) {
  ------------------
  |  Branch (260:7): [True: 13.7k, False: 18.3k]
  ------------------
  261|  13.7k|    VP8LPredictorsAdd_SSE[11](in + i, upper + i, num_pixels - i, out + i);
  262|  13.7k|  }
  263|  32.1k|}
lossless_avx2.c:PredictorAdd12_AVX2:
  285|  40.1k|                                int num_pixels, uint32_t* WEBP_RESTRICT out) {
  286|  40.1k|  int i;
  287|  40.1k|  const __m256i zero = _mm256_setzero_si256();
  288|  40.1k|  const __m256i L8 = _mm256_setr_epi32((int)out[-1], 0, 0, 0, 0, 0, 0, 0);
  289|  40.1k|  __m256i L = _mm256_unpacklo_epi8(L8, zero);
  290|   115k|  for (i = 0; i + 8 <= num_pixels; i += 8) {
  ------------------
  |  Branch (290:15): [True: 74.8k, False: 40.1k]
  ------------------
  291|       |    // Load 8 pixels at a time.
  292|  74.8k|    __m256i src = _mm256_loadu_si256((const __m256i*)&in[i]);
  293|  74.8k|    const __m256i T = _mm256_loadu_si256((const __m256i*)&upper[i]);
  294|  74.8k|    const __m256i T_lo = _mm256_unpacklo_epi8(T, zero);
  295|  74.8k|    const __m256i T_hi = _mm256_unpackhi_epi8(T, zero);
  296|  74.8k|    const __m256i TL = _mm256_loadu_si256((const __m256i*)&upper[i - 1]);
  297|  74.8k|    const __m256i TL_lo = _mm256_unpacklo_epi8(TL, zero);
  298|  74.8k|    const __m256i TL_hi = _mm256_unpackhi_epi8(TL, zero);
  299|  74.8k|    __m256i diff_lo = _mm256_sub_epi16(T_lo, TL_lo);
  300|  74.8k|    __m256i diff_hi = _mm256_sub_epi16(T_hi, TL_hi);
  301|  74.8k|    const __m256i diff_lo_bak = diff_lo;
  302|  74.8k|    const __m256i diff_hi_bak = diff_hi;
  303|  74.8k|    const __m256i src_bak = src;
  304|  74.8k|    DO_PRED12(diff_lo, 0);
  ------------------
  |  |  269|  74.8k|  do {                                                    \
  |  |  270|  74.8k|    const __m256i all = _mm256_add_epi16(L, (DIFF));      \
  |  |  271|  74.8k|    const __m256i alls = _mm256_packus_epi16(all, all);   \
  |  |  272|  74.8k|    const __m256i res = _mm256_add_epi8(src, alls);       \
  |  |  273|  74.8k|    out[i + (OUT)] = (uint32_t)_mm256_cvtsi256_si32(res); \
  |  |  274|  74.8k|    L = _mm256_unpacklo_epi8(res, zero);                  \
  |  |  275|  74.8k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (275:12): [Folded, False: 74.8k]
  |  |  ------------------
  ------------------
  305|  74.8k|    DO_PRED12_SHIFT(diff_lo, 0);
  ------------------
  |  |  278|  74.8k|  do {                                                        \
  |  |  279|  74.8k|    /* Shift the pre-computed value for the next iteration.*/ \
  |  |  280|  74.8k|    if ((LANE) == 0) (DIFF) = _mm256_srli_si256(DIFF, 8);     \
  |  |  ------------------
  |  |  |  Branch (280:9): [True: 74.8k, Folded]
  |  |  ------------------
  |  |  281|  74.8k|    src = _mm256_srli_si256(src, 4);                          \
  |  |  282|  74.8k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (282:12): [Folded, False: 74.8k]
  |  |  ------------------
  ------------------
  306|  74.8k|    DO_PRED12(diff_lo, 1);
  ------------------
  |  |  269|  74.8k|  do {                                                    \
  |  |  270|  74.8k|    const __m256i all = _mm256_add_epi16(L, (DIFF));      \
  |  |  271|  74.8k|    const __m256i alls = _mm256_packus_epi16(all, all);   \
  |  |  272|  74.8k|    const __m256i res = _mm256_add_epi8(src, alls);       \
  |  |  273|  74.8k|    out[i + (OUT)] = (uint32_t)_mm256_cvtsi256_si32(res); \
  |  |  274|  74.8k|    L = _mm256_unpacklo_epi8(res, zero);                  \
  |  |  275|  74.8k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (275:12): [Folded, False: 74.8k]
  |  |  ------------------
  ------------------
  307|  74.8k|    DO_PRED12_SHIFT(diff_lo, 0);
  ------------------
  |  |  278|  74.8k|  do {                                                        \
  |  |  279|  74.8k|    /* Shift the pre-computed value for the next iteration.*/ \
  |  |  280|  74.8k|    if ((LANE) == 0) (DIFF) = _mm256_srli_si256(DIFF, 8);     \
  |  |  ------------------
  |  |  |  Branch (280:9): [True: 74.8k, Folded]
  |  |  ------------------
  |  |  281|  74.8k|    src = _mm256_srli_si256(src, 4);                          \
  |  |  282|  74.8k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (282:12): [Folded, False: 74.8k]
  |  |  ------------------
  ------------------
  308|  74.8k|    DO_PRED12(diff_hi, 2);
  ------------------
  |  |  269|  74.8k|  do {                                                    \
  |  |  270|  74.8k|    const __m256i all = _mm256_add_epi16(L, (DIFF));      \
  |  |  271|  74.8k|    const __m256i alls = _mm256_packus_epi16(all, all);   \
  |  |  272|  74.8k|    const __m256i res = _mm256_add_epi8(src, alls);       \
  |  |  273|  74.8k|    out[i + (OUT)] = (uint32_t)_mm256_cvtsi256_si32(res); \
  |  |  274|  74.8k|    L = _mm256_unpacklo_epi8(res, zero);                  \
  |  |  275|  74.8k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (275:12): [Folded, False: 74.8k]
  |  |  ------------------
  ------------------
  309|  74.8k|    DO_PRED12_SHIFT(diff_hi, 0);
  ------------------
  |  |  278|  74.8k|  do {                                                        \
  |  |  279|  74.8k|    /* Shift the pre-computed value for the next iteration.*/ \
  |  |  280|  74.8k|    if ((LANE) == 0) (DIFF) = _mm256_srli_si256(DIFF, 8);     \
  |  |  ------------------
  |  |  |  Branch (280:9): [True: 74.8k, Folded]
  |  |  ------------------
  |  |  281|  74.8k|    src = _mm256_srli_si256(src, 4);                          \
  |  |  282|  74.8k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (282:12): [Folded, False: 74.8k]
  |  |  ------------------
  ------------------
  310|  74.8k|    DO_PRED12(diff_hi, 3);
  ------------------
  |  |  269|  74.8k|  do {                                                    \
  |  |  270|  74.8k|    const __m256i all = _mm256_add_epi16(L, (DIFF));      \
  |  |  271|  74.8k|    const __m256i alls = _mm256_packus_epi16(all, all);   \
  |  |  272|  74.8k|    const __m256i res = _mm256_add_epi8(src, alls);       \
  |  |  273|  74.8k|    out[i + (OUT)] = (uint32_t)_mm256_cvtsi256_si32(res); \
  |  |  274|  74.8k|    L = _mm256_unpacklo_epi8(res, zero);                  \
  |  |  275|  74.8k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (275:12): [Folded, False: 74.8k]
  |  |  ------------------
  ------------------
  311|  74.8k|    DO_PRED12_SHIFT(diff_hi, 0);
  ------------------
  |  |  278|  74.8k|  do {                                                        \
  |  |  279|  74.8k|    /* Shift the pre-computed value for the next iteration.*/ \
  |  |  280|  74.8k|    if ((LANE) == 0) (DIFF) = _mm256_srli_si256(DIFF, 8);     \
  |  |  ------------------
  |  |  |  Branch (280:9): [True: 74.8k, Folded]
  |  |  ------------------
  |  |  281|  74.8k|    src = _mm256_srli_si256(src, 4);                          \
  |  |  282|  74.8k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (282:12): [Folded, False: 74.8k]
  |  |  ------------------
  ------------------
  312|       |
  313|       |    // Process the upper lane.
  314|  74.8k|    diff_lo = _mm256_permute2x128_si256(diff_lo_bak, diff_lo_bak, 1);
  315|  74.8k|    diff_hi = _mm256_permute2x128_si256(diff_hi_bak, diff_hi_bak, 1);
  316|  74.8k|    src = _mm256_permute2x128_si256(src_bak, src_bak, 1);
  317|       |
  318|  74.8k|    DO_PRED12(diff_lo, 4);
  ------------------
  |  |  269|  74.8k|  do {                                                    \
  |  |  270|  74.8k|    const __m256i all = _mm256_add_epi16(L, (DIFF));      \
  |  |  271|  74.8k|    const __m256i alls = _mm256_packus_epi16(all, all);   \
  |  |  272|  74.8k|    const __m256i res = _mm256_add_epi8(src, alls);       \
  |  |  273|  74.8k|    out[i + (OUT)] = (uint32_t)_mm256_cvtsi256_si32(res); \
  |  |  274|  74.8k|    L = _mm256_unpacklo_epi8(res, zero);                  \
  |  |  275|  74.8k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (275:12): [Folded, False: 74.8k]
  |  |  ------------------
  ------------------
  319|  74.8k|    DO_PRED12_SHIFT(diff_lo, 0);
  ------------------
  |  |  278|  74.8k|  do {                                                        \
  |  |  279|  74.8k|    /* Shift the pre-computed value for the next iteration.*/ \
  |  |  280|  74.8k|    if ((LANE) == 0) (DIFF) = _mm256_srli_si256(DIFF, 8);     \
  |  |  ------------------
  |  |  |  Branch (280:9): [True: 74.8k, Folded]
  |  |  ------------------
  |  |  281|  74.8k|    src = _mm256_srli_si256(src, 4);                          \
  |  |  282|  74.8k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (282:12): [Folded, False: 74.8k]
  |  |  ------------------
  ------------------
  320|  74.8k|    DO_PRED12(diff_lo, 5);
  ------------------
  |  |  269|  74.8k|  do {                                                    \
  |  |  270|  74.8k|    const __m256i all = _mm256_add_epi16(L, (DIFF));      \
  |  |  271|  74.8k|    const __m256i alls = _mm256_packus_epi16(all, all);   \
  |  |  272|  74.8k|    const __m256i res = _mm256_add_epi8(src, alls);       \
  |  |  273|  74.8k|    out[i + (OUT)] = (uint32_t)_mm256_cvtsi256_si32(res); \
  |  |  274|  74.8k|    L = _mm256_unpacklo_epi8(res, zero);                  \
  |  |  275|  74.8k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (275:12): [Folded, False: 74.8k]
  |  |  ------------------
  ------------------
  321|  74.8k|    DO_PRED12_SHIFT(diff_lo, 1);
  ------------------
  |  |  278|  74.8k|  do {                                                        \
  |  |  279|  74.8k|    /* Shift the pre-computed value for the next iteration.*/ \
  |  |  280|  74.8k|    if ((LANE) == 0) (DIFF) = _mm256_srli_si256(DIFF, 8);     \
  |  |  ------------------
  |  |  |  Branch (280:9): [Folded, False: 74.8k]
  |  |  ------------------
  |  |  281|  74.8k|    src = _mm256_srli_si256(src, 4);                          \
  |  |  282|  74.8k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (282:12): [Folded, False: 74.8k]
  |  |  ------------------
  ------------------
  322|  74.8k|    DO_PRED12(diff_hi, 6);
  ------------------
  |  |  269|  74.8k|  do {                                                    \
  |  |  270|  74.8k|    const __m256i all = _mm256_add_epi16(L, (DIFF));      \
  |  |  271|  74.8k|    const __m256i alls = _mm256_packus_epi16(all, all);   \
  |  |  272|  74.8k|    const __m256i res = _mm256_add_epi8(src, alls);       \
  |  |  273|  74.8k|    out[i + (OUT)] = (uint32_t)_mm256_cvtsi256_si32(res); \
  |  |  274|  74.8k|    L = _mm256_unpacklo_epi8(res, zero);                  \
  |  |  275|  74.8k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (275:12): [Folded, False: 74.8k]
  |  |  ------------------
  ------------------
  323|  74.8k|    DO_PRED12_SHIFT(diff_hi, 0);
  ------------------
  |  |  278|  74.8k|  do {                                                        \
  |  |  279|  74.8k|    /* Shift the pre-computed value for the next iteration.*/ \
  |  |  280|  74.8k|    if ((LANE) == 0) (DIFF) = _mm256_srli_si256(DIFF, 8);     \
  |  |  ------------------
  |  |  |  Branch (280:9): [True: 74.8k, Folded]
  |  |  ------------------
  |  |  281|  74.8k|    src = _mm256_srli_si256(src, 4);                          \
  |  |  282|  74.8k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (282:12): [Folded, False: 74.8k]
  |  |  ------------------
  ------------------
  324|  74.8k|    DO_PRED12(diff_hi, 7);
  ------------------
  |  |  269|  74.8k|  do {                                                    \
  |  |  270|  74.8k|    const __m256i all = _mm256_add_epi16(L, (DIFF));      \
  |  |  271|  74.8k|    const __m256i alls = _mm256_packus_epi16(all, all);   \
  |  |  272|  74.8k|    const __m256i res = _mm256_add_epi8(src, alls);       \
  |  |  273|  74.8k|    out[i + (OUT)] = (uint32_t)_mm256_cvtsi256_si32(res); \
  |  |  274|  74.8k|    L = _mm256_unpacklo_epi8(res, zero);                  \
  |  |  275|  74.8k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (275:12): [Folded, False: 74.8k]
  |  |  ------------------
  ------------------
  325|  74.8k|  }
  326|  40.1k|  if (i != num_pixels) {
  ------------------
  |  Branch (326:7): [True: 23.8k, False: 16.2k]
  ------------------
  327|  23.8k|    VP8LPredictorsAdd_SSE[12](in + i, upper + i, num_pixels - i, out + i);
  328|  23.8k|  }
  329|  40.1k|}
lossless_avx2.c:AddGreenToBlueAndRed_AVX2:
  340|  7.55k|                                      uint32_t* dst) {
  341|  7.55k|  int i;
  342|  7.55k|  const __m256i kCstShuffle = _mm256_set_epi8(
  343|  7.55k|      -1, 29, -1, 29, -1, 25, -1, 25, -1, 21, -1, 21, -1, 17, -1, 17, -1, 13,
  344|  7.55k|      -1, 13, -1, 9, -1, 9, -1, 5, -1, 5, -1, 1, -1, 1);
  345|   386k|  for (i = 0; i + 8 <= num_pixels; i += 8) {
  ------------------
  |  Branch (345:15): [True: 379k, False: 7.55k]
  ------------------
  346|   379k|    const __m256i in = _mm256_loadu_si256((const __m256i*)&src[i]);  // argb
  347|   379k|    const __m256i in_0g0g = _mm256_shuffle_epi8(in, kCstShuffle);    // 0g0g
  348|   379k|    const __m256i out = _mm256_add_epi8(in, in_0g0g);
  349|   379k|    _mm256_storeu_si256((__m256i*)&dst[i], out);
  350|   379k|  }
  351|       |  // fallthrough and finish off with SSE.
  352|  7.55k|  if (i != num_pixels) {
  ------------------
  |  Branch (352:7): [True: 79, False: 7.48k]
  ------------------
  353|     79|    VP8LAddGreenToBlueAndRed_SSE(src + i, num_pixels - i, dst + i);
  354|     79|  }
  355|  7.55k|}
lossless_avx2.c:TransformColorInverse_AVX2:
  362|   209k|                                       int num_pixels, uint32_t* dst) {
  363|       |// sign-extended multiplying constants, pre-shifted by 5.
  364|   209k|#define CST(X) (((int16_t)(m->X << 8)) >> 5)  // sign-extend
  365|   209k|  const __m256i mults_rb = _mm256_set1_epi32(
  366|   209k|      (int)((uint32_t)CST(green_to_red) << 16 | (CST(green_to_blue) & 0xffff)));
  ------------------
  |  |  364|   209k|#define CST(X) (((int16_t)(m->X << 8)) >> 5)  // sign-extend
  ------------------
                    (int)((uint32_t)CST(green_to_red) << 16 | (CST(green_to_blue) & 0xffff)));
  ------------------
  |  |  364|   209k|#define CST(X) (((int16_t)(m->X << 8)) >> 5)  // sign-extend
  ------------------
  367|   209k|  const __m256i mults_b2 = _mm256_set1_epi32(CST(red_to_blue));
  ------------------
  |  |  364|   209k|#define CST(X) (((int16_t)(m->X << 8)) >> 5)  // sign-extend
  ------------------
  368|   209k|#undef CST
  369|   209k|  const __m256i mask_ag = _mm256_set1_epi32((int)0xff00ff00);
  370|   209k|  const __m256i perm1 = _mm256_setr_epi8(
  371|   209k|      -1, 1, -1, 1, -1, 5, -1, 5, -1, 9, -1, 9, -1, 13, -1, 13, -1, 17, -1, 17,
  372|   209k|      -1, 21, -1, 21, -1, 25, -1, 25, -1, 29, -1, 29);
  373|   209k|  const __m256i perm2 = _mm256_setr_epi8(
  374|   209k|      -1, 2, -1, -1, -1, 6, -1, -1, -1, 10, -1, -1, -1, 14, -1, -1, -1, 18, -1,
  375|   209k|      -1, -1, 22, -1, -1, -1, 26, -1, -1, -1, 30, -1, -1);
  376|   209k|  int i;
  377|   350k|  for (i = 0; i + 8 <= num_pixels; i += 8) {
  ------------------
  |  Branch (377:15): [True: 140k, False: 209k]
  ------------------
  378|   140k|    const __m256i A = _mm256_loadu_si256((const __m256i*)(src + i));
  379|   140k|    const __m256i B = _mm256_shuffle_epi8(A, perm1);  // argb -> g0g0
  380|   140k|    const __m256i C = _mm256_mulhi_epi16(B, mults_rb);
  381|   140k|    const __m256i D = _mm256_add_epi8(A, C);
  382|   140k|    const __m256i E = _mm256_shuffle_epi8(D, perm2);
  383|   140k|    const __m256i F = _mm256_mulhi_epi16(E, mults_b2);
  384|   140k|    const __m256i G = _mm256_add_epi8(D, F);
  385|   140k|    const __m256i out = _mm256_blendv_epi8(G, A, mask_ag);
  386|   140k|    _mm256_storeu_si256((__m256i*)&dst[i], out);
  387|   140k|  }
  388|       |  // Fall-back to SSE-version for left-overs.
  389|   209k|  if (i != num_pixels) {
  ------------------
  |  Branch (389:7): [True: 180k, False: 28.6k]
  ------------------
  390|   180k|    VP8LTransformColorInverse_SSE(m, src + i, num_pixels - i, dst + i);
  391|   180k|  }
  392|   209k|}
lossless_avx2.c:ConvertBGRAToRGBA_AVX2:
  398|   161k|                                   int num_pixels, uint8_t* WEBP_RESTRICT dst) {
  399|   161k|  const __m256i* in = (const __m256i*)src;
  400|   161k|  __m256i* out = (__m256i*)dst;
  401|   703k|  while (num_pixels >= 8) {
  ------------------
  |  Branch (401:10): [True: 542k, False: 161k]
  ------------------
  402|   542k|    const __m256i A = _mm256_loadu_si256(in++);
  403|   542k|    const __m256i B = _mm256_shuffle_epi8(
  404|   542k|        A,
  405|   542k|        _mm256_set_epi8(15, 12, 13, 14, 11, 8, 9, 10, 7, 4, 5, 6, 3, 0, 1, 2,
  406|   542k|                        15, 12, 13, 14, 11, 8, 9, 10, 7, 4, 5, 6, 3, 0, 1, 2));
  407|   542k|    _mm256_storeu_si256(out++, B);
  408|   542k|    num_pixels -= 8;
  409|   542k|  }
  410|       |  // left-overs
  411|   161k|  if (num_pixels > 0) {
  ------------------
  |  Branch (411:7): [True: 151k, False: 9.07k]
  ------------------
  412|   151k|    VP8LConvertBGRAToRGBA_SSE((const uint32_t*)in, num_pixels, (uint8_t*)out);
  413|   151k|  }
  414|   161k|}

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

VP8LDspInitSSE2:
  675|      1|WEBP_TSAN_IGNORE_FUNCTION void VP8LDspInitSSE2(void) {
  676|      1|  VP8LPredictors[5] = Predictor5_SSE2;
  677|      1|  VP8LPredictors[6] = Predictor6_SSE2;
  678|      1|  VP8LPredictors[7] = Predictor7_SSE2;
  679|      1|  VP8LPredictors[8] = Predictor8_SSE2;
  680|      1|  VP8LPredictors[9] = Predictor9_SSE2;
  681|      1|  VP8LPredictors[10] = Predictor10_SSE2;
  682|      1|  VP8LPredictors[11] = Predictor11_SSE2;
  683|      1|  VP8LPredictors[12] = Predictor12_SSE2;
  684|      1|  VP8LPredictors[13] = Predictor13_SSE2;
  685|       |
  686|       |  // SSE exports for AVX and above.
  687|      1|  VP8LPredictorsAdd_SSE[0] = PredictorAdd0_SSE2;
  688|      1|  VP8LPredictorsAdd_SSE[1] = PredictorAdd1_SSE2;
  689|      1|  VP8LPredictorsAdd_SSE[2] = PredictorAdd2_SSE2;
  690|      1|  VP8LPredictorsAdd_SSE[3] = PredictorAdd3_SSE2;
  691|      1|  VP8LPredictorsAdd_SSE[4] = PredictorAdd4_SSE2;
  692|      1|  VP8LPredictorsAdd_SSE[5] = PredictorAdd5_SSE2;
  693|      1|  VP8LPredictorsAdd_SSE[6] = PredictorAdd6_SSE2;
  694|      1|  VP8LPredictorsAdd_SSE[7] = PredictorAdd7_SSE2;
  695|      1|  VP8LPredictorsAdd_SSE[8] = PredictorAdd8_SSE2;
  696|      1|  VP8LPredictorsAdd_SSE[9] = PredictorAdd9_SSE2;
  697|      1|  VP8LPredictorsAdd_SSE[10] = PredictorAdd10_SSE2;
  698|      1|  VP8LPredictorsAdd_SSE[11] = PredictorAdd11_SSE2;
  699|      1|  VP8LPredictorsAdd_SSE[12] = PredictorAdd12_SSE2;
  700|      1|  VP8LPredictorsAdd_SSE[13] = PredictorAdd13_SSE2;
  701|       |  // padding security sentinels
  702|      1|  VP8LPredictorsAdd_SSE[14] = PredictorAdd0_SSE2;
  703|      1|  VP8LPredictorsAdd_SSE[15] = PredictorAdd0_SSE2;
  704|      1|  memcpy(VP8LPredictorsAdd, VP8LPredictorsAdd_SSE, sizeof(VP8LPredictorsAdd));
  705|       |
  706|       |  // SSE exports for AVX and above.
  707|      1|  VP8LAddGreenToBlueAndRed_SSE = AddGreenToBlueAndRed_SSE2;
  708|      1|  VP8LTransformColorInverse_SSE = TransformColorInverse_SSE2;
  709|      1|  VP8LAddGreenToBlueAndRed = VP8LAddGreenToBlueAndRed_SSE;
  710|      1|  VP8LTransformColorInverse = VP8LTransformColorInverse_SSE;
  711|       |
  712|      1|  VP8LConvertBGRAToRGB = ConvertBGRAToRGB_SSE2;
  713|      1|  VP8LConvertBGRAToRGBA = ConvertBGRAToRGBA_SSE2;
  714|      1|  VP8LConvertBGRAToRGBA4444 = ConvertBGRAToRGBA4444_SSE2;
  715|      1|  VP8LConvertBGRAToRGB565 = ConvertBGRAToRGB565_SSE2;
  716|      1|  VP8LConvertBGRAToBGR = ConvertBGRAToBGR_SSE2;
  717|       |
  718|      1|  VP8LConvertBGRAToRGB_SSE = ConvertBGRAToRGB_SSE2;
  719|      1|  VP8LConvertBGRAToRGBA_SSE = ConvertBGRAToRGBA_SSE2;
  720|      1|}
lossless_sse2.c:Predictor5_SSE2:
  131|   178k|                                const uint32_t* const top) {
  132|   178k|  const uint32_t pred = Average3_SSE2(*left, top[0], top[1]);
  133|   178k|  return pred;
  134|   178k|}
lossless_sse2.c:Average3_SSE2:
  110|   178k|                                          uint32_t a2) {
  111|   178k|  const __m128i zero = _mm_setzero_si128();
  112|   178k|  const __m128i avg1 = Average2_uint32_16_SSE2(a0, a2);
  113|   178k|  const __m128i A1 = _mm_unpacklo_epi8(_mm_cvtsi32_si128((int)a1), zero);
  114|   178k|  const __m128i sum = _mm_add_epi16(avg1, A1);
  115|   178k|  const __m128i avg2 = _mm_srli_epi16(sum, 1);
  116|   178k|  const __m128i A2 = _mm_packus_epi16(avg2, avg2);
  117|   178k|  return (uint32_t)_mm_cvtsi128_si32(A2);
  118|   178k|}
lossless_sse2.c:Average2_uint32_16_SSE2:
   95|   178k|static WEBP_INLINE __m128i Average2_uint32_16_SSE2(uint32_t a0, uint32_t a1) {
   96|   178k|  const __m128i zero = _mm_setzero_si128();
   97|   178k|  const __m128i A0 = _mm_unpacklo_epi8(_mm_cvtsi32_si128((int)a0), zero);
   98|   178k|  const __m128i A1 = _mm_unpacklo_epi8(_mm_cvtsi32_si128((int)a1), zero);
   99|   178k|  const __m128i sum = _mm_add_epi16(A1, A0);
  100|   178k|  return _mm_srli_epi16(sum, 1);
  101|   178k|}
lossless_sse2.c:Predictor6_SSE2:
  136|   210k|                                const uint32_t* const top) {
  137|   210k|  const uint32_t pred = Average2_SSE2(*left, top[-1]);
  138|   210k|  return pred;
  139|   210k|}
lossless_sse2.c:Average2_SSE2:
  103|   337k|static WEBP_INLINE uint32_t Average2_SSE2(uint32_t a0, uint32_t a1) {
  104|   337k|  __m128i output;
  105|   337k|  Average2_uint32_SSE2(a0, a1, &output);
  106|   337k|  return (uint32_t)_mm_cvtsi128_si32(output);
  107|   337k|}
lossless_sse2.c:Average2_uint32_SSE2:
   85|   337k|                                             __m128i* const avg) {
   86|       |  // (a + b) >> 1 = ((a + b + 1) >> 1) - ((a ^ b) & 1)
   87|   337k|  const __m128i ones = _mm_set1_epi8(1);
   88|   337k|  const __m128i A0 = _mm_cvtsi32_si128((int)a0);
   89|   337k|  const __m128i A1 = _mm_cvtsi32_si128((int)a1);
   90|   337k|  const __m128i avg1 = _mm_avg_epu8(A0, A1);
   91|   337k|  const __m128i one = _mm_and_si128(_mm_xor_si128(A0, A1), ones);
   92|   337k|  *avg = _mm_sub_epi8(avg1, one);
   93|   337k|}
lossless_sse2.c:Predictor7_SSE2:
  141|   126k|                                const uint32_t* const top) {
  142|   126k|  const uint32_t pred = Average2_SSE2(*left, top[0]);
  143|   126k|  return pred;
  144|   126k|}
lossless_sse2.c:Predictor13_SSE2:
  173|  1.08M|                                 const uint32_t* const top) {
  174|  1.08M|  const uint32_t pred = ClampedAddSubtractHalf_SSE2(*left, top[0], top[-1]);
  175|  1.08M|  return pred;
  176|  1.08M|}
lossless_sse2.c:ClampedAddSubtractHalf_SSE2:
   46|  1.08M|                                                        uint32_t c2) {
   47|  1.08M|  const __m128i zero = _mm_setzero_si128();
   48|  1.08M|  const __m128i C0 = _mm_unpacklo_epi8(_mm_cvtsi32_si128((int)c0), zero);
   49|  1.08M|  const __m128i C1 = _mm_unpacklo_epi8(_mm_cvtsi32_si128((int)c1), zero);
   50|  1.08M|  const __m128i B0 = _mm_unpacklo_epi8(_mm_cvtsi32_si128((int)c2), zero);
   51|  1.08M|  const __m128i avg = _mm_add_epi16(C1, C0);
   52|  1.08M|  const __m128i A0 = _mm_srli_epi16(avg, 1);
   53|  1.08M|  const __m128i A1 = _mm_sub_epi16(A0, B0);
   54|  1.08M|  const __m128i BgtA = _mm_cmpgt_epi16(B0, A0);
   55|  1.08M|  const __m128i A2 = _mm_sub_epi16(A1, BgtA);
   56|  1.08M|  const __m128i A3 = _mm_srai_epi16(A2, 1);
   57|  1.08M|  const __m128i A4 = _mm_add_epi16(A0, A3);
   58|  1.08M|  const __m128i A5 = _mm_packus_epi16(A4, A4);
   59|  1.08M|  return (uint32_t)_mm_cvtsi128_si32(A5);
   60|  1.08M|}
lossless_sse2.c:PredictorAdd0_SSE2:
  182|   107k|                               int num_pixels, uint32_t* WEBP_RESTRICT out) {
  183|   107k|  int i;
  184|   107k|  const __m128i black = _mm_set1_epi32((int)ARGB_BLACK);
  ------------------
  |  |   38|   107k|#define ARGB_BLACK 0xff000000
  ------------------
  185|   206k|  for (i = 0; i + 4 <= num_pixels; i += 4) {
  ------------------
  |  Branch (185:15): [True: 99.6k, False: 107k]
  ------------------
  186|  99.6k|    const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);
  187|  99.6k|    const __m128i res = _mm_add_epi8(src, black);
  188|  99.6k|    _mm_storeu_si128((__m128i*)&out[i], res);
  189|  99.6k|  }
  190|   107k|  if (i != num_pixels) {
  ------------------
  |  Branch (190:7): [True: 53.1k, False: 54.0k]
  ------------------
  191|       |    VP8LPredictorsAdd_C[0](in + i, NULL, num_pixels - i, out + i);
  192|  53.1k|  }
  193|   107k|  (void)upper;
  194|   107k|}
lossless_sse2.c:PredictorAdd1_SSE2:
  198|  72.3k|                               int num_pixels, uint32_t* WEBP_RESTRICT out) {
  199|  72.3k|  int i;
  200|  72.3k|  __m128i prev = _mm_set1_epi32((int)out[-1]);
  201|   124k|  for (i = 0; i + 4 <= num_pixels; i += 4) {
  ------------------
  |  Branch (201:15): [True: 52.2k, False: 72.3k]
  ------------------
  202|       |    // a | b | c | d
  203|  52.2k|    const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);
  204|       |    // 0 | a | b | c
  205|  52.2k|    const __m128i shift0 = _mm_slli_si128(src, 4);
  206|       |    // a | a + b | b + c | c + d
  207|  52.2k|    const __m128i sum0 = _mm_add_epi8(src, shift0);
  208|       |    // 0 | 0 | a | a + b
  209|  52.2k|    const __m128i shift1 = _mm_slli_si128(sum0, 8);
  210|       |    // a | a + b | a + b + c | a + b + c + d
  211|  52.2k|    const __m128i sum1 = _mm_add_epi8(sum0, shift1);
  212|  52.2k|    const __m128i res = _mm_add_epi8(sum1, prev);
  213|  52.2k|    _mm_storeu_si128((__m128i*)&out[i], res);
  214|       |    // replicate prev output on the four lanes
  215|  52.2k|    prev = _mm_shuffle_epi32(res, (3 << 0) | (3 << 2) | (3 << 4) | (3 << 6));
  216|  52.2k|  }
  217|  72.3k|  if (i != num_pixels) {
  ------------------
  |  Branch (217:7): [True: 28.2k, False: 44.0k]
  ------------------
  218|  28.2k|    VP8LPredictorsAdd_C[1](in + i, upper + i, num_pixels - i, out + i);
  219|  28.2k|  }
  220|  72.3k|}
lossless_sse2.c:PredictorAdd2_SSE2:
  227|  15.3k|                                     uint32_t* WEBP_RESTRICT out) {         \
  228|  15.3k|    int i;                                                                  \
  229|  29.6k|    for (i = 0; i + 4 <= num_pixels; i += 4) {                              \
  ------------------
  |  Branch (229:17): [True: 14.2k, False: 15.3k]
  ------------------
  230|  14.2k|      const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);          \
  231|  14.2k|      const __m128i other = _mm_loadu_si128((const __m128i*)&(IN));         \
  232|  14.2k|      const __m128i res = _mm_add_epi8(src, other);                         \
  233|  14.2k|      _mm_storeu_si128((__m128i*)&out[i], res);                             \
  234|  14.2k|    }                                                                       \
  235|  15.3k|    if (i != num_pixels) {                                                  \
  ------------------
  |  Branch (235:9): [True: 6.75k, False: 8.59k]
  ------------------
  236|  6.75k|      VP8LPredictorsAdd_C[(X)](in + i, upper + i, num_pixels - i, out + i); \
  237|  6.75k|    }                                                                       \
  238|  15.3k|  }
lossless_sse2.c:PredictorAdd3_SSE2:
  227|  18.2k|                                     uint32_t* WEBP_RESTRICT out) {         \
  228|  18.2k|    int i;                                                                  \
  229|  30.7k|    for (i = 0; i + 4 <= num_pixels; i += 4) {                              \
  ------------------
  |  Branch (229:17): [True: 12.4k, False: 18.2k]
  ------------------
  230|  12.4k|      const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);          \
  231|  12.4k|      const __m128i other = _mm_loadu_si128((const __m128i*)&(IN));         \
  232|  12.4k|      const __m128i res = _mm_add_epi8(src, other);                         \
  233|  12.4k|      _mm_storeu_si128((__m128i*)&out[i], res);                             \
  234|  12.4k|    }                                                                       \
  235|  18.2k|    if (i != num_pixels) {                                                  \
  ------------------
  |  Branch (235:9): [True: 9.16k, False: 9.06k]
  ------------------
  236|  9.16k|      VP8LPredictorsAdd_C[(X)](in + i, upper + i, num_pixels - i, out + i); \
  237|  9.16k|    }                                                                       \
  238|  18.2k|  }
lossless_sse2.c:PredictorAdd4_SSE2:
  227|  48.8k|                                     uint32_t* WEBP_RESTRICT out) {         \
  228|  48.8k|    int i;                                                                  \
  229|  90.5k|    for (i = 0; i + 4 <= num_pixels; i += 4) {                              \
  ------------------
  |  Branch (229:17): [True: 41.7k, False: 48.8k]
  ------------------
  230|  41.7k|      const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);          \
  231|  41.7k|      const __m128i other = _mm_loadu_si128((const __m128i*)&(IN));         \
  232|  41.7k|      const __m128i res = _mm_add_epi8(src, other);                         \
  233|  41.7k|      _mm_storeu_si128((__m128i*)&out[i], res);                             \
  234|  41.7k|    }                                                                       \
  235|  48.8k|    if (i != num_pixels) {                                                  \
  ------------------
  |  Branch (235:9): [True: 11.5k, False: 37.2k]
  ------------------
  236|  11.5k|      VP8LPredictorsAdd_C[(X)](in + i, upper + i, num_pixels - i, out + i); \
  237|  11.5k|    }                                                                       \
  238|  48.8k|  }
lossless_sse2.c:PredictorAdd8_SSE2:
  257|  23.5k|                                     uint32_t* WEBP_RESTRICT out) {         \
  258|  23.5k|    int i;                                                                  \
  259|  41.8k|    for (i = 0; i + 4 <= num_pixels; i += 4) {                              \
  ------------------
  |  Branch (259:17): [True: 18.2k, False: 23.5k]
  ------------------
  260|  18.2k|      const __m128i Tother = _mm_loadu_si128((const __m128i*)&(IN));        \
  261|  18.2k|      const __m128i T = _mm_loadu_si128((const __m128i*)&upper[i]);         \
  262|  18.2k|      const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);          \
  263|  18.2k|      __m128i avg, res;                                                     \
  264|  18.2k|      Average2_m128i(&T, &Tother, &avg);                                    \
  265|  18.2k|      res = _mm_add_epi8(avg, src);                                         \
  266|  18.2k|      _mm_storeu_si128((__m128i*)&out[i], res);                             \
  267|  18.2k|    }                                                                       \
  268|  23.5k|    if (i != num_pixels) {                                                  \
  ------------------
  |  Branch (268:9): [True: 6.40k, False: 17.1k]
  ------------------
  269|  6.40k|      VP8LPredictorsAdd_C[(X)](in + i, upper + i, num_pixels - i, out + i); \
  270|  6.40k|    }                                                                       \
  271|  23.5k|  }
lossless_sse2.c:Average2_m128i:
   75|   213k|                                       __m128i* const avg) {
   76|       |  // (a + b) >> 1 = ((a + b + 1) >> 1) - ((a ^ b) & 1)
   77|   213k|  const __m128i ones = _mm_set1_epi8(1);
   78|   213k|  const __m128i avg1 = _mm_avg_epu8(*a0, *a1);
   79|   213k|  const __m128i one = _mm_and_si128(_mm_xor_si128(*a0, *a1), ones);
   80|   213k|  *avg = _mm_sub_epi8(avg1, one);
   81|   213k|}
lossless_sse2.c:PredictorAdd9_SSE2:
  257|  14.3k|                                     uint32_t* WEBP_RESTRICT out) {         \
  258|  14.3k|    int i;                                                                  \
  259|  27.6k|    for (i = 0; i + 4 <= num_pixels; i += 4) {                              \
  ------------------
  |  Branch (259:17): [True: 13.3k, False: 14.3k]
  ------------------
  260|  13.3k|      const __m128i Tother = _mm_loadu_si128((const __m128i*)&(IN));        \
  261|  13.3k|      const __m128i T = _mm_loadu_si128((const __m128i*)&upper[i]);         \
  262|  13.3k|      const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);          \
  263|  13.3k|      __m128i avg, res;                                                     \
  264|  13.3k|      Average2_m128i(&T, &Tother, &avg);                                    \
  265|  13.3k|      res = _mm_add_epi8(avg, src);                                         \
  266|  13.3k|      _mm_storeu_si128((__m128i*)&out[i], res);                             \
  267|  13.3k|    }                                                                       \
  268|  14.3k|    if (i != num_pixels) {                                                  \
  ------------------
  |  Branch (268:9): [True: 1.42k, False: 12.8k]
  ------------------
  269|  1.42k|      VP8LPredictorsAdd_C[(X)](in + i, upper + i, num_pixels - i, out + i); \
  270|  1.42k|    }                                                                       \
  271|  14.3k|  }
lossless_sse2.c:PredictorAdd10_SSE2:
  297|  23.8k|                                int num_pixels, uint32_t* WEBP_RESTRICT out) {
  298|  23.8k|  int i;
  299|  23.8k|  __m128i L = _mm_cvtsi32_si128((int)out[-1]);
  300|  44.0k|  for (i = 0; i + 4 <= num_pixels; i += 4) {
  ------------------
  |  Branch (300:15): [True: 20.2k, False: 23.8k]
  ------------------
  301|  20.2k|    __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);
  302|  20.2k|    __m128i TL = _mm_loadu_si128((const __m128i*)&upper[i - 1]);
  303|  20.2k|    const __m128i T = _mm_loadu_si128((const __m128i*)&upper[i]);
  304|  20.2k|    const __m128i TR = _mm_loadu_si128((const __m128i*)&upper[i + 1]);
  305|  20.2k|    __m128i avgTTR;
  306|  20.2k|    Average2_m128i(&T, &TR, &avgTTR);
  307|  20.2k|    DO_PRED10(0);
  ------------------
  |  |  280|  20.2k|  do {                                               \
  |  |  281|  20.2k|    __m128i avgLTL, avg;                             \
  |  |  282|  20.2k|    Average2_m128i(&L, &TL, &avgLTL);                \
  |  |  283|  20.2k|    Average2_m128i(&avgTTR, &avgLTL, &avg);          \
  |  |  284|  20.2k|    L = _mm_add_epi8(avg, src);                      \
  |  |  285|  20.2k|    out[i + (OUT)] = (uint32_t)_mm_cvtsi128_si32(L); \
  |  |  286|  20.2k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (286:12): [Folded, False: 20.2k]
  |  |  ------------------
  ------------------
  308|  20.2k|    DO_PRED10_SHIFT;
  ------------------
  |  |  289|  20.2k|  do {                                                          \
  |  |  290|  20.2k|    /* Rotate the pre-computed values for the next iteration.*/ \
  |  |  291|  20.2k|    avgTTR = _mm_srli_si128(avgTTR, 4);                         \
  |  |  292|  20.2k|    TL = _mm_srli_si128(TL, 4);                                 \
  |  |  293|  20.2k|    src = _mm_srli_si128(src, 4);                               \
  |  |  294|  20.2k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (294:12): [Folded, False: 20.2k]
  |  |  ------------------
  ------------------
  309|  20.2k|    DO_PRED10(1);
  ------------------
  |  |  280|  20.2k|  do {                                               \
  |  |  281|  20.2k|    __m128i avgLTL, avg;                             \
  |  |  282|  20.2k|    Average2_m128i(&L, &TL, &avgLTL);                \
  |  |  283|  20.2k|    Average2_m128i(&avgTTR, &avgLTL, &avg);          \
  |  |  284|  20.2k|    L = _mm_add_epi8(avg, src);                      \
  |  |  285|  20.2k|    out[i + (OUT)] = (uint32_t)_mm_cvtsi128_si32(L); \
  |  |  286|  20.2k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (286:12): [Folded, False: 20.2k]
  |  |  ------------------
  ------------------
  310|  20.2k|    DO_PRED10_SHIFT;
  ------------------
  |  |  289|  20.2k|  do {                                                          \
  |  |  290|  20.2k|    /* Rotate the pre-computed values for the next iteration.*/ \
  |  |  291|  20.2k|    avgTTR = _mm_srli_si128(avgTTR, 4);                         \
  |  |  292|  20.2k|    TL = _mm_srli_si128(TL, 4);                                 \
  |  |  293|  20.2k|    src = _mm_srli_si128(src, 4);                               \
  |  |  294|  20.2k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (294:12): [Folded, False: 20.2k]
  |  |  ------------------
  ------------------
  311|  20.2k|    DO_PRED10(2);
  ------------------
  |  |  280|  20.2k|  do {                                               \
  |  |  281|  20.2k|    __m128i avgLTL, avg;                             \
  |  |  282|  20.2k|    Average2_m128i(&L, &TL, &avgLTL);                \
  |  |  283|  20.2k|    Average2_m128i(&avgTTR, &avgLTL, &avg);          \
  |  |  284|  20.2k|    L = _mm_add_epi8(avg, src);                      \
  |  |  285|  20.2k|    out[i + (OUT)] = (uint32_t)_mm_cvtsi128_si32(L); \
  |  |  286|  20.2k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (286:12): [Folded, False: 20.2k]
  |  |  ------------------
  ------------------
  312|  20.2k|    DO_PRED10_SHIFT;
  ------------------
  |  |  289|  20.2k|  do {                                                          \
  |  |  290|  20.2k|    /* Rotate the pre-computed values for the next iteration.*/ \
  |  |  291|  20.2k|    avgTTR = _mm_srli_si128(avgTTR, 4);                         \
  |  |  292|  20.2k|    TL = _mm_srli_si128(TL, 4);                                 \
  |  |  293|  20.2k|    src = _mm_srli_si128(src, 4);                               \
  |  |  294|  20.2k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (294:12): [Folded, False: 20.2k]
  |  |  ------------------
  ------------------
  313|  20.2k|    DO_PRED10(3);
  ------------------
  |  |  280|  20.2k|  do {                                               \
  |  |  281|  20.2k|    __m128i avgLTL, avg;                             \
  |  |  282|  20.2k|    Average2_m128i(&L, &TL, &avgLTL);                \
  |  |  283|  20.2k|    Average2_m128i(&avgTTR, &avgLTL, &avg);          \
  |  |  284|  20.2k|    L = _mm_add_epi8(avg, src);                      \
  |  |  285|  20.2k|    out[i + (OUT)] = (uint32_t)_mm_cvtsi128_si32(L); \
  |  |  286|  20.2k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (286:12): [Folded, False: 20.2k]
  |  |  ------------------
  ------------------
  314|  20.2k|  }
  315|  23.8k|  if (i != num_pixels) {
  ------------------
  |  Branch (315:7): [True: 8.62k, False: 15.1k]
  ------------------
  316|  8.62k|    VP8LPredictorsAdd_C[10](in + i, upper + i, num_pixels - i, out + i);
  317|  8.62k|  }
  318|  23.8k|}
lossless_sse2.c:PredictorAdd11_SSE2:
  346|  13.7k|                                int num_pixels, uint32_t* WEBP_RESTRICT out) {
  347|  13.7k|  int i;
  348|  13.7k|  __m128i pa;
  349|  13.7k|  __m128i L = _mm_cvtsi32_si128((int)out[-1]);
  350|  25.9k|  for (i = 0; i + 4 <= num_pixels; i += 4) {
  ------------------
  |  Branch (350:15): [True: 12.1k, False: 13.7k]
  ------------------
  351|  12.1k|    __m128i T = _mm_loadu_si128((const __m128i*)&upper[i]);
  352|  12.1k|    __m128i TL = _mm_loadu_si128((const __m128i*)&upper[i - 1]);
  353|  12.1k|    __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);
  354|  12.1k|    {
  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|  12.1k|      const __m128i T_lo = _mm_unpacklo_epi32(T, T);
  359|  12.1k|      const __m128i TL_lo = _mm_unpacklo_epi32(TL, T);
  360|  12.1k|      const __m128i T_hi = _mm_unpackhi_epi32(T, T);
  361|  12.1k|      const __m128i TL_hi = _mm_unpackhi_epi32(TL, T);
  362|  12.1k|      const __m128i s_lo = _mm_sad_epu8(T_lo, TL_lo);
  363|  12.1k|      const __m128i s_hi = _mm_sad_epu8(T_hi, TL_hi);
  364|  12.1k|      pa = _mm_packs_epi32(s_lo, s_hi);  // pa = sum |T-TL|
  365|  12.1k|    }
  366|  12.1k|    DO_PRED11(0);
  ------------------
  |  |  324|  12.1k|  do {                                                                   \
  |  |  325|  12.1k|    const __m128i L_lo = _mm_unpacklo_epi32(L, T);                       \
  |  |  326|  12.1k|    const __m128i TL_lo = _mm_unpacklo_epi32(TL, T);                     \
  |  |  327|  12.1k|    const __m128i pb = _mm_sad_epu8(L_lo, TL_lo); /* pb = sum |L-TL|*/   \
  |  |  328|  12.1k|    const __m128i mask = _mm_cmpgt_epi32(pb, pa);                        \
  |  |  329|  12.1k|    const __m128i A = _mm_and_si128(mask, L);                            \
  |  |  330|  12.1k|    const __m128i B = _mm_andnot_si128(mask, T);                         \
  |  |  331|  12.1k|    const __m128i pred = _mm_or_si128(A, B); /* pred = (pa > b)? L : T*/ \
  |  |  332|  12.1k|    L = _mm_add_epi8(src, pred);                                         \
  |  |  333|  12.1k|    out[i + (OUT)] = (uint32_t)_mm_cvtsi128_si32(L);                     \
  |  |  334|  12.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (334:12): [Folded, False: 12.1k]
  |  |  ------------------
  ------------------
  367|  12.1k|    DO_PRED11_SHIFT;
  ------------------
  |  |  337|  12.1k|  do {                                                        \
  |  |  338|  12.1k|    /* Shift the pre-computed value for the next iteration.*/ \
  |  |  339|  12.1k|    T = _mm_srli_si128(T, 4);                                 \
  |  |  340|  12.1k|    TL = _mm_srli_si128(TL, 4);                               \
  |  |  341|  12.1k|    src = _mm_srli_si128(src, 4);                             \
  |  |  342|  12.1k|    pa = _mm_srli_si128(pa, 4);                               \
  |  |  343|  12.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (343:12): [Folded, False: 12.1k]
  |  |  ------------------
  ------------------
  368|  12.1k|    DO_PRED11(1);
  ------------------
  |  |  324|  12.1k|  do {                                                                   \
  |  |  325|  12.1k|    const __m128i L_lo = _mm_unpacklo_epi32(L, T);                       \
  |  |  326|  12.1k|    const __m128i TL_lo = _mm_unpacklo_epi32(TL, T);                     \
  |  |  327|  12.1k|    const __m128i pb = _mm_sad_epu8(L_lo, TL_lo); /* pb = sum |L-TL|*/   \
  |  |  328|  12.1k|    const __m128i mask = _mm_cmpgt_epi32(pb, pa);                        \
  |  |  329|  12.1k|    const __m128i A = _mm_and_si128(mask, L);                            \
  |  |  330|  12.1k|    const __m128i B = _mm_andnot_si128(mask, T);                         \
  |  |  331|  12.1k|    const __m128i pred = _mm_or_si128(A, B); /* pred = (pa > b)? L : T*/ \
  |  |  332|  12.1k|    L = _mm_add_epi8(src, pred);                                         \
  |  |  333|  12.1k|    out[i + (OUT)] = (uint32_t)_mm_cvtsi128_si32(L);                     \
  |  |  334|  12.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (334:12): [Folded, False: 12.1k]
  |  |  ------------------
  ------------------
  369|  12.1k|    DO_PRED11_SHIFT;
  ------------------
  |  |  337|  12.1k|  do {                                                        \
  |  |  338|  12.1k|    /* Shift the pre-computed value for the next iteration.*/ \
  |  |  339|  12.1k|    T = _mm_srli_si128(T, 4);                                 \
  |  |  340|  12.1k|    TL = _mm_srli_si128(TL, 4);                               \
  |  |  341|  12.1k|    src = _mm_srli_si128(src, 4);                             \
  |  |  342|  12.1k|    pa = _mm_srli_si128(pa, 4);                               \
  |  |  343|  12.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (343:12): [Folded, False: 12.1k]
  |  |  ------------------
  ------------------
  370|  12.1k|    DO_PRED11(2);
  ------------------
  |  |  324|  12.1k|  do {                                                                   \
  |  |  325|  12.1k|    const __m128i L_lo = _mm_unpacklo_epi32(L, T);                       \
  |  |  326|  12.1k|    const __m128i TL_lo = _mm_unpacklo_epi32(TL, T);                     \
  |  |  327|  12.1k|    const __m128i pb = _mm_sad_epu8(L_lo, TL_lo); /* pb = sum |L-TL|*/   \
  |  |  328|  12.1k|    const __m128i mask = _mm_cmpgt_epi32(pb, pa);                        \
  |  |  329|  12.1k|    const __m128i A = _mm_and_si128(mask, L);                            \
  |  |  330|  12.1k|    const __m128i B = _mm_andnot_si128(mask, T);                         \
  |  |  331|  12.1k|    const __m128i pred = _mm_or_si128(A, B); /* pred = (pa > b)? L : T*/ \
  |  |  332|  12.1k|    L = _mm_add_epi8(src, pred);                                         \
  |  |  333|  12.1k|    out[i + (OUT)] = (uint32_t)_mm_cvtsi128_si32(L);                     \
  |  |  334|  12.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (334:12): [Folded, False: 12.1k]
  |  |  ------------------
  ------------------
  371|  12.1k|    DO_PRED11_SHIFT;
  ------------------
  |  |  337|  12.1k|  do {                                                        \
  |  |  338|  12.1k|    /* Shift the pre-computed value for the next iteration.*/ \
  |  |  339|  12.1k|    T = _mm_srli_si128(T, 4);                                 \
  |  |  340|  12.1k|    TL = _mm_srli_si128(TL, 4);                               \
  |  |  341|  12.1k|    src = _mm_srli_si128(src, 4);                             \
  |  |  342|  12.1k|    pa = _mm_srli_si128(pa, 4);                               \
  |  |  343|  12.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (343:12): [Folded, False: 12.1k]
  |  |  ------------------
  ------------------
  372|  12.1k|    DO_PRED11(3);
  ------------------
  |  |  324|  12.1k|  do {                                                                   \
  |  |  325|  12.1k|    const __m128i L_lo = _mm_unpacklo_epi32(L, T);                       \
  |  |  326|  12.1k|    const __m128i TL_lo = _mm_unpacklo_epi32(TL, T);                     \
  |  |  327|  12.1k|    const __m128i pb = _mm_sad_epu8(L_lo, TL_lo); /* pb = sum |L-TL|*/   \
  |  |  328|  12.1k|    const __m128i mask = _mm_cmpgt_epi32(pb, pa);                        \
  |  |  329|  12.1k|    const __m128i A = _mm_and_si128(mask, L);                            \
  |  |  330|  12.1k|    const __m128i B = _mm_andnot_si128(mask, T);                         \
  |  |  331|  12.1k|    const __m128i pred = _mm_or_si128(A, B); /* pred = (pa > b)? L : T*/ \
  |  |  332|  12.1k|    L = _mm_add_epi8(src, pred);                                         \
  |  |  333|  12.1k|    out[i + (OUT)] = (uint32_t)_mm_cvtsi128_si32(L);                     \
  |  |  334|  12.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (334:12): [Folded, False: 12.1k]
  |  |  ------------------
  ------------------
  373|  12.1k|  }
  374|  13.7k|  if (i != num_pixels) {
  ------------------
  |  Branch (374:7): [True: 5.31k, False: 8.48k]
  ------------------
  375|  5.31k|    VP8LPredictorsAdd_C[11](in + i, upper + i, num_pixels - i, out + i);
  376|  5.31k|  }
  377|  13.7k|}
lossless_sse2.c:PredictorAdd12_SSE2:
  399|  23.8k|                                int num_pixels, uint32_t* WEBP_RESTRICT out) {
  400|  23.8k|  int i;
  401|  23.8k|  const __m128i zero = _mm_setzero_si128();
  402|  23.8k|  const __m128i L8 = _mm_cvtsi32_si128((int)out[-1]);
  403|  23.8k|  __m128i L = _mm_unpacklo_epi8(L8, zero);
  404|  33.2k|  for (i = 0; i + 4 <= num_pixels; i += 4) {
  ------------------
  |  Branch (404:15): [True: 9.36k, False: 23.8k]
  ------------------
  405|       |    // Load 4 pixels at a time.
  406|  9.36k|    __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);
  407|  9.36k|    const __m128i T = _mm_loadu_si128((const __m128i*)&upper[i]);
  408|  9.36k|    const __m128i T_lo = _mm_unpacklo_epi8(T, zero);
  409|  9.36k|    const __m128i T_hi = _mm_unpackhi_epi8(T, zero);
  410|  9.36k|    const __m128i TL = _mm_loadu_si128((const __m128i*)&upper[i - 1]);
  411|  9.36k|    const __m128i TL_lo = _mm_unpacklo_epi8(TL, zero);
  412|  9.36k|    const __m128i TL_hi = _mm_unpackhi_epi8(TL, zero);
  413|  9.36k|    __m128i diff_lo = _mm_sub_epi16(T_lo, TL_lo);
  414|  9.36k|    __m128i diff_hi = _mm_sub_epi16(T_hi, TL_hi);
  415|  9.36k|    DO_PRED12(diff_lo, 0, 0);
  ------------------
  |  |  383|  9.36k|  do {                                                 \
  |  |  384|  9.36k|    const __m128i all = _mm_add_epi16(L, (DIFF));      \
  |  |  385|  9.36k|    const __m128i alls = _mm_packus_epi16(all, all);   \
  |  |  386|  9.36k|    const __m128i res = _mm_add_epi8(src, alls);       \
  |  |  387|  9.36k|    out[i + (OUT)] = (uint32_t)_mm_cvtsi128_si32(res); \
  |  |  388|  9.36k|    L = _mm_unpacklo_epi8(res, zero);                  \
  |  |  389|  9.36k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (389:12): [Folded, False: 9.36k]
  |  |  ------------------
  ------------------
  416|  9.36k|    DO_PRED12_SHIFT(diff_lo, 0);
  ------------------
  |  |  392|  9.36k|  do {                                                        \
  |  |  393|  9.36k|    /* Shift the pre-computed value for the next iteration.*/ \
  |  |  394|  9.36k|    if ((LANE) == 0) (DIFF) = _mm_srli_si128((DIFF), 8);      \
  |  |  ------------------
  |  |  |  Branch (394:9): [True: 9.36k, Folded]
  |  |  ------------------
  |  |  395|  9.36k|    src = _mm_srli_si128(src, 4);                             \
  |  |  396|  9.36k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (396:12): [Folded, False: 9.36k]
  |  |  ------------------
  ------------------
  417|  9.36k|    DO_PRED12(diff_lo, 1, 1);
  ------------------
  |  |  383|  9.36k|  do {                                                 \
  |  |  384|  9.36k|    const __m128i all = _mm_add_epi16(L, (DIFF));      \
  |  |  385|  9.36k|    const __m128i alls = _mm_packus_epi16(all, all);   \
  |  |  386|  9.36k|    const __m128i res = _mm_add_epi8(src, alls);       \
  |  |  387|  9.36k|    out[i + (OUT)] = (uint32_t)_mm_cvtsi128_si32(res); \
  |  |  388|  9.36k|    L = _mm_unpacklo_epi8(res, zero);                  \
  |  |  389|  9.36k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (389:12): [Folded, False: 9.36k]
  |  |  ------------------
  ------------------
  418|  9.36k|    DO_PRED12_SHIFT(diff_lo, 1);
  ------------------
  |  |  392|  9.36k|  do {                                                        \
  |  |  393|  9.36k|    /* Shift the pre-computed value for the next iteration.*/ \
  |  |  394|  9.36k|    if ((LANE) == 0) (DIFF) = _mm_srli_si128((DIFF), 8);      \
  |  |  ------------------
  |  |  |  Branch (394:9): [Folded, False: 9.36k]
  |  |  ------------------
  |  |  395|  9.36k|    src = _mm_srli_si128(src, 4);                             \
  |  |  396|  9.36k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (396:12): [Folded, False: 9.36k]
  |  |  ------------------
  ------------------
  419|  9.36k|    DO_PRED12(diff_hi, 0, 2);
  ------------------
  |  |  383|  9.36k|  do {                                                 \
  |  |  384|  9.36k|    const __m128i all = _mm_add_epi16(L, (DIFF));      \
  |  |  385|  9.36k|    const __m128i alls = _mm_packus_epi16(all, all);   \
  |  |  386|  9.36k|    const __m128i res = _mm_add_epi8(src, alls);       \
  |  |  387|  9.36k|    out[i + (OUT)] = (uint32_t)_mm_cvtsi128_si32(res); \
  |  |  388|  9.36k|    L = _mm_unpacklo_epi8(res, zero);                  \
  |  |  389|  9.36k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (389:12): [Folded, False: 9.36k]
  |  |  ------------------
  ------------------
  420|  9.36k|    DO_PRED12_SHIFT(diff_hi, 0);
  ------------------
  |  |  392|  9.36k|  do {                                                        \
  |  |  393|  9.36k|    /* Shift the pre-computed value for the next iteration.*/ \
  |  |  394|  9.36k|    if ((LANE) == 0) (DIFF) = _mm_srli_si128((DIFF), 8);      \
  |  |  ------------------
  |  |  |  Branch (394:9): [True: 9.36k, Folded]
  |  |  ------------------
  |  |  395|  9.36k|    src = _mm_srli_si128(src, 4);                             \
  |  |  396|  9.36k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (396:12): [Folded, False: 9.36k]
  |  |  ------------------
  ------------------
  421|  9.36k|    DO_PRED12(diff_hi, 1, 3);
  ------------------
  |  |  383|  9.36k|  do {                                                 \
  |  |  384|  9.36k|    const __m128i all = _mm_add_epi16(L, (DIFF));      \
  |  |  385|  9.36k|    const __m128i alls = _mm_packus_epi16(all, all);   \
  |  |  386|  9.36k|    const __m128i res = _mm_add_epi8(src, alls);       \
  |  |  387|  9.36k|    out[i + (OUT)] = (uint32_t)_mm_cvtsi128_si32(res); \
  |  |  388|  9.36k|    L = _mm_unpacklo_epi8(res, zero);                  \
  |  |  389|  9.36k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (389:12): [Folded, False: 9.36k]
  |  |  ------------------
  ------------------
  422|  9.36k|  }
  423|  23.8k|  if (i != num_pixels) {
  ------------------
  |  Branch (423:7): [True: 20.5k, False: 3.38k]
  ------------------
  424|  20.5k|    VP8LPredictorsAdd_C[12](in + i, upper + i, num_pixels - i, out + i);
  425|  20.5k|  }
  426|  23.8k|}
lossless_sse2.c:AddGreenToBlueAndRed_SSE2:
  438|     79|                                      uint32_t* dst) {
  439|     79|  int i;
  440|    124|  for (i = 0; i + 4 <= num_pixels; i += 4) {
  ------------------
  |  Branch (440:15): [True: 45, False: 79]
  ------------------
  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|     79|  if (i != num_pixels) {
  ------------------
  |  Branch (449:7): [True: 66, False: 13]
  ------------------
  450|     66|    VP8LAddGreenToBlueAndRed_C(src + i, num_pixels - i, dst + i);
  451|     66|  }
  452|     79|}
lossless_sse2.c:ConvertBGRAToRGBA_SSE2:
  531|   151k|                                   int num_pixels, uint8_t* WEBP_RESTRICT dst) {
  532|   151k|  const __m128i red_blue_mask = _mm_set1_epi32(0x00ff00ff);
  533|   151k|  const __m128i* in = (const __m128i*)src;
  534|   151k|  __m128i* out = (__m128i*)dst;
  535|   151k|  while (num_pixels >= 8) {
  ------------------
  |  Branch (535:10): [True: 0, False: 151k]
  ------------------
  536|      0|    const __m128i A1 = _mm_loadu_si128(in++);
  537|      0|    const __m128i A2 = _mm_loadu_si128(in++);
  538|      0|    const __m128i B1 = _mm_and_si128(A1, red_blue_mask);     // R 0 B 0
  539|      0|    const __m128i B2 = _mm_and_si128(A2, red_blue_mask);     // R 0 B 0
  540|      0|    const __m128i C1 = _mm_andnot_si128(red_blue_mask, A1);  // 0 G 0 A
  541|      0|    const __m128i C2 = _mm_andnot_si128(red_blue_mask, A2);  // 0 G 0 A
  542|      0|    const __m128i D1 = _mm_shufflelo_epi16(B1, _MM_SHUFFLE(2, 3, 0, 1));
  543|      0|    const __m128i D2 = _mm_shufflelo_epi16(B2, _MM_SHUFFLE(2, 3, 0, 1));
  544|      0|    const __m128i E1 = _mm_shufflehi_epi16(D1, _MM_SHUFFLE(2, 3, 0, 1));
  545|      0|    const __m128i E2 = _mm_shufflehi_epi16(D2, _MM_SHUFFLE(2, 3, 0, 1));
  546|      0|    const __m128i F1 = _mm_or_si128(E1, C1);
  547|      0|    const __m128i F2 = _mm_or_si128(E2, C2);
  548|      0|    _mm_storeu_si128(out++, F1);
  549|      0|    _mm_storeu_si128(out++, F2);
  550|      0|    num_pixels -= 8;
  551|      0|  }
  552|       |  // left-overs
  553|   151k|  if (num_pixels > 0) {
  ------------------
  |  Branch (553:7): [True: 151k, False: 0]
  ------------------
  554|   151k|    VP8LConvertBGRAToRGBA_C((const uint32_t*)in, num_pixels, (uint8_t*)out);
  555|   151k|  }
  556|   151k|}

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

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|   243k|                                  uint8_t* WEBP_RESTRICT const out) {
  103|   243k|  UPSAMPLE_32PIXELS(r1, r2, out);
  ------------------
  |  |   70|   243k|  do {                                                                         \
  |  |   71|   243k|    const __m128i one = _mm_set1_epi8(1);                                      \
  |  |   72|   243k|    const __m128i a = _mm_loadu_si128((const __m128i*)&(r1)[0]);               \
  |  |   73|   243k|    const __m128i b = _mm_loadu_si128((const __m128i*)&(r1)[1]);               \
  |  |   74|   243k|    const __m128i c = _mm_loadu_si128((const __m128i*)&(r2)[0]);               \
  |  |   75|   243k|    const __m128i d = _mm_loadu_si128((const __m128i*)&(r2)[1]);               \
  |  |   76|   243k|                                                                               \
  |  |   77|   243k|    const __m128i s = _mm_avg_epu8(a, d);   /* s = (a + d + 1) / 2 */          \
  |  |   78|   243k|    const __m128i t = _mm_avg_epu8(b, c);   /* t = (b + c + 1) / 2 */          \
  |  |   79|   243k|    const __m128i st = _mm_xor_si128(s, t); /* st = s^t */                     \
  |  |   80|   243k|                                                                               \
  |  |   81|   243k|    const __m128i ad = _mm_xor_si128(a, d); /* ad = a^d */                     \
  |  |   82|   243k|    const __m128i bc = _mm_xor_si128(b, c); /* bc = b^c */                     \
  |  |   83|   243k|                                                                               \
  |  |   84|   243k|    const __m128i t1 = _mm_or_si128(ad, bc);   /* (a^d) | (b^c) */             \
  |  |   85|   243k|    const __m128i t2 = _mm_or_si128(t1, st);   /* (a^d) | (b^c) | (s^t) */     \
  |  |   86|   243k|    const __m128i t3 = _mm_and_si128(t2, one); /* (a^d) | (b^c) | (s^t) & 1 */ \
  |  |   87|   243k|    const __m128i t4 = _mm_avg_epu8(s, t);                                     \
  |  |   88|   243k|    const __m128i k = _mm_sub_epi8(t4, t3); /* k = (a + b + c + d) / 4 */      \
  |  |   89|   243k|    __m128i diag1, diag2;                                                      \
  |  |   90|   243k|                                                                               \
  |  |   91|   243k|    GET_M(bc, t, diag1); /* diag1 = (a + 3b + 3c + d) / 8 */                   \
  |  |  ------------------
  |  |  |  |   45|   243k|  do {                                                                         \
  |  |  |  |   46|   243k|    const __m128i tmp0 = _mm_avg_epu8(k, (in));   /* (k + in + 1) / 2 */       \
  |  |  |  |   47|   243k|    const __m128i tmp1 = _mm_and_si128((ij), st); /* (ij) & (s^t) */           \
  |  |  |  |   48|   243k|    const __m128i tmp2 = _mm_xor_si128(k, (in));  /* (k^in) */                 \
  |  |  |  |   49|   243k|    const __m128i tmp3 =                                                       \
  |  |  |  |   50|   243k|        _mm_or_si128(tmp1, tmp2); /* ((ij) & (s^t)) | (k^in) */                \
  |  |  |  |   51|   243k|    const __m128i tmp4 = _mm_and_si128(tmp3, one); /* & 1 -> lsb_correction */ \
  |  |  |  |   52|   243k|    (out) = _mm_sub_epi8(tmp0, tmp4); /* (k + in + 1) / 2 - lsb_correction */  \
  |  |  |  |   53|   243k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (53:12): [Folded, False: 243k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   92|   243k|    GET_M(ad, s, diag2); /* diag2 = (3a + b + c + 3d) / 8 */                   \
  |  |  ------------------
  |  |  |  |   45|   243k|  do {                                                                         \
  |  |  |  |   46|   243k|    const __m128i tmp0 = _mm_avg_epu8(k, (in));   /* (k + in + 1) / 2 */       \
  |  |  |  |   47|   243k|    const __m128i tmp1 = _mm_and_si128((ij), st); /* (ij) & (s^t) */           \
  |  |  |  |   48|   243k|    const __m128i tmp2 = _mm_xor_si128(k, (in));  /* (k^in) */                 \
  |  |  |  |   49|   243k|    const __m128i tmp3 =                                                       \
  |  |  |  |   50|   243k|        _mm_or_si128(tmp1, tmp2); /* ((ij) & (s^t)) | (k^in) */                \
  |  |  |  |   51|   243k|    const __m128i tmp4 = _mm_and_si128(tmp3, one); /* & 1 -> lsb_correction */ \
  |  |  |  |   52|   243k|    (out) = _mm_sub_epi8(tmp0, tmp4); /* (k + in + 1) / 2 - lsb_correction */  \
  |  |  |  |   53|   243k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (53:12): [Folded, False: 243k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   93|   243k|                                                                               \
  |  |   94|   243k|    /* pack the alternate pixels */                                            \
  |  |   95|   243k|    PACK_AND_STORE(a, b, diag1, diag2, (out) + 0);      /* store top */        \
  |  |  ------------------
  |  |  |  |   57|   243k|  do {                                                          \
  |  |  |  |   58|   243k|    const __m128i t_a =                                         \
  |  |  |  |   59|   243k|        _mm_avg_epu8(a, da); /* (9a + 3b + 3c +  d + 8) / 16 */ \
  |  |  |  |   60|   243k|    const __m128i t_b =                                         \
  |  |  |  |   61|   243k|        _mm_avg_epu8(b, db); /* (3a + 9b +  c + 3d + 8) / 16 */ \
  |  |  |  |   62|   243k|    const __m128i t_1 = _mm_unpacklo_epi8(t_a, t_b);            \
  |  |  |  |   63|   243k|    const __m128i t_2 = _mm_unpackhi_epi8(t_a, t_b);            \
  |  |  |  |   64|   243k|    _mm_store_si128(((__m128i*)(out)) + 0, t_1);                \
  |  |  |  |   65|   243k|    _mm_store_si128(((__m128i*)(out)) + 1, t_2);                \
  |  |  |  |   66|   243k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (66:12): [Folded, False: 243k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   96|   243k|    PACK_AND_STORE(c, d, diag2, diag1, (out) + 2 * 32); /* store bottom */     \
  |  |  ------------------
  |  |  |  |   57|   243k|  do {                                                          \
  |  |  |  |   58|   243k|    const __m128i t_a =                                         \
  |  |  |  |   59|   243k|        _mm_avg_epu8(a, da); /* (9a + 3b + 3c +  d + 8) / 16 */ \
  |  |  |  |   60|   243k|    const __m128i t_b =                                         \
  |  |  |  |   61|   243k|        _mm_avg_epu8(b, db); /* (3a + 9b +  c + 3d + 8) / 16 */ \
  |  |  |  |   62|   243k|    const __m128i t_1 = _mm_unpacklo_epi8(t_a, t_b);            \
  |  |  |  |   63|   243k|    const __m128i t_2 = _mm_unpackhi_epi8(t_a, t_b);            \
  |  |  |  |   64|   243k|    _mm_store_si128(((__m128i*)(out)) + 0, t_1);                \
  |  |  |  |   65|   243k|    _mm_store_si128(((__m128i*)(out)) + 1, t_2);                \
  |  |  |  |   66|   243k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (66:12): [Folded, False: 243k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   97|   243k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (97:12): [Folded, False: 243k]
  |  |  ------------------
  ------------------
  104|   243k|}

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

WebPConvertRGBA32ToUV_C:
  209|   108k|                             int width) {
  210|   108k|  int i;
  211|   382k|  for (i = 0; i < width; i += 1, rgb += 4) {
  ------------------
  |  Branch (211:15): [True: 274k, False: 108k]
  ------------------
  212|   274k|    const int r = rgb[0], g = rgb[1], b = rgb[2];
  213|   274k|    u[i] = VP8RGBToU(r, g, b, YUV_HALF << 2);
  214|   274k|    v[i] = VP8RGBToV(r, g, b, YUV_HALF << 2);
  215|   274k|  }
  216|   108k|}
WebPAccumulateRGB:
  492|   110k|                       uint16_t* dst, int width) {
  493|   110k|  int i, j;
  494|  1.26M|  for (i = 0, j = 0; i < (width >> 1); i += 1, j += 2 * step, dst += 4) {
  ------------------
  |  Branch (494:22): [True: 1.15M, False: 110k]
  ------------------
  495|  1.15M|    dst[0] = SUM4(r_ptr + j, step);
  ------------------
  |  |  297|  1.15M|  LinearToGamma(GammaToLinear((ptr)[0]) + GammaToLinear((ptr)[(step)]) + \
  |  |  298|  1.15M|                    GammaToLinear((ptr)[rgb_stride]) +                   \
  |  |  299|  1.15M|                    GammaToLinear((ptr)[rgb_stride + (step)]),           \
  |  |  300|  1.15M|                0)
  ------------------
  496|  1.15M|    dst[1] = SUM4(g_ptr + j, step);
  ------------------
  |  |  297|  1.15M|  LinearToGamma(GammaToLinear((ptr)[0]) + GammaToLinear((ptr)[(step)]) + \
  |  |  298|  1.15M|                    GammaToLinear((ptr)[rgb_stride]) +                   \
  |  |  299|  1.15M|                    GammaToLinear((ptr)[rgb_stride + (step)]),           \
  |  |  300|  1.15M|                0)
  ------------------
  497|  1.15M|    dst[2] = SUM4(b_ptr + j, step);
  ------------------
  |  |  297|  1.15M|  LinearToGamma(GammaToLinear((ptr)[0]) + GammaToLinear((ptr)[(step)]) + \
  |  |  298|  1.15M|                    GammaToLinear((ptr)[rgb_stride]) +                   \
  |  |  299|  1.15M|                    GammaToLinear((ptr)[rgb_stride + (step)]),           \
  |  |  300|  1.15M|                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.15M|  }
  505|   110k|  if (width & 1) {
  ------------------
  |  Branch (505:7): [True: 82.3k, False: 28.0k]
  ------------------
  506|  82.3k|    dst[0] = SUM2(r_ptr + j);
  ------------------
  |  |  303|  82.3k|  LinearToGamma(GammaToLinear((ptr)[0]) + GammaToLinear((ptr)[rgb_stride]), 1)
  ------------------
  507|  82.3k|    dst[1] = SUM2(g_ptr + j);
  ------------------
  |  |  303|  82.3k|  LinearToGamma(GammaToLinear((ptr)[0]) + GammaToLinear((ptr)[rgb_stride]), 1)
  ------------------
  508|  82.3k|    dst[2] = SUM2(b_ptr + j);
  ------------------
  |  |  303|  82.3k|  LinearToGamma(GammaToLinear((ptr)[0]) + GammaToLinear((ptr)[rgb_stride]), 1)
  ------------------
  509|       |#ifdef WEBP_MSAN
  510|       |    dst[3] = 0;
  511|       |#endif
  512|  82.3k|  }
  513|   110k|}
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|  3.71M|static WEBP_INLINE int LinearToGamma(uint32_t base_value, int shift) {
  270|  3.71M|  const int y = Interpolate(base_value << shift);  // final uplifted value
  271|  3.71M|  return (y + kGammaTabRounder) >> GAMMA_TAB_FIX;  // descale
  ------------------
  |  |  225|  3.71M|#define GAMMA_TAB_FIX 7  // fixed-point fractional bits precision
  ------------------
  272|  3.71M|}
yuv.c:Interpolate:
  257|  3.71M|static WEBP_INLINE int Interpolate(int v) {
  258|  3.71M|  const int tab_pos = v >> (GAMMA_TAB_FIX + 2);   // integer part
  ------------------
  |  |  225|  3.71M|#define GAMMA_TAB_FIX 7  // fixed-point fractional bits precision
  ------------------
  259|  3.71M|  const int x = v & ((kGammaTabScale << 2) - 1);  // fractional part
  260|  3.71M|  const int v0 = kLinearToGammaTab[tab_pos];
  261|  3.71M|  const int v1 = kLinearToGammaTab[tab_pos + 1];
  262|  3.71M|  const int y = v1 * x + v0 * ((kGammaTabScale << 2) - x);  // interpolate
  263|       |  assert(tab_pos + 1 < GAMMA_TAB_SIZE + 1);
  264|  3.71M|  return y;
  265|  3.71M|}
yuv.c:GammaToLinear:
  253|  14.3M|static WEBP_INLINE uint32_t GammaToLinear(uint8_t v) {
  254|  14.3M|  return kGammaToLinearTab[v];
  255|  14.3M|}
yuv.c:WebPInitConvertARGBToYUV_body:
  644|      1|WEBP_DSP_INIT_FUNC(WebPInitConvertARGBToYUV) {
  645|      1|  WebPConvertARGBToY = ConvertARGBToY_C;
  646|      1|  WebPConvertARGBToUV = WebPConvertARGBToUV_C;
  647|       |
  648|      1|  WebPConvertRGBToY = ConvertRGBToY_C;
  649|      1|  WebPConvertBGRToY = ConvertBGRToY_C;
  650|       |
  651|      1|  WebPConvertRGBA32ToUV = WebPConvertRGBA32ToUV_C;
  652|       |
  653|      1|  WebPImportYUVAFromRGBA = ImportYUVAFromRGBA_C;
  654|      1|  WebPImportYUVAFromRGBALastLine = ImportYUVAFromRGBALastLine_C;
  655|       |
  656|      1|  if (VP8GetCPUInfo != NULL) {
  ------------------
  |  Branch (656:7): [True: 1, False: 0]
  ------------------
  657|      1|#if defined(WEBP_HAVE_SSE2)
  658|      1|    if (VP8GetCPUInfo(kSSE2)) {
  ------------------
  |  Branch (658:9): [True: 1, False: 0]
  ------------------
  659|      1|      WebPInitConvertARGBToYUVSSE2();
  660|      1|    }
  661|      1|#endif  // WEBP_HAVE_SSE2
  662|      1|#if defined(WEBP_HAVE_SSE41)
  663|      1|    if (VP8GetCPUInfo(kSSE4_1)) {
  ------------------
  |  Branch (663:9): [True: 1, False: 0]
  ------------------
  664|      1|      WebPInitConvertARGBToYUVSSE41();
  665|      1|    }
  666|      1|#endif  // WEBP_HAVE_SSE41
  667|      1|  }
  668|       |
  669|       |#if defined(WEBP_HAVE_NEON)
  670|       |  if (WEBP_NEON_OMIT_C_CODE ||
  671|       |      (VP8GetCPUInfo != NULL && VP8GetCPUInfo(kNEON))) {
  672|       |    WebPInitConvertARGBToYUVNEON();
  673|       |  }
  674|       |#endif  // WEBP_HAVE_NEON
  675|       |
  676|      1|  assert(WebPConvertARGBToY != NULL);
  677|      1|  assert(WebPConvertARGBToUV != NULL);
  678|      1|  assert(WebPConvertRGBToY != NULL);
  679|      1|  assert(WebPConvertBGRToY != NULL);
  680|       |  assert(WebPConvertRGBA32ToUV != NULL);
  681|      1|}
yuv.c:ImportYUVAFromRGBA_C:
  522|  13.9k|                                 uint8_t* dst_v, uint8_t* dst_a) {
  523|  13.9k|  int y;
  524|  13.9k|  const int is_rgb = (r_ptr < b_ptr);  // otherwise it's bgr
  525|  13.9k|  const int uv_width = (width + 1) >> 1;
  526|       |
  527|  13.9k|  has_alpha &= dst_a != NULL;
  528|  13.9k|  if (has_alpha) {
  ------------------
  |  Branch (528:7): [True: 0, False: 13.9k]
  ------------------
  529|      0|#if defined(USE_GAMMA_COMPRESSION) && defined(USE_INVERSE_ALPHA_TABLE)
  530|      0|    assert(kAlphaFix + GAMMA_FIX <= 31);
  531|      0|#endif
  532|      0|  }
  533|       |
  534|  13.9k|  WebPInitGammaTables();
  535|       |
  536|       |  // Downsample Y/U/V planes, two rows at a time
  537|   124k|  for (y = 0; y < (height >> 1); ++y) {
  ------------------
  |  Branch (537:15): [True: 110k, False: 13.9k]
  ------------------
  538|   110k|    int rows_have_alpha = has_alpha;
  539|   110k|    if (is_rgb) {
  ------------------
  |  Branch (539:9): [True: 0, False: 110k]
  ------------------
  540|      0|      WebPConvertRGBToY(r_ptr, dst_y, width, step);
  541|      0|      WebPConvertRGBToY(r_ptr + rgb_stride, dst_y + y_stride, width, step);
  542|   110k|    } else {
  543|   110k|      WebPConvertBGRToY(b_ptr, dst_y, width, step);
  544|   110k|      WebPConvertBGRToY(b_ptr + rgb_stride, dst_y + y_stride, width, step);
  545|   110k|    }
  546|   110k|    dst_y += 2 * y_stride;
  547|   110k|    if (has_alpha) {
  ------------------
  |  Branch (547:9): [True: 0, False: 110k]
  ------------------
  548|      0|      rows_have_alpha &=
  549|      0|          !WebPExtractAlpha(a_ptr, rgb_stride, width, 2, dst_a, a_stride);
  550|      0|      dst_a += 2 * a_stride;
  551|   110k|    } else if (dst_a != NULL) {
  ------------------
  |  Branch (551:16): [True: 0, False: 110k]
  ------------------
  552|      0|      int i;
  553|      0|      for (i = 0; i < 2; ++i, dst_a += a_stride) {
  ------------------
  |  Branch (553:19): [True: 0, False: 0]
  ------------------
  554|      0|        memset(dst_a, 0xff, width);
  555|      0|      }
  556|      0|    }
  557|       |
  558|       |    // Collect averaged R/G/B(/A)
  559|   110k|    if (!rows_have_alpha) {
  ------------------
  |  Branch (559:9): [True: 110k, False: 0]
  ------------------
  560|   110k|      WebPAccumulateRGB(r_ptr, g_ptr, b_ptr, step, rgb_stride, tmp_rgb, width);
  561|   110k|    } else {
  562|      0|      WebPAccumulateRGBA(r_ptr, g_ptr, b_ptr, a_ptr, rgb_stride, tmp_rgb,
  563|      0|                         width);
  564|      0|    }
  565|       |    // Convert to U/V
  566|   110k|    WebPConvertRGBA32ToUV(tmp_rgb, dst_u, dst_v, uv_width);
  567|   110k|    dst_u += uv_stride;
  568|   110k|    dst_v += uv_stride;
  569|   110k|    r_ptr += 2 * rgb_stride;
  570|   110k|    b_ptr += 2 * rgb_stride;
  571|   110k|    g_ptr += 2 * rgb_stride;
  572|   110k|    if (has_alpha) a_ptr += 2 * rgb_stride;
  ------------------
  |  Branch (572:9): [True: 0, False: 110k]
  ------------------
  573|   110k|  }
  574|  13.9k|}
yuv.c:ImportYUVAFromRGBALastLine_C:
  581|    103|    uint8_t* dst_v, uint8_t* dst_a) {
  582|    103|  const int is_rgb = (r_ptr < b_ptr);  // otherwise it's bgr
  583|    103|  const int uv_width = (width + 1) >> 1;
  584|    103|  int row_has_alpha = has_alpha && dst_a != NULL;
  ------------------
  |  Branch (584:23): [True: 0, False: 103]
  |  Branch (584:36): [True: 0, False: 0]
  ------------------
  585|       |
  586|    103|  if (is_rgb) {
  ------------------
  |  Branch (586:7): [True: 0, False: 103]
  ------------------
  587|      0|    WebPConvertRGBToY(r_ptr, dst_y, width, step);
  588|    103|  } else {
  589|    103|    WebPConvertBGRToY(b_ptr, dst_y, width, step);
  590|    103|  }
  591|    103|  if (row_has_alpha) {
  ------------------
  |  Branch (591:7): [True: 0, False: 103]
  ------------------
  592|      0|    row_has_alpha &= !WebPExtractAlpha(a_ptr, 0, width, 1, dst_a, 0);
  593|    103|  } else if (dst_a != NULL) {
  ------------------
  |  Branch (593:14): [True: 0, False: 103]
  ------------------
  594|      0|    memset(dst_a, 0xff, width);
  595|      0|  }
  596|       |
  597|       |  // Collect averaged R/G/B(/A)
  598|    103|  if (!row_has_alpha) {
  ------------------
  |  Branch (598:7): [True: 103, False: 0]
  ------------------
  599|       |    // Collect averaged R/G/B
  600|    103|    WebPAccumulateRGB(r_ptr, g_ptr, b_ptr, step, /*rgb_stride=*/0, tmp_rgb,
  601|    103|                      width);
  602|    103|  } else {
  603|      0|    WebPAccumulateRGBA(r_ptr, g_ptr, b_ptr, a_ptr, /*rgb_stride=*/0, tmp_rgb,
  604|      0|                       width);
  605|      0|  }
  606|    103|  WebPConvertRGBA32ToUV(tmp_rgb, dst_u, dst_v, uv_width);
  607|    103|}

yuv.c:VP8RGBToU:
  225|   274k|static WEBP_INLINE int VP8RGBToU(int r, int g, int b, int rounding) {
  226|   274k|  const int u = -9719 * r - 19081 * g + 28800 * b;
  227|   274k|  return VP8ClipUV(u, rounding);
  228|   274k|}
yuv.c:VP8ClipUV:
  215|   548k|static WEBP_INLINE int VP8ClipUV(int uv, int rounding) {
  216|   548k|  uv = (uv + rounding + (128 << (YUV_FIX + 2))) >> (YUV_FIX + 2);
  217|   548k|  return ((uv & ~0xff) == 0) ? uv : (uv < 0) ? 0 : 255;
  ------------------
  |  Branch (217:10): [True: 548k, False: 0]
  |  Branch (217:37): [True: 0, False: 0]
  ------------------
  218|   548k|}
yuv.c:VP8RGBToV:
  230|   274k|static WEBP_INLINE int VP8RGBToV(int r, int g, int b, int rounding) {
  231|   274k|  const int v = +28800 * r - 24116 * g - 4684 * b;
  232|   274k|  return VP8ClipUV(v, rounding);
  233|   274k|}
upsampling_sse41.c:VP8YuvToRgb:
   92|  90.1k|static WEBP_INLINE void VP8YuvToRgb(int y, int u, int v, uint8_t* const rgb) {
   93|  90.1k|  rgb[0] = VP8YUVToR(y, v);
   94|  90.1k|  rgb[1] = VP8YUVToG(y, u, v);
   95|  90.1k|  rgb[2] = VP8YUVToB(y, u);
   96|  90.1k|}
upsampling_sse41.c:VP8YUVToR:
   80|   206k|static WEBP_INLINE int VP8YUVToR(int y, int v) {
   81|   206k|  return VP8Clip8(MultHi(y, 19077) + MultHi(v, 26149) - 14234);
   82|   206k|}
upsampling_sse41.c:VP8Clip8:
   76|   620k|static WEBP_INLINE int VP8Clip8(int v) {
   77|   620k|  return ((v & ~YUV_MASK2) == 0) ? (v >> YUV_FIX2) : (v < 0) ? 0 : 255;
  ------------------
  |  Branch (77:10): [True: 533k, False: 87.4k]
  |  Branch (77:54): [True: 43.4k, False: 43.9k]
  ------------------
   78|   620k|}
upsampling_sse41.c:MultHi:
   72|  1.44M|static WEBP_INLINE int MultHi(int v, int coeff) {  // _mm_mulhi_epu16 emulation
   73|  1.44M|  return (v * coeff) >> 8;
   74|  1.44M|}
upsampling_sse41.c:VP8YUVToG:
   84|   206k|static WEBP_INLINE int VP8YUVToG(int y, int u, int v) {
   85|   206k|  return VP8Clip8(MultHi(y, 19077) - MultHi(u, 6419) - MultHi(v, 13320) + 8708);
   86|   206k|}
upsampling_sse41.c:VP8YUVToB:
   88|   206k|static WEBP_INLINE int VP8YUVToB(int y, int u) {
   89|   206k|  return VP8Clip8(MultHi(y, 19077) + MultHi(u, 33050) - 17685);
   90|   206k|}
upsampling_sse41.c:VP8YuvToBgr:
   98|   116k|static WEBP_INLINE void VP8YuvToBgr(int y, int u, int v, uint8_t* const bgr) {
   99|   116k|  bgr[0] = VP8YUVToB(y, u);
  100|   116k|  bgr[1] = VP8YUVToG(y, u, v);
  101|   116k|  bgr[2] = VP8YUVToR(y, v);
  102|   116k|}
yuv_sse41.c:VP8RGBToY:
  220|  1.02M|static WEBP_INLINE int VP8RGBToY(int r, int g, int b, int rounding) {
  221|  1.02M|  const int luma = 16839 * r + 33059 * g + 6420 * b;
  222|  1.02M|  return (luma + rounding + (16 << YUV_FIX)) >> YUV_FIX;  // no need to clip
  223|  1.02M|}
upsampling_sse2.c:VP8YuvToRgba:
  152|  91.1k|                                     uint8_t* const rgba) {
  153|  91.1k|  VP8YuvToRgb(y, u, v, rgba);
  154|  91.1k|  rgba[3] = 0xff;
  155|  91.1k|}
upsampling_sse2.c:VP8YuvToRgb:
   92|   211k|static WEBP_INLINE void VP8YuvToRgb(int y, int u, int v, uint8_t* const rgb) {
   93|   211k|  rgb[0] = VP8YUVToR(y, v);
   94|   211k|  rgb[1] = VP8YUVToG(y, u, v);
   95|   211k|  rgb[2] = VP8YUVToB(y, u);
   96|   211k|}
upsampling_sse2.c:VP8YUVToR:
   80|   274k|static WEBP_INLINE int VP8YUVToR(int y, int v) {
   81|   274k|  return VP8Clip8(MultHi(y, 19077) + MultHi(v, 26149) - 14234);
   82|   274k|}
upsampling_sse2.c:VP8Clip8:
   76|   824k|static WEBP_INLINE int VP8Clip8(int v) {
   77|   824k|  return ((v & ~YUV_MASK2) == 0) ? (v >> YUV_FIX2) : (v < 0) ? 0 : 255;
  ------------------
  |  Branch (77:10): [True: 738k, False: 85.9k]
  |  Branch (77:54): [True: 37.0k, False: 48.9k]
  ------------------
   78|   824k|}
upsampling_sse2.c:MultHi:
   72|  1.92M|static WEBP_INLINE int MultHi(int v, int coeff) {  // _mm_mulhi_epu16 emulation
   73|  1.92M|  return (v * coeff) >> 8;
   74|  1.92M|}
upsampling_sse2.c:VP8YUVToG:
   84|   274k|static WEBP_INLINE int VP8YUVToG(int y, int u, int v) {
   85|   274k|  return VP8Clip8(MultHi(y, 19077) - MultHi(u, 6419) - MultHi(v, 13320) + 8708);
   86|   274k|}
upsampling_sse2.c:VP8YUVToB:
   88|   274k|static WEBP_INLINE int VP8YUVToB(int y, int u) {
   89|   274k|  return VP8Clip8(MultHi(y, 19077) + MultHi(u, 33050) - 17685);
   90|   274k|}
upsampling_sse2.c:VP8YuvToBgra:
  146|  63.4k|                                     uint8_t* const bgra) {
  147|  63.4k|  VP8YuvToBgr(y, u, v, bgra);
  148|  63.4k|  bgra[3] = 0xff;
  149|  63.4k|}
upsampling_sse2.c:VP8YuvToBgr:
   98|  63.4k|static WEBP_INLINE void VP8YuvToBgr(int y, int u, int v, uint8_t* const bgr) {
   99|  63.4k|  bgr[0] = VP8YUVToB(y, u);
  100|  63.4k|  bgr[1] = VP8YUVToG(y, u, v);
  101|  63.4k|  bgr[2] = VP8YUVToR(y, v);
  102|  63.4k|}
upsampling_sse2.c:VP8YuvToArgb:
  140|   120k|                                     uint8_t* const argb) {
  141|   120k|  argb[0] = 0xff;
  142|   120k|  VP8YuvToRgb(y, u, v, argb + 1);
  143|   120k|}

VP8YuvToRgba32_SSE2:
  198|  79.6k|                         uint8_t* WEBP_RESTRICT dst) {
  199|  79.6k|  const __m128i kAlpha = _mm_set1_epi16(255);
  200|  79.6k|  int n;
  201|   398k|  for (n = 0; n < 32; n += 8, dst += 32) {
  ------------------
  |  Branch (201:15): [True: 318k, False: 79.6k]
  ------------------
  202|   318k|    __m128i R, G, B;
  203|   318k|    YUV444ToRGB_SSE2(y + n, u + n, v + n, &R, &G, &B);
  204|   318k|    PackAndStore4_SSE2(&R, &G, &B, &kAlpha, dst);
  205|   318k|  }
  206|  79.6k|}
VP8YuvToBgra32_SSE2:
  211|  67.2k|                         uint8_t* WEBP_RESTRICT dst) {
  212|  67.2k|  const __m128i kAlpha = _mm_set1_epi16(255);
  213|  67.2k|  int n;
  214|   336k|  for (n = 0; n < 32; n += 8, dst += 32) {
  ------------------
  |  Branch (214:15): [True: 269k, False: 67.2k]
  ------------------
  215|   269k|    __m128i R, G, B;
  216|   269k|    YUV444ToRGB_SSE2(y + n, u + n, v + n, &R, &G, &B);
  217|   269k|    PackAndStore4_SSE2(&B, &G, &R, &kAlpha, dst);
  218|   269k|  }
  219|  67.2k|}
VP8YuvToArgb32_SSE2:
  224|   118k|                         uint8_t* WEBP_RESTRICT dst) {
  225|   118k|  const __m128i kAlpha = _mm_set1_epi16(255);
  226|   118k|  int n;
  227|   594k|  for (n = 0; n < 32; n += 8, dst += 32) {
  ------------------
  |  Branch (227:15): [True: 475k, False: 118k]
  ------------------
  228|   475k|    __m128i R, G, B;
  229|   475k|    YUV444ToRGB_SSE2(y + n, u + n, v + n, &R, &G, &B);
  230|   475k|    PackAndStore4_SSE2(&kAlpha, &R, &G, &B, dst);
  231|   475k|  }
  232|   118k|}
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.06M|                             __m128i* const B) {
   91|  1.06M|  const __m128i Y0 = Load_HI_16_SSE2(y), U0 = Load_HI_16_SSE2(u),
   92|  1.06M|                V0 = Load_HI_16_SSE2(v);
   93|  1.06M|  ConvertYUV444ToRGB_SSE2(&Y0, &U0, &V0, R, G, B);
   94|  1.06M|}
yuv_sse2.c:Load_HI_16_SSE2:
   72|  3.19M|static WEBP_INLINE __m128i Load_HI_16_SSE2(const uint8_t* src) {
   73|  3.19M|  const __m128i zero = _mm_setzero_si128();
   74|  3.19M|  return _mm_unpacklo_epi8(zero, _mm_loadl_epi64((const __m128i*)src));
   75|  3.19M|}
yuv_sse2.c:ConvertYUV444ToRGB_SSE2:
   37|  1.06M|                                    __m128i* const G, __m128i* const B) {
   38|  1.06M|  const __m128i k19077 = _mm_set1_epi16(19077);
   39|  1.06M|  const __m128i k26149 = _mm_set1_epi16(26149);
   40|  1.06M|  const __m128i k14234 = _mm_set1_epi16(14234);
   41|       |  // 33050 doesn't fit in a signed short: only use this with unsigned arithmetic
   42|  1.06M|  const __m128i k33050 = _mm_set1_epi16((short)33050);
   43|  1.06M|  const __m128i k17685 = _mm_set1_epi16(17685);
   44|  1.06M|  const __m128i k6419 = _mm_set1_epi16(6419);
   45|  1.06M|  const __m128i k13320 = _mm_set1_epi16(13320);
   46|  1.06M|  const __m128i k8708 = _mm_set1_epi16(8708);
   47|       |
   48|  1.06M|  const __m128i Y1 = _mm_mulhi_epu16(*Y0, k19077);
   49|       |
   50|  1.06M|  const __m128i R0 = _mm_mulhi_epu16(*V0, k26149);
   51|  1.06M|  const __m128i R1 = _mm_sub_epi16(Y1, k14234);
   52|  1.06M|  const __m128i R2 = _mm_add_epi16(R1, R0);
   53|       |
   54|  1.06M|  const __m128i G0 = _mm_mulhi_epu16(*U0, k6419);
   55|  1.06M|  const __m128i G1 = _mm_mulhi_epu16(*V0, k13320);
   56|  1.06M|  const __m128i G2 = _mm_add_epi16(Y1, k8708);
   57|  1.06M|  const __m128i G3 = _mm_add_epi16(G0, G1);
   58|  1.06M|  const __m128i G4 = _mm_sub_epi16(G2, G3);
   59|       |
   60|       |  // be careful with the saturated *unsigned* arithmetic here!
   61|  1.06M|  const __m128i B0 = _mm_mulhi_epu16(*U0, k33050);
   62|  1.06M|  const __m128i B1 = _mm_adds_epu16(B0, Y1);
   63|  1.06M|  const __m128i B2 = _mm_subs_epu16(B1, k17685);
   64|       |
   65|       |  // use logical shift for B2, which can be larger than 32767
   66|  1.06M|  *R = _mm_srai_epi16(R2, 6);  // range: [-14234, 30815]
   67|  1.06M|  *G = _mm_srai_epi16(G4, 6);  // range: [-10953, 27710]
   68|  1.06M|  *B = _mm_srli_epi16(B2, 6);  // range: [0, 34238]
   69|  1.06M|}
yuv_sse2.c:PackAndStore4_SSE2:
  112|  1.06M|                                           uint8_t* WEBP_RESTRICT const dst) {
  113|  1.06M|  const __m128i rb = _mm_packus_epi16(*R, *B);
  114|  1.06M|  const __m128i ga = _mm_packus_epi16(*G, *A);
  115|  1.06M|  const __m128i rg = _mm_unpacklo_epi8(rb, ga);
  116|  1.06M|  const __m128i ba = _mm_unpackhi_epi8(rb, ga);
  117|  1.06M|  const __m128i RGBA_lo = _mm_unpacklo_epi16(rg, ba);
  118|  1.06M|  const __m128i RGBA_hi = _mm_unpackhi_epi16(rg, ba);
  119|  1.06M|  _mm_storeu_si128((__m128i*)(dst + 0), RGBA_lo);
  120|  1.06M|  _mm_storeu_si128((__m128i*)(dst + 16), RGBA_hi);
  121|  1.06M|}

VP8YuvToRgb32_SSE41:
  140|  83.7k|                         uint8_t* WEBP_RESTRICT dst) {
  141|  83.7k|  __m128i R0, R1, R2, R3, G0, G1, G2, G3, B0, B1, B2, B3;
  142|  83.7k|  __m128i rgb0, rgb1, rgb2, rgb3, rgb4, rgb5;
  143|       |
  144|  83.7k|  YUV444ToRGB_SSE41(y + 0, u + 0, v + 0, &R0, &G0, &B0);
  145|  83.7k|  YUV444ToRGB_SSE41(y + 8, u + 8, v + 8, &R1, &G1, &B1);
  146|  83.7k|  YUV444ToRGB_SSE41(y + 16, u + 16, v + 16, &R2, &G2, &B2);
  147|  83.7k|  YUV444ToRGB_SSE41(y + 24, u + 24, v + 24, &R3, &G3, &B3);
  148|       |
  149|       |  // Cast to 8b and store as RRRRGGGGBBBB.
  150|  83.7k|  rgb0 = _mm_packus_epi16(R0, R1);
  151|  83.7k|  rgb1 = _mm_packus_epi16(R2, R3);
  152|  83.7k|  rgb2 = _mm_packus_epi16(G0, G1);
  153|  83.7k|  rgb3 = _mm_packus_epi16(G2, G3);
  154|  83.7k|  rgb4 = _mm_packus_epi16(B0, B1);
  155|  83.7k|  rgb5 = _mm_packus_epi16(B2, B3);
  156|       |
  157|       |  // Pack as RGBRGBRGBRGB.
  158|  83.7k|  PlanarTo24b_SSE41(&rgb0, &rgb1, &rgb2, &rgb3, &rgb4, &rgb5, dst);
  159|  83.7k|}
VP8YuvToBgr32_SSE41:
  164|   123k|                         uint8_t* WEBP_RESTRICT dst) {
  165|   123k|  __m128i R0, R1, R2, R3, G0, G1, G2, G3, B0, B1, B2, B3;
  166|   123k|  __m128i bgr0, bgr1, bgr2, bgr3, bgr4, bgr5;
  167|       |
  168|   123k|  YUV444ToRGB_SSE41(y + 0, u + 0, v + 0, &R0, &G0, &B0);
  169|   123k|  YUV444ToRGB_SSE41(y + 8, u + 8, v + 8, &R1, &G1, &B1);
  170|   123k|  YUV444ToRGB_SSE41(y + 16, u + 16, v + 16, &R2, &G2, &B2);
  171|   123k|  YUV444ToRGB_SSE41(y + 24, u + 24, v + 24, &R3, &G3, &B3);
  172|       |
  173|       |  // Cast to 8b and store as BBBBGGGGRRRR.
  174|   123k|  bgr0 = _mm_packus_epi16(B0, B1);
  175|   123k|  bgr1 = _mm_packus_epi16(B2, B3);
  176|   123k|  bgr2 = _mm_packus_epi16(G0, G1);
  177|   123k|  bgr3 = _mm_packus_epi16(G2, G3);
  178|   123k|  bgr4 = _mm_packus_epi16(R0, R1);
  179|   123k|  bgr5 = _mm_packus_epi16(R2, R3);
  180|       |
  181|       |  // Pack as BGRBGRBGRBGR.
  182|   123k|  PlanarTo24b_SSE41(&bgr0, &bgr1, &bgr2, &bgr3, &bgr4, &bgr5, dst);
  183|   123k|}
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|   830k|                              __m128i* const B) {
   92|   830k|  const __m128i Y0 = Load_HI_16_SSE41(y), U0 = Load_HI_16_SSE41(u),
   93|   830k|                V0 = Load_HI_16_SSE41(v);
   94|   830k|  ConvertYUV444ToRGB_SSE41(&Y0, &U0, &V0, R, G, B);
   95|   830k|}
yuv_sse41.c:Load_HI_16_SSE41:
   73|  2.49M|static WEBP_INLINE __m128i Load_HI_16_SSE41(const uint8_t* src) {
   74|  2.49M|  const __m128i zero = _mm_setzero_si128();
   75|  2.49M|  return _mm_unpacklo_epi8(zero, _mm_loadl_epi64((const __m128i*)src));
   76|  2.49M|}
yuv_sse41.c:ConvertYUV444ToRGB_SSE41:
   38|   830k|                                     __m128i* const G, __m128i* const B) {
   39|   830k|  const __m128i k19077 = _mm_set1_epi16(19077);
   40|   830k|  const __m128i k26149 = _mm_set1_epi16(26149);
   41|   830k|  const __m128i k14234 = _mm_set1_epi16(14234);
   42|       |  // 33050 doesn't fit in a signed short: only use this with unsigned arithmetic
   43|   830k|  const __m128i k33050 = _mm_set1_epi16((short)33050);
   44|   830k|  const __m128i k17685 = _mm_set1_epi16(17685);
   45|   830k|  const __m128i k6419 = _mm_set1_epi16(6419);
   46|   830k|  const __m128i k13320 = _mm_set1_epi16(13320);
   47|   830k|  const __m128i k8708 = _mm_set1_epi16(8708);
   48|       |
   49|   830k|  const __m128i Y1 = _mm_mulhi_epu16(*Y0, k19077);
   50|       |
   51|   830k|  const __m128i R0 = _mm_mulhi_epu16(*V0, k26149);
   52|   830k|  const __m128i R1 = _mm_sub_epi16(Y1, k14234);
   53|   830k|  const __m128i R2 = _mm_add_epi16(R1, R0);
   54|       |
   55|   830k|  const __m128i G0 = _mm_mulhi_epu16(*U0, k6419);
   56|   830k|  const __m128i G1 = _mm_mulhi_epu16(*V0, k13320);
   57|   830k|  const __m128i G2 = _mm_add_epi16(Y1, k8708);
   58|   830k|  const __m128i G3 = _mm_add_epi16(G0, G1);
   59|   830k|  const __m128i G4 = _mm_sub_epi16(G2, G3);
   60|       |
   61|       |  // be careful with the saturated *unsigned* arithmetic here!
   62|   830k|  const __m128i B0 = _mm_mulhi_epu16(*U0, k33050);
   63|   830k|  const __m128i B1 = _mm_adds_epu16(B0, Y1);
   64|   830k|  const __m128i B2 = _mm_subs_epu16(B1, k17685);
   65|       |
   66|       |  // use logical shift for B2, which can be larger than 32767
   67|   830k|  *R = _mm_srai_epi16(R2, 6);  // range: [-14234, 30815]
   68|   830k|  *G = _mm_srai_epi16(G4, 6);  // range: [-10953, 27710]
   69|   830k|  *B = _mm_srli_epi16(B2, 6);  // range: [0, 34238]
   70|   830k|}
yuv_sse41.c:PlanarTo24b_SSE41:
  114|   207k|    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|   207k|  VP8PlanarTo24b_SSE41(in0, in1, in2, in3, in4, in5);
  128|       |
  129|   207k|  _mm_storeu_si128((__m128i*)(rgb + 0), *in0);
  130|   207k|  _mm_storeu_si128((__m128i*)(rgb + 16), *in1);
  131|   207k|  _mm_storeu_si128((__m128i*)(rgb + 32), *in2);
  132|   207k|  _mm_storeu_si128((__m128i*)(rgb + 48), *in3);
  133|   207k|  _mm_storeu_si128((__m128i*)(rgb + 64), *in4);
  134|   207k|  _mm_storeu_si128((__m128i*)(rgb + 80), *in5);
  135|   207k|}
yuv_sse41.c:ConvertRGBToYImpl_SSE41:
  405|   423k|                                                __m128i* const Y) {
  406|   423k|  const __m128i kRG_y = MK_CST_16(16839, 33059 - 16384);
  ------------------
  |  |  401|   423k|#define MK_CST_16(A, B) _mm_set_epi16((B), (A), (B), (A), (B), (A), (B), (A))
  ------------------
  407|   423k|  const __m128i kGB_y = MK_CST_16(16384, 6420);
  ------------------
  |  |  401|   423k|#define MK_CST_16(A, B) _mm_set_epi16((B), (A), (B), (A), (B), (A), (B), (A))
  ------------------
  408|   423k|  const __m128i kHALF_Y = _mm_set1_epi32((16 << YUV_FIX) + YUV_HALF);
  409|       |
  410|   423k|  const __m128i RG_lo = _mm_unpacklo_epi16(*R, *G);
  411|   423k|  const __m128i RG_hi = _mm_unpackhi_epi16(*R, *G);
  412|   423k|  const __m128i GB_lo = _mm_unpacklo_epi16(*G, *B);
  413|   423k|  const __m128i GB_hi = _mm_unpackhi_epi16(*G, *B);
  414|   423k|  TRANSFORM(RG_lo, RG_hi, GB_lo, GB_hi, kRG_y, kGB_y, kHALF_Y, YUV_FIX, *Y);
  ------------------
  |  |  387|   423k|  do {                                                                   \
  |  |  388|   423k|    const __m128i V0_lo = _mm_madd_epi16(RG_LO, MULT_RG);                \
  |  |  389|   423k|    const __m128i V0_hi = _mm_madd_epi16(RG_HI, MULT_RG);                \
  |  |  390|   423k|    const __m128i V1_lo = _mm_madd_epi16(GB_LO, MULT_GB);                \
  |  |  391|   423k|    const __m128i V1_hi = _mm_madd_epi16(GB_HI, MULT_GB);                \
  |  |  392|   423k|    const __m128i V2_lo = _mm_add_epi32(V0_lo, V1_lo);                   \
  |  |  393|   423k|    const __m128i V2_hi = _mm_add_epi32(V0_hi, V1_hi);                   \
  |  |  394|   423k|    const __m128i V3_lo = _mm_add_epi32(V2_lo, ROUNDER);                 \
  |  |  395|   423k|    const __m128i V3_hi = _mm_add_epi32(V2_hi, ROUNDER);                 \
  |  |  396|   423k|    const __m128i V5_lo = _mm_srai_epi32(V3_lo, DESCALE_FIX);            \
  |  |  397|   423k|    const __m128i V5_hi = _mm_srai_epi32(V3_hi, DESCALE_FIX);            \
  |  |  398|   423k|    (OUT) = _mm_packs_epi32(V5_lo, V5_hi);                               \
  |  |  399|   423k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (399:12): [Folded, False: 423k]
  |  |  ------------------
  ------------------
  415|   423k|}
yuv_sse41.c:ConvertRGBToUV_SSE41:
  421|   120k|                                             __m128i* const V) {
  422|   120k|  const __m128i kRG_u = MK_CST_16(-9719, -19081);
  ------------------
  |  |  401|   120k|#define MK_CST_16(A, B) _mm_set_epi16((B), (A), (B), (A), (B), (A), (B), (A))
  ------------------
  423|   120k|  const __m128i kGB_u = MK_CST_16(0, 28800);
  ------------------
  |  |  401|   120k|#define MK_CST_16(A, B) _mm_set_epi16((B), (A), (B), (A), (B), (A), (B), (A))
  ------------------
  424|   120k|  const __m128i kRG_v = MK_CST_16(28800, 0);
  ------------------
  |  |  401|   120k|#define MK_CST_16(A, B) _mm_set_epi16((B), (A), (B), (A), (B), (A), (B), (A))
  ------------------
  425|   120k|  const __m128i kGB_v = MK_CST_16(-24116, -4684);
  ------------------
  |  |  401|   120k|#define MK_CST_16(A, B) _mm_set_epi16((B), (A), (B), (A), (B), (A), (B), (A))
  ------------------
  426|   120k|  const __m128i kHALF_UV = _mm_set1_epi32(((128 << YUV_FIX) + YUV_HALF) << 2);
  427|       |
  428|   120k|  const __m128i RG_lo = _mm_unpacklo_epi16(*R, *G);
  429|   120k|  const __m128i RG_hi = _mm_unpackhi_epi16(*R, *G);
  430|   120k|  const __m128i GB_lo = _mm_unpacklo_epi16(*G, *B);
  431|   120k|  const __m128i GB_hi = _mm_unpackhi_epi16(*G, *B);
  432|   120k|  TRANSFORM(RG_lo, RG_hi, GB_lo, GB_hi, kRG_u, kGB_u, kHALF_UV, YUV_FIX + 2,
  ------------------
  |  |  387|   120k|  do {                                                                   \
  |  |  388|   120k|    const __m128i V0_lo = _mm_madd_epi16(RG_LO, MULT_RG);                \
  |  |  389|   120k|    const __m128i V0_hi = _mm_madd_epi16(RG_HI, MULT_RG);                \
  |  |  390|   120k|    const __m128i V1_lo = _mm_madd_epi16(GB_LO, MULT_GB);                \
  |  |  391|   120k|    const __m128i V1_hi = _mm_madd_epi16(GB_HI, MULT_GB);                \
  |  |  392|   120k|    const __m128i V2_lo = _mm_add_epi32(V0_lo, V1_lo);                   \
  |  |  393|   120k|    const __m128i V2_hi = _mm_add_epi32(V0_hi, V1_hi);                   \
  |  |  394|   120k|    const __m128i V3_lo = _mm_add_epi32(V2_lo, ROUNDER);                 \
  |  |  395|   120k|    const __m128i V3_hi = _mm_add_epi32(V2_hi, ROUNDER);                 \
  |  |  396|   120k|    const __m128i V5_lo = _mm_srai_epi32(V3_lo, DESCALE_FIX);            \
  |  |  397|   120k|    const __m128i V5_hi = _mm_srai_epi32(V3_hi, DESCALE_FIX);            \
  |  |  398|   120k|    (OUT) = _mm_packs_epi32(V5_lo, V5_hi);                               \
  |  |  399|   120k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (399:12): [Folded, False: 120k]
  |  |  ------------------
  ------------------
  433|   120k|            *U);
  434|   120k|  TRANSFORM(RG_lo, RG_hi, GB_lo, GB_hi, kRG_v, kGB_v, kHALF_UV, YUV_FIX + 2,
  ------------------
  |  |  387|   120k|  do {                                                                   \
  |  |  388|   120k|    const __m128i V0_lo = _mm_madd_epi16(RG_LO, MULT_RG);                \
  |  |  389|   120k|    const __m128i V0_hi = _mm_madd_epi16(RG_HI, MULT_RG);                \
  |  |  390|   120k|    const __m128i V1_lo = _mm_madd_epi16(GB_LO, MULT_GB);                \
  |  |  391|   120k|    const __m128i V1_hi = _mm_madd_epi16(GB_HI, MULT_GB);                \
  |  |  392|   120k|    const __m128i V2_lo = _mm_add_epi32(V0_lo, V1_lo);                   \
  |  |  393|   120k|    const __m128i V2_hi = _mm_add_epi32(V0_hi, V1_hi);                   \
  |  |  394|   120k|    const __m128i V3_lo = _mm_add_epi32(V2_lo, ROUNDER);                 \
  |  |  395|   120k|    const __m128i V3_hi = _mm_add_epi32(V2_hi, ROUNDER);                 \
  |  |  396|   120k|    const __m128i V5_lo = _mm_srai_epi32(V3_lo, DESCALE_FIX);            \
  |  |  397|   120k|    const __m128i V5_hi = _mm_srai_epi32(V3_hi, DESCALE_FIX);            \
  |  |  398|   120k|    (OUT) = _mm_packs_epi32(V5_lo, V5_hi);                               \
  |  |  399|   120k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (399:12): [Folded, False: 120k]
  |  |  ------------------
  ------------------
  435|   120k|            *V);
  436|   120k|}
yuv_sse41.c:ConvertRGBToYHelper_SSE41:
  443|   105k|    uint8_t* WEBP_RESTRICT y) {
  444|   105k|  int j;
  445|       |
  446|   317k|  for (j = 0; j < 2; ++j, *i += 16) {
  ------------------
  |  Branch (446:15): [True: 211k, False: 105k]
  ------------------
  447|   211k|    const __m128i zero = _mm_setzero_si128();
  448|   211k|    __m128i r, g, b, Y0, Y1;
  449|       |
  450|       |    // Convert to 16-bit Y.
  451|   211k|    r = _mm_unpacklo_epi8(rgb_plane[(swap_rb ? 4 : 0) + j], zero);
  ------------------
  |  Branch (451:38): [True: 211k, False: 0]
  ------------------
  452|   211k|    g = _mm_unpacklo_epi8(rgb_plane[2 + j], zero);
  453|   211k|    b = _mm_unpacklo_epi8(rgb_plane[(swap_rb ? 0 : 4) + j], zero);
  ------------------
  |  Branch (453:38): [True: 211k, False: 0]
  ------------------
  454|   211k|    ConvertRGBToYImpl_SSE41(&r, &g, &b, &Y0);
  455|       |
  456|       |    // Convert to 16-bit Y.
  457|   211k|    r = _mm_unpackhi_epi8(rgb_plane[(swap_rb ? 4 : 0) + j], zero);
  ------------------
  |  Branch (457:38): [True: 211k, False: 0]
  ------------------
  458|   211k|    g = _mm_unpackhi_epi8(rgb_plane[2 + j], zero);
  459|   211k|    b = _mm_unpackhi_epi8(rgb_plane[(swap_rb ? 0 : 4) + j], zero);
  ------------------
  |  Branch (459:38): [True: 211k, False: 0]
  ------------------
  460|   211k|    ConvertRGBToYImpl_SSE41(&r, &g, &b, &Y1);
  461|       |
  462|       |    // Cast to 8-bit and store.
  463|   211k|    STORE_16(_mm_packus_epi16(Y0, Y1), y + *i);
  ------------------
  |  |  280|   211k|#define STORE_16(V, dst) _mm_storeu_si128((__m128i*)(dst), (V))
  ------------------
  464|   211k|  }
  465|   105k|}
yuv_sse41.c:RGBAPackedToRGBPlanar_SSE41:
  345|   105k|    const uint8_t* WEBP_RESTRICT const rgba, __m128i* const rgb /*in[6]*/) {
  346|   105k|  __m128i a0 = _mm_loadu_si128((const __m128i*)(rgba + 0));
  347|   105k|  __m128i a1 = _mm_loadu_si128((const __m128i*)(rgba + 16));
  348|   105k|  __m128i a2 = _mm_loadu_si128((const __m128i*)(rgba + 32));
  349|   105k|  __m128i a3 = _mm_loadu_si128((const __m128i*)(rgba + 48));
  350|   105k|  __m128i a4 = _mm_loadu_si128((const __m128i*)(rgba + 64));
  351|   105k|  __m128i a5 = _mm_loadu_si128((const __m128i*)(rgba + 80));
  352|   105k|  __m128i a6 = _mm_loadu_si128((const __m128i*)(rgba + 96));
  353|   105k|  __m128i a7 = _mm_loadu_si128((const __m128i*)(rgba + 112));
  354|   105k|  VP8L32bToPlanar_SSE41(&a0, &a1, &a2, &a3);
  355|   105k|  rgb[0] = a3;
  356|   105k|  rgb[2] = a2;
  357|   105k|  rgb[4] = a1;
  358|   105k|  VP8L32bToPlanar_SSE41(&a4, &a5, &a6, &a7);
  359|   105k|  rgb[1] = a7;
  360|   105k|  rgb[3] = a6;
  361|   105k|  rgb[5] = a5;
  362|   105k|}
yuv_sse41.c:ConvertBGRToY_SSE41:
  489|   220k|                                uint8_t* WEBP_RESTRICT y, int width, int step) {
  490|   220k|  const int max_width = width & ~31;
  491|   220k|  int i;
  492|   220k|  __m128i bgr_plane[6];
  493|   220k|  if (step == 3) {
  ------------------
  |  Branch (493:7): [True: 0, False: 220k]
  ------------------
  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|   220k|  } else {
  499|   326k|    for (i = 0; i < max_width; bgr += 4 * 16 * 2) {
  ------------------
  |  Branch (499:17): [True: 105k, False: 220k]
  ------------------
  500|   105k|      RGBAPackedToRGBPlanar_SSE41(bgr, bgr_plane);
  501|   105k|      ConvertRGBToYHelper_SSE41(bgr_plane, /*swap_rb=*/1, &i, y);
  502|   105k|    }
  503|   220k|  }
  504|  1.24M|  for (; i < width; ++i, bgr += step) {  // left-over
  ------------------
  |  Branch (504:10): [True: 1.02M, False: 220k]
  ------------------
  505|  1.02M|    y[i] = VP8RGBToY(bgr[2], bgr[1], bgr[0], YUV_HALF);
  506|  1.02M|  }
  507|   220k|}
yuv_sse41.c:ConvertRGBA32ToUV_SSE41:
  608|   110k|                                    uint8_t* WEBP_RESTRICT v, int width) {
  609|   110k|  const int max_width = width & ~15;
  610|   110k|  const uint16_t* const last_rgb = rgb + 4 * max_width;
  611|   170k|  while (rgb < last_rgb) {
  ------------------
  |  Branch (611:10): [True: 60.2k, False: 110k]
  ------------------
  612|  60.2k|    __m128i r, g, b, U0, V0, U1, V1;
  613|  60.2k|    RGBA32PackedToPlanar_16b_SSE41(rgb + 0, &r, &g, &b);
  614|  60.2k|    ConvertRGBToUV_SSE41(&r, &g, &b, &U0, &V0);
  615|  60.2k|    RGBA32PackedToPlanar_16b_SSE41(rgb + 32, &r, &g, &b);
  616|  60.2k|    ConvertRGBToUV_SSE41(&r, &g, &b, &U1, &V1);
  617|  60.2k|    STORE_16(_mm_packus_epi16(U0, U1), u);
  ------------------
  |  |  280|  60.2k|#define STORE_16(V, dst) _mm_storeu_si128((__m128i*)(dst), (V))
  ------------------
  618|  60.2k|    STORE_16(_mm_packus_epi16(V0, V1), v);
  ------------------
  |  |  280|  60.2k|#define STORE_16(V, dst) _mm_storeu_si128((__m128i*)(dst), (V))
  ------------------
  619|  60.2k|    u += 16;
  620|  60.2k|    v += 16;
  621|  60.2k|    rgb += 2 * 32;
  622|  60.2k|  }
  623|   110k|  if (max_width < width) {  // left-over
  ------------------
  |  Branch (623:7): [True: 108k, False: 2.26k]
  ------------------
  624|   108k|    WebPConvertRGBA32ToUV_C(rgb, u, v, width - max_width);
  625|   108k|  }
  626|   110k|}
yuv_sse41.c:RGBA32PackedToPlanar_16b_SSE41:
  577|   120k|    __m128i* const g, __m128i* const b) {
  578|   120k|  const __m128i in0 = LOAD_16(rgbx + 0);   // r0 | g0 | b0 |x| r1 | g1 | b1 |x
  ------------------
  |  |  278|   120k|#define LOAD_16(src) _mm_loadu_si128((const __m128i*)(src))
  ------------------
  579|   120k|  const __m128i in1 = LOAD_16(rgbx + 8);   // r2 | g2 | b2 |x| r3 | g3 | b3 |x
  ------------------
  |  |  278|   120k|#define LOAD_16(src) _mm_loadu_si128((const __m128i*)(src))
  ------------------
  580|   120k|  const __m128i in2 = LOAD_16(rgbx + 16);  // r4 | ...
  ------------------
  |  |  278|   120k|#define LOAD_16(src) _mm_loadu_si128((const __m128i*)(src))
  ------------------
  581|   120k|  const __m128i in3 = LOAD_16(rgbx + 24);  // r6 | ...
  ------------------
  |  |  278|   120k|#define LOAD_16(src) _mm_loadu_si128((const __m128i*)(src))
  ------------------
  582|       |  // aarrggbb as 16-bit.
  583|   120k|  const __m128i shuff0 =
  584|   120k|      _mm_set_epi8(-1, -1, -1, -1, 13, 12, 5, 4, 11, 10, 3, 2, 9, 8, 1, 0);
  585|   120k|  const __m128i shuff1 =
  586|   120k|      _mm_set_epi8(13, 12, 5, 4, -1, -1, -1, -1, 11, 10, 3, 2, 9, 8, 1, 0);
  587|   120k|  const __m128i A0 = _mm_shuffle_epi8(in0, shuff0);
  588|   120k|  const __m128i A1 = _mm_shuffle_epi8(in1, shuff1);
  589|   120k|  const __m128i A2 = _mm_shuffle_epi8(in2, shuff0);
  590|   120k|  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|   120k|  const __m128i B0 = _mm_unpacklo_epi32(A0, A1);
  597|   120k|  const __m128i B1 = _mm_or_si128(A0, A1);
  598|   120k|  const __m128i B2 = _mm_unpacklo_epi32(A2, A3);
  599|   120k|  const __m128i B3 = _mm_or_si128(A2, A3);
  600|       |  // Gather the channels.
  601|   120k|  *r = _mm_unpacklo_epi64(B0, B2);
  602|   120k|  *g = _mm_unpackhi_epi64(B0, B2);
  603|   120k|  *b = _mm_unpackhi_epi64(B1, B3);
  604|   120k|}

vp8_dec.c:VP8LoadNewBytes:
   64|   557k|    VP8BitReader* WEBP_RESTRICT const br) {
   65|   557k|  assert(br != NULL && br->buf != NULL);
   66|       |  // Read 'BITS' bits at a time if possible.
   67|   557k|  if (br->buf < br->buf_max) {
  ------------------
  |  Branch (67:7): [True: 63.9k, False: 494k]
  ------------------
   68|       |    // convert memory type to register type (with some zero'ing!)
   69|  63.9k|    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|  63.9k|    lbit_t in_bits;
   85|  63.9k|    WEBP_UNSAFE_MEMCPY(&in_bits, br->buf, sizeof(in_bits));
  ------------------
  |  |  174|  63.9k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
   86|  63.9k|#endif
   87|  63.9k|    br->buf += BITS >> 3;
  ------------------
  |  |   70|  63.9k|#define BITS 56
  ------------------
   88|  63.9k|    WEBP_SELF_ASSIGN(br->buf_end);
  ------------------
  |  |  186|  63.9k|#define WEBP_SELF_ASSIGN(x) x = x
  ------------------
   89|  63.9k|#if !defined(WORDS_BIGENDIAN)
   90|  63.9k|#if (BITS > 32)
   91|  63.9k|    bits = BSwap64(in_bits);
   92|  63.9k|    bits >>= 64 - BITS;
  ------------------
  |  |   70|  63.9k|#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|  63.9k|    br->value = bits | (br->value << BITS);
  ------------------
  |  |   70|  63.9k|#define BITS 56
  ------------------
  106|  63.9k|    br->bits += BITS;
  ------------------
  |  |   70|  63.9k|#define BITS 56
  ------------------
  107|   494k|  } else {
  108|   494k|    VP8LoadFinalBytes(br);  // no need to be inlined
  109|   494k|  }
  110|   557k|}
vp8_dec.c:VP8GetBit:
  114|  2.84M|                                 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.84M|  range_t range = br->range;
  119|  2.84M|  if (br->bits < 0) {
  ------------------
  |  Branch (119:7): [True: 529k, False: 2.31M]
  ------------------
  120|   529k|    VP8LoadNewBytes(br);
  121|   529k|  }
  122|  2.84M|  {
  123|  2.84M|    const int pos = br->bits;
  124|  2.84M|    const range_t split = (range * prob) >> 8;
  125|  2.84M|    const range_t value = (range_t)(br->value >> pos);
  126|  2.84M|    const int bit = (value > split);
  127|  2.84M|    if (bit) {
  ------------------
  |  Branch (127:9): [True: 1.95M, False: 893k]
  ------------------
  128|  1.95M|      range -= split;
  129|  1.95M|      br->value -= (bit_t)(split + 1) << pos;
  130|  1.95M|    } else {
  131|   893k|      range = split + 1;
  132|   893k|    }
  133|  2.84M|    {
  134|  2.84M|      const int shift = 7 ^ BitsLog2Floor(range);
  135|  2.84M|      range <<= shift;
  136|  2.84M|      br->bits -= shift;
  137|  2.84M|    }
  138|  2.84M|    br->range = range - 1;
  139|  2.84M|    BT_TRACK(br);
  140|  2.84M|    return bit;
  141|  2.84M|  }
  142|  2.84M|}
vp8_dec.c:VP8GetSigned:
  146|   241k|    VP8BitReader* WEBP_RESTRICT const br, int v, const char label[]) {
  147|   241k|  if (br->bits < 0) {
  ------------------
  |  Branch (147:7): [True: 28.6k, False: 212k]
  ------------------
  148|  28.6k|    VP8LoadNewBytes(br);
  149|  28.6k|  }
  150|   241k|  {
  151|   241k|    const int pos = br->bits;
  152|   241k|    const range_t split = br->range >> 1;
  153|   241k|    const range_t value = (range_t)(br->value >> pos);
  154|   241k|    const int32_t mask = (int32_t)(split - value) >> 31;  // -1 or 0
  155|   241k|    br->bits -= 1;
  156|   241k|    br->range += (range_t)mask;
  157|   241k|    br->range |= 1;
  158|   241k|    br->value -= (bit_t)((split + 1) & (uint32_t)mask) << pos;
  159|   241k|    BT_TRACK(br);
  160|   241k|    return (v ^ mask) - mask;
  161|   241k|  }
  162|   241k|}
bit_reader_utils.c:VP8LoadNewBytes:
   64|   362k|    VP8BitReader* WEBP_RESTRICT const br) {
   65|   362k|  assert(br != NULL && br->buf != NULL);
   66|       |  // Read 'BITS' bits at a time if possible.
   67|   362k|  if (br->buf < br->buf_max) {
  ------------------
  |  Branch (67:7): [True: 5.54k, False: 357k]
  ------------------
   68|       |    // convert memory type to register type (with some zero'ing!)
   69|  5.54k|    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.54k|    lbit_t in_bits;
   85|  5.54k|    WEBP_UNSAFE_MEMCPY(&in_bits, br->buf, sizeof(in_bits));
  ------------------
  |  |  174|  5.54k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
   86|  5.54k|#endif
   87|  5.54k|    br->buf += BITS >> 3;
  ------------------
  |  |   70|  5.54k|#define BITS 56
  ------------------
   88|  5.54k|    WEBP_SELF_ASSIGN(br->buf_end);
  ------------------
  |  |  186|  5.54k|#define WEBP_SELF_ASSIGN(x) x = x
  ------------------
   89|  5.54k|#if !defined(WORDS_BIGENDIAN)
   90|  5.54k|#if (BITS > 32)
   91|  5.54k|    bits = BSwap64(in_bits);
   92|  5.54k|    bits >>= 64 - BITS;
  ------------------
  |  |   70|  5.54k|#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.54k|    br->value = bits | (br->value << BITS);
  ------------------
  |  |   70|  5.54k|#define BITS 56
  ------------------
  106|  5.54k|    br->bits += BITS;
  ------------------
  |  |   70|  5.54k|#define BITS 56
  ------------------
  107|   357k|  } else {
  108|   357k|    VP8LoadFinalBytes(br);  // no need to be inlined
  109|   357k|  }
  110|   362k|}
bit_reader_utils.c:VP8GetBit:
  114|   549k|                                 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|   549k|  range_t range = br->range;
  119|   549k|  if (br->bits < 0) {
  ------------------
  |  Branch (119:7): [True: 356k, False: 192k]
  ------------------
  120|   356k|    VP8LoadNewBytes(br);
  121|   356k|  }
  122|   549k|  {
  123|   549k|    const int pos = br->bits;
  124|   549k|    const range_t split = (range * prob) >> 8;
  125|   549k|    const range_t value = (range_t)(br->value >> pos);
  126|   549k|    const int bit = (value > split);
  127|   549k|    if (bit) {
  ------------------
  |  Branch (127:9): [True: 455k, False: 93.4k]
  ------------------
  128|   455k|      range -= split;
  129|   455k|      br->value -= (bit_t)(split + 1) << pos;
  130|   455k|    } else {
  131|  93.4k|      range = split + 1;
  132|  93.4k|    }
  133|   549k|    {
  134|   549k|      const int shift = 7 ^ BitsLog2Floor(range);
  135|   549k|      range <<= shift;
  136|   549k|      br->bits -= shift;
  137|   549k|    }
  138|   549k|    br->range = range - 1;
  139|   549k|    BT_TRACK(br);
  140|   549k|    return bit;
  141|   549k|  }
  142|   549k|}
tree_dec.c:VP8GetBit:
  114|  5.26M|                                 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|  5.26M|  range_t range = br->range;
  119|  5.26M|  if (br->bits < 0) {
  ------------------
  |  Branch (119:7): [True: 502k, False: 4.76M]
  ------------------
  120|   502k|    VP8LoadNewBytes(br);
  121|   502k|  }
  122|  5.26M|  {
  123|  5.26M|    const int pos = br->bits;
  124|  5.26M|    const range_t split = (range * prob) >> 8;
  125|  5.26M|    const range_t value = (range_t)(br->value >> pos);
  126|  5.26M|    const int bit = (value > split);
  127|  5.26M|    if (bit) {
  ------------------
  |  Branch (127:9): [True: 521k, False: 4.74M]
  ------------------
  128|   521k|      range -= split;
  129|   521k|      br->value -= (bit_t)(split + 1) << pos;
  130|  4.74M|    } else {
  131|  4.74M|      range = split + 1;
  132|  4.74M|    }
  133|  5.26M|    {
  134|  5.26M|      const int shift = 7 ^ BitsLog2Floor(range);
  135|  5.26M|      range <<= shift;
  136|  5.26M|      br->bits -= shift;
  137|  5.26M|    }
  138|  5.26M|    br->range = range - 1;
  139|  5.26M|    BT_TRACK(br);
  140|  5.26M|    return bit;
  141|  5.26M|  }
  142|  5.26M|}
tree_dec.c:VP8LoadNewBytes:
   64|   502k|    VP8BitReader* WEBP_RESTRICT const br) {
   65|   502k|  assert(br != NULL && br->buf != NULL);
   66|       |  // Read 'BITS' bits at a time if possible.
   67|   502k|  if (br->buf < br->buf_max) {
  ------------------
  |  Branch (67:7): [True: 11.5k, False: 490k]
  ------------------
   68|       |    // convert memory type to register type (with some zero'ing!)
   69|  11.5k|    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|  11.5k|    lbit_t in_bits;
   85|  11.5k|    WEBP_UNSAFE_MEMCPY(&in_bits, br->buf, sizeof(in_bits));
  ------------------
  |  |  174|  11.5k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
   86|  11.5k|#endif
   87|  11.5k|    br->buf += BITS >> 3;
  ------------------
  |  |   70|  11.5k|#define BITS 56
  ------------------
   88|  11.5k|    WEBP_SELF_ASSIGN(br->buf_end);
  ------------------
  |  |  186|  11.5k|#define WEBP_SELF_ASSIGN(x) x = x
  ------------------
   89|  11.5k|#if !defined(WORDS_BIGENDIAN)
   90|  11.5k|#if (BITS > 32)
   91|  11.5k|    bits = BSwap64(in_bits);
   92|  11.5k|    bits >>= 64 - BITS;
  ------------------
  |  |   70|  11.5k|#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|  11.5k|    br->value = bits | (br->value << BITS);
  ------------------
  |  |   70|  11.5k|#define BITS 56
  ------------------
  106|  11.5k|    br->bits += BITS;
  ------------------
  |  |   70|  11.5k|#define BITS 56
  ------------------
  107|   490k|  } else {
  108|   490k|    VP8LoadFinalBytes(br);  // no need to be inlined
  109|   490k|  }
  110|   502k|}

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

vp8l_dec.c:VP8LFillBitWindow:
  198|  2.84M|static WEBP_INLINE void VP8LFillBitWindow(VP8LBitReader* const br) {
  199|  2.84M|  if (br->bit_pos >= VP8L_WBITS) VP8LDoFillBitWindow(br);
  ------------------
  |  |  147|  2.84M|#define VP8L_WBITS 32  // Minimum number of bytes ready after VP8LFillBitWindow.
  ------------------
  |  Branch (199:7): [True: 726k, False: 2.12M]
  ------------------
  200|  2.84M|}
vp8l_dec.c:VP8LPrefetchBits:
  176|  4.57M|static WEBP_INLINE uint32_t VP8LPrefetchBits(VP8LBitReader* const br) {
  177|  4.57M|  return (uint32_t)(br->val >> (br->bit_pos & (VP8L_LBITS - 1)));
  ------------------
  |  |  146|  4.57M|#define VP8L_LBITS 64  // Number of bits prefetched (= bit-size of vp8l_val_t).
  ------------------
  178|  4.57M|}
vp8l_dec.c:VP8LSetBitPos:
  191|  4.57M|static WEBP_INLINE void VP8LSetBitPos(VP8LBitReader* const br, int val) {
  192|  4.57M|  br->bit_pos = val;
  193|  4.57M|}
vp8l_dec.c:VP8LIsEndOfStream:
  182|  2.00M|static WEBP_INLINE int VP8LIsEndOfStream(const VP8LBitReader* const br) {
  183|  2.00M|  assert(br->pos <= br->len);
  184|  2.00M|  return br->eos || ((br->pos == br->len) && (br->bit_pos > VP8L_LBITS));
  ------------------
  |  |  146|   592k|#define VP8L_LBITS 64  // Number of bits prefetched (= bit-size of vp8l_val_t).
  ------------------
  |  Branch (184:10): [True: 234, False: 2.00M]
  |  Branch (184:22): [True: 592k, False: 1.41M]
  |  Branch (184:46): [True: 546, False: 592k]
  ------------------
  185|  2.00M|}
bit_reader_utils.c:VP8LIsEndOfStream:
  182|  4.54M|static WEBP_INLINE int VP8LIsEndOfStream(const VP8LBitReader* const br) {
  183|  4.54M|  assert(br->pos <= br->len);
  184|  4.54M|  return br->eos || ((br->pos == br->len) && (br->bit_pos > VP8L_LBITS));
  ------------------
  |  |  146|   574k|#define VP8L_LBITS 64  // Number of bits prefetched (= bit-size of vp8l_val_t).
  ------------------
  |  Branch (184:10): [True: 359, False: 4.54M]
  |  Branch (184:22): [True: 574k, False: 3.96M]
  |  Branch (184:46): [True: 750, False: 573k]
  ------------------
  185|  4.54M|}
bit_reader_utils.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|}

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

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

vp8_dec.c:BSwap64:
   78|  63.9k|static WEBP_INLINE uint64_t BSwap64(uint64_t x) {
   79|  63.9k|#if defined(HAVE_BUILTIN_BSWAP64)
   80|  63.9k|  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|  63.9k|}
lossless.c:BSwap32:
   56|  3.73M|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.73M|}
bit_reader_utils.c:BSwap64:
   78|  5.54k|static WEBP_INLINE uint64_t BSwap64(uint64_t x) {
   79|  5.54k|#if defined(HAVE_BUILTIN_BSWAP64)
   80|  5.54k|  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.54k|}
tree_dec.c:BSwap64:
   78|  11.5k|static WEBP_INLINE uint64_t BSwap64(uint64_t x) {
   79|  11.5k|#if defined(HAVE_BUILTIN_BSWAP64)
   80|  11.5k|  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|  11.5k|}

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

WebPGetWorkerInterface:
  305|  8.04k|const WebPWorkerInterface* WebPGetWorkerInterface(void) {
  306|  8.04k|  return &g_worker_interface;
  307|  8.04k|}
thread_utils.c:Init:
  204|  2.86k|static void Init(WebPWorker* const worker) {
  205|  2.86k|  WEBP_UNSAFE_MEMSET(worker, 0, sizeof(*worker));
  ------------------
  |  |  175|  2.86k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  206|  2.86k|  worker->status = NOT_OK;
  207|  2.86k|}
thread_utils.c:End:
  271|  5.17k|static void End(WebPWorker* const worker) {
  272|  5.17k|#ifdef WEBP_USE_THREAD
  273|  5.17k|  if (worker->impl != NULL) {
  ------------------
  |  Branch (273:7): [True: 0, False: 5.17k]
  ------------------
  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|  5.17k|}

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

webp_dec.c:GetLE32:
  107|    611|                                        data) {
  108|    611|  return GetLE16(data) | ((uint32_t)GetLE16(data + 2) << 16);
  109|    611|}
webp_dec.c:GetLE16:
   98|  1.24k|static WEBP_INLINE int GetLE16(const uint8_t* const WEBP_COUNTED_BY(2) data) {
   99|  1.24k|  return (int)(data[0] << 0) | (data[1] << 8);
  100|  1.24k|}
webp_dec.c:GetLE24:
  102|     20|static WEBP_INLINE int GetLE24(const uint8_t* const WEBP_COUNTED_BY(3) data) {
  103|     20|  return GetLE16(data) | (data[2] << 16);
  104|     20|}
utils.c:CheckSizeOverflow:
   47|  31.6k|static WEBP_INLINE int CheckSizeOverflow(uint64_t size) {
   48|  31.6k|  return size == (size_t)size;
   49|  31.6k|}
frame_dec.c:CheckSizeOverflow:
   47|  2.66k|static WEBP_INLINE int CheckSizeOverflow(uint64_t size) {
   48|  2.66k|  return size == (size_t)size;
   49|  2.66k|}
vp8_dec.c:BitsLog2Floor:
  136|  2.84M|static WEBP_INLINE int BitsLog2Floor(uint32_t n) {
  137|  2.84M|  return 31 ^ __builtin_clz(n);
  138|  2.84M|}
dec.c:WebPUint32ToMem:
   86|  20.8k|static WEBP_INLINE void WebPUint32ToMem(uint8_t* const ptr, uint32_t val) {
   87|  20.8k|  WEBP_UNSAFE_MEMCPY(ptr, &val, sizeof(val));
  ------------------
  |  |  174|  20.8k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
   88|  20.8k|}
lossless.c:WebPUint32ToMem:
   86|  3.73M|static WEBP_INLINE void WebPUint32ToMem(uint8_t* const ptr, uint32_t val) {
   87|  3.73M|  WEBP_UNSAFE_MEMCPY(ptr, &val, sizeof(val));
  ------------------
  |  |  174|  3.73M|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
   88|  3.73M|}
dec_sse41.c:WebPMemToInt32:
   82|  76.3k|static WEBP_INLINE int32_t WebPMemToInt32(const uint8_t* const ptr) {
   83|  76.3k|  return (int32_t)WebPMemToUint32(ptr);
   84|  76.3k|}
dec_sse41.c:WebPMemToUint32:
   76|  76.3k|static WEBP_INLINE uint32_t WebPMemToUint32(const uint8_t* const ptr) {
   77|  76.3k|  uint32_t A;
   78|  76.3k|  WEBP_UNSAFE_MEMCPY(&A, ptr, sizeof(A));
  ------------------
  |  |  174|  76.3k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
   79|  76.3k|  return A;
   80|  76.3k|}
dec_sse2.c:WebPMemToInt32:
   82|  2.57M|static WEBP_INLINE int32_t WebPMemToInt32(const uint8_t* const ptr) {
   83|  2.57M|  return (int32_t)WebPMemToUint32(ptr);
   84|  2.57M|}
dec_sse2.c:WebPMemToUint32:
   76|  2.57M|static WEBP_INLINE uint32_t WebPMemToUint32(const uint8_t* const ptr) {
   77|  2.57M|  uint32_t A;
   78|  2.57M|  WEBP_UNSAFE_MEMCPY(&A, ptr, sizeof(A));
  ------------------
  |  |  174|  2.57M|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
   79|  2.57M|  return A;
   80|  2.57M|}
dec_sse2.c:WebPInt32ToMem:
   90|  2.17M|static WEBP_INLINE void WebPInt32ToMem(uint8_t* const ptr, int val) {
   91|  2.17M|  WebPUint32ToMem(ptr, (uint32_t)val);
   92|  2.17M|}
dec_sse2.c:WebPUint32ToMem:
   86|  2.17M|static WEBP_INLINE void WebPUint32ToMem(uint8_t* const ptr, uint32_t val) {
   87|  2.17M|  WEBP_UNSAFE_MEMCPY(ptr, &val, sizeof(val));
  ------------------
  |  |  174|  2.17M|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
   88|  2.17M|}
bit_reader_utils.c:BitsLog2Floor:
  136|   549k|static WEBP_INLINE int BitsLog2Floor(uint32_t n) {
  137|   549k|  return 31 ^ __builtin_clz(n);
  138|   549k|}
bit_reader_utils.c:WebPMemToUint32:
   76|   236k|static WEBP_INLINE uint32_t WebPMemToUint32(const uint8_t* const ptr) {
   77|   236k|  uint32_t A;
   78|   236k|  WEBP_UNSAFE_MEMCPY(&A, ptr, sizeof(A));
  ------------------
  |  |  174|   236k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
   79|   236k|  return A;
   80|   236k|}
tree_dec.c:BitsLog2Floor:
  136|  5.26M|static WEBP_INLINE int BitsLog2Floor(uint32_t n) {
  137|  5.26M|  return 31 ^ __builtin_clz(n);
  138|  5.26M|}

webp_dec.c:WebPInitDecBuffer:
  250|  5.18k|WEBP_NODISCARD static WEBP_INLINE int WebPInitDecBuffer(WebPDecBuffer* buffer) {
  251|  5.18k|  return WebPInitDecBufferInternal(buffer, WEBP_DECODER_ABI_VERSION);
  ------------------
  |  |   27|  5.18k|#define WEBP_DECODER_ABI_VERSION 0x0210  // MAJOR(8b) + MINOR(8b)
  ------------------
  252|  5.18k|}
webp_dec.c:WebPIsRGBMode:
  203|    751|static WEBP_INLINE int WebPIsRGBMode(WEBP_CSP_MODE mode) {
  204|    751|  return (mode < MODE_YUV);
  205|    751|}
buffer_dec.c:WebPIsRGBMode:
  203|  8.54k|static WEBP_INLINE int WebPIsRGBMode(WEBP_CSP_MODE mode) {
  204|  8.54k|  return (mode < MODE_YUV);
  205|  8.54k|}
io_dec.c:WebPIsRGBMode:
  203|  2.66k|static WEBP_INLINE int WebPIsRGBMode(WEBP_CSP_MODE mode) {
  204|  2.66k|  return (mode < MODE_YUV);
  205|  2.66k|}
io_dec.c:WebPIsAlphaMode:
  197|  2.66k|static WEBP_INLINE int WebPIsAlphaMode(WEBP_CSP_MODE mode) {
  198|  2.66k|  return (mode == MODE_RGBA || mode == MODE_BGRA || mode == MODE_ARGB ||
  ------------------
  |  Branch (198:11): [True: 478, False: 2.19k]
  |  Branch (198:32): [True: 344, False: 1.84k]
  |  Branch (198:53): [True: 487, False: 1.36k]
  ------------------
  199|  1.36k|          mode == MODE_RGBA_4444 || mode == MODE_YUVA ||
  ------------------
  |  Branch (199:11): [True: 0, False: 1.36k]
  |  Branch (199:37): [True: 0, False: 1.36k]
  ------------------
  200|  1.36k|          WebPIsPremultipliedMode(mode));
  ------------------
  |  Branch (200:11): [True: 0, False: 1.36k]
  ------------------
  201|  2.66k|}
io_dec.c:WebPIsPremultipliedMode:
  192|  2.66k|static WEBP_INLINE int WebPIsPremultipliedMode(WEBP_CSP_MODE mode) {
  193|  2.66k|  return (mode == MODE_rgbA || mode == MODE_bgrA || mode == MODE_Argb ||
  ------------------
  |  Branch (193:11): [True: 0, False: 2.66k]
  |  Branch (193:32): [True: 0, False: 2.66k]
  |  Branch (193:53): [True: 0, False: 2.66k]
  ------------------
  194|  2.66k|          mode == MODE_rgbA_4444);
  ------------------
  |  Branch (194:11): [True: 0, False: 2.66k]
  ------------------
  195|  2.66k|}
vp8l_dec.c:WebPIsPremultipliedMode:
  192|  1.30k|static WEBP_INLINE int WebPIsPremultipliedMode(WEBP_CSP_MODE mode) {
  193|  1.30k|  return (mode == MODE_rgbA || mode == MODE_bgrA || mode == MODE_Argb ||
  ------------------
  |  Branch (193:11): [True: 0, False: 1.30k]
  |  Branch (193:32): [True: 0, False: 1.30k]
  |  Branch (193:53): [True: 0, False: 1.30k]
  ------------------
  194|  1.30k|          mode == MODE_rgbA_4444);
  ------------------
  |  Branch (194:11): [True: 0, False: 1.30k]
  ------------------
  195|  1.30k|}
vp8l_dec.c:WebPIsRGBMode:
  203|  1.04M|static WEBP_INLINE int WebPIsRGBMode(WEBP_CSP_MODE mode) {
  204|  1.04M|  return (mode < MODE_YUV);
  205|  1.04M|}

simple_api_fuzzer.cc:_ZN10fuzz_utilsL8FuzzHashEPKhm:
   64|  5.18k|static WEBP_INLINE uint8_t FuzzHash(const uint8_t* const data, size_t size) {
   65|  5.18k|  uint8_t value = 0;
   66|  5.18k|  size_t incr = size / 128;
   67|  5.18k|  if (!incr) incr = 1;
  ------------------
  |  Branch (67:7): [True: 4.61k, False: 565]
  ------------------
   68|   203k|  for (size_t i = 0; i < size; i += incr) value += data[i];
  ------------------
  |  Branch (68:22): [True: 198k, False: 5.18k]
  ------------------
   69|  5.18k|  return value;
   70|  5.18k|}

simple_api_fuzzer.cc:_ZN12_GLOBAL__N_113SimpleApiTestENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE:
   30|  5.53k|void SimpleApiTest(std::string_view data_in) {
   31|  5.53k|  const uint8_t* const data = reinterpret_cast<const uint8_t*>(data_in.data());
   32|  5.53k|  const size_t size = data_in.size();
   33|  5.53k|  int w, h;
   34|  5.53k|  if (!WebPGetInfo(data, size, &w, &h)) return;
  ------------------
  |  Branch (34:7): [True: 319, False: 5.21k]
  ------------------
   35|  5.21k|  if ((size_t)w * h > fuzz_utils::kFuzzPxLimit) return;
  ------------------
  |  Branch (35:7): [True: 27, False: 5.18k]
  ------------------
   36|       |
   37|  5.18k|  const uint8_t value = fuzz_utils::FuzzHash(data, size);
   38|  5.18k|  uint8_t* buf = NULL;
   39|       |
   40|       |  // For *Into functions, which decode into an external buffer, an
   41|       |  // intentionally too small buffer can be given with low probability.
   42|  5.18k|  if (value < 0x16) {
  ------------------
  |  Branch (42:7): [True: 481, False: 4.70k]
  ------------------
   43|    481|    buf = WebPDecodeRGBA(data, size, &w, &h);
   44|  4.70k|  } else if (value < 0x2b) {
  ------------------
  |  Branch (44:14): [True: 535, False: 4.16k]
  ------------------
   45|    535|    buf = WebPDecodeBGRA(data, size, &w, &h);
   46|    535|#if !defined(WEBP_REDUCE_CSP)
   47|  4.16k|  } else if (value < 0x40) {
  ------------------
  |  Branch (47:14): [True: 472, False: 3.69k]
  ------------------
   48|    472|    buf = WebPDecodeARGB(data, size, &w, &h);
   49|  3.69k|  } else if (value < 0x55) {
  ------------------
  |  Branch (49:14): [True: 462, False: 3.23k]
  ------------------
   50|    462|    buf = WebPDecodeRGB(data, size, &w, &h);
   51|  3.23k|  } else if (value < 0x6a) {
  ------------------
  |  Branch (51:14): [True: 447, False: 2.78k]
  ------------------
   52|    447|    buf = WebPDecodeBGR(data, size, &w, &h);
   53|    447|#endif  // !defined(WEBP_REDUCE_CSP)
   54|  2.78k|  } else if (value < 0x7f) {
  ------------------
  |  Branch (54:14): [True: 409, False: 2.37k]
  ------------------
   55|    409|    uint8_t *u, *v;
   56|    409|    int stride, uv_stride;
   57|    409|    buf = WebPDecodeYUV(data, size, &w, &h, &u, &v, &stride, &uv_stride);
   58|  2.37k|  } else if (value < 0xe8) {
  ------------------
  |  Branch (58:14): [True: 1.90k, False: 474]
  ------------------
   59|  1.90k|    const int stride = (value < 0xbe ? 4 : 3) * w;
  ------------------
  |  Branch (59:25): [True: 1.35k, False: 549]
  ------------------
   60|  1.90k|    size_t buf_size = stride * h;
   61|  1.90k|    if (value % 0x10 == 0) buf_size--;
  ------------------
  |  Branch (61:9): [True: 45, False: 1.85k]
  ------------------
   62|  1.90k|    uint8_t* const ext_buf = (uint8_t*)malloc(buf_size);
   63|  1.90k|    if (value < 0x94) {
  ------------------
  |  Branch (63:9): [True: 408, False: 1.49k]
  ------------------
   64|    408|      (void)WebPDecodeRGBAInto(data, size, ext_buf, buf_size, stride);
   65|    408|#if !defined(WEBP_REDUCE_CSP)
   66|  1.49k|    } else if (value < 0xa9) {
  ------------------
  |  Branch (66:16): [True: 448, False: 1.04k]
  ------------------
   67|    448|      (void)WebPDecodeARGBInto(data, size, ext_buf, buf_size, stride);
   68|  1.04k|    } else if (value < 0xbe) {
  ------------------
  |  Branch (68:16): [True: 499, False: 549]
  ------------------
   69|    499|      (void)WebPDecodeBGRInto(data, size, ext_buf, buf_size, stride);
   70|    549|    } else if (value < 0xd3) {
  ------------------
  |  Branch (70:16): [True: 416, False: 133]
  ------------------
   71|    416|      (void)WebPDecodeRGBInto(data, size, ext_buf, buf_size, stride);
   72|    416|#endif  // !defined(WEBP_REDUCE_CSP)
   73|    416|    } else {
   74|    133|      (void)WebPDecodeBGRAInto(data, size, ext_buf, buf_size, stride);
   75|    133|    }
   76|  1.90k|    free(ext_buf);
   77|  1.90k|  } else {
   78|    474|    size_t luma_size = w * h;
   79|    474|    const int uv_stride = (w + 1) / 2;
   80|    474|    size_t u_size = uv_stride * (h + 1) / 2;
   81|    474|    size_t v_size = uv_stride * (h + 1) / 2;
   82|    474|    if (value % 0x10 == 0) {
  ------------------
  |  Branch (82:9): [True: 26, False: 448]
  ------------------
   83|     26|      if (size & 1) luma_size--;
  ------------------
  |  Branch (83:11): [True: 16, False: 10]
  ------------------
   84|     26|      if (size & 2) u_size--;
  ------------------
  |  Branch (84:11): [True: 3, False: 23]
  ------------------
   85|     26|      if (size & 4) v_size--;
  ------------------
  |  Branch (85:11): [True: 24, False: 2]
  ------------------
   86|     26|    }
   87|    474|    uint8_t* const luma_buf = (uint8_t*)malloc(luma_size);
   88|    474|    uint8_t* const u_buf = (uint8_t*)malloc(u_size);
   89|    474|    uint8_t* const v_buf = (uint8_t*)malloc(v_size);
   90|    474|    (void)WebPDecodeYUVInto(data, size, luma_buf, luma_size,
   91|    474|                            w /* luma_stride */, u_buf, u_size, uv_stride,
   92|    474|                            v_buf, v_size, uv_stride);
   93|    474|    free(luma_buf);
   94|    474|    free(u_buf);
   95|    474|    free(v_buf);
   96|    474|  }
   97|       |
   98|  5.18k|  if (buf) WebPFree(buf);
  ------------------
  |  Branch (98:7): [True: 751, False: 4.43k]
  ------------------
   99|  5.18k|}