_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|  8.92k|inline constexpr Dest bit_cast(const Source& source) {
  164|  8.92k|  return __builtin_bit_cast(Dest, source);
  165|  8.92k|}
_ZN4absl12lts_202401168bit_castIlmTnNSt3__19enable_ifIXaaaaeqstT_stT0_sr3std21is_trivially_copyableIS5_EE5valuesr3std21is_trivially_copyableIS4_EE5valueEiE4typeELi0EEES4_RKS5_:
  163|  4.47k|inline constexpr Dest bit_cast(const Source& source) {
  164|  4.47k|  return __builtin_bit_cast(Dest, source);
  165|  4.47k|}
_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|  4.27k|inline constexpr Dest bit_cast(const Source& source) {
  164|  4.27k|  return __builtin_bit_cast(Dest, source);
  165|  4.27k|}

_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|     28|  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|      2|  apply(F&& f, Args&&... args) {
  591|      2|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  592|      2|                                                   std::forward<Args>(args)...);
  593|      2|  }
_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|     28|      -> decltype(P::element(slot)) {
   76|     28|    return P::element(slot);
   77|     28|  }
_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|    256|  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|    256|  constexpr const ElemT<I>& get() const& {
  247|    256|    return StorageT<I>::get();
  248|    256|  }
_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|      2|  ElemT<I>& get() & {
  242|      2|    return StorageT<I>::get();
  243|      2|  }
_ZNR4absl12lts_2024011618container_internal25internal_compressed_tuple7StorageINS1_8StringEqELm2ELb1EE3getEv:
  106|      2|  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|      2|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  207|      2|  return memory_internal::DecomposePairImpl(
  208|      2|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  209|      2|}
_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|      2|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  139|      2|  const auto& key = std::get<0>(p.first);
  140|      2|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  141|      2|                            std::move(p.second));
  142|      2|}
_ZN4absl12lts_2024011618container_internal8PairArgsIKNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS3_4pairINS3_5tupleIJRKT_EEENSC_IJRKT0_EEEEERKNSB_ISD_SH_EE:
  187|      2|    const std::pair<F, S>& p) {
  188|      2|  return PairArgs(p.first, p.second);
  189|      2|}
_ZN4absl12lts_2024011618container_internal8PairArgsIRKNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEERKPNS0_15CommandLineFlagEEENS3_4pairINS3_5tupleIJOT_EEENSF_IJOT0_EEEEESH_SK_:
  181|      2|std::pair<std::tuple<F&&>, std::tuple<S&&>> PairArgs(F&& f, S&& s) {
  182|      2|  return {std::piecewise_construct, std::forward_as_tuple(std::forward<F>(f)),
  183|      2|          std::forward_as_tuple(std::forward<S>(s))};
  184|      2|}
_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|      2|  bool operator()(absl::string_view lhs, absl::string_view rhs) const {
   88|      2|    return lhs == rhs;
   89|      2|  }

_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|      2|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  134|      2|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  135|      2|  }
_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|     55|  explicit GroupSse2Impl(const ctrl_t* pos) {
  616|     55|    ctrl = _mm_loadu_si128(reinterpret_cast<const __m128i*>(pos));
  617|     55|  }
_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|     28|  friend bool operator!=(const BitMask& a, const BitMask& b) {
  462|     28|    return a.mask_ != b.mask_;
  463|     28|  }
_ZNK4absl12lts_2024011618container_internal7BitMaskItLi16ELi0EEdeEv:
  452|      2|  uint32_t operator*() const { return Base::LowestBitSet(); }
_ZNK4absl12lts_2024011618container_internal18NonIterableBitMaskItLi16ELi0EE12LowestBitSetEv:
  394|     28|  uint32_t LowestBitSet() const {
  395|     28|    return container_internal::TrailingZeros(mask_) >> Shift;
  396|     28|  }
_ZN4absl12lts_2024011618container_internal13TrailingZerosItEEjT_:
  372|     28|uint32_t TrailingZeros(T x) {
  373|     28|  ABSL_ASSUME(x != 0);
  ------------------
  |  |  259|     28|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
  374|     28|  return static_cast<uint32_t>(countr_zero(x));
  375|     28|}
_ZNK4absl12lts_2024011618container_internal12CommonFields10slot_arrayEv:
 1047|    138|  void* slot_array() const { return slots_; }
_ZNK4absl12lts_2024011618container_internal9probe_seqILm16EE6offsetEm:
  324|     28|  size_t offset(size_t i) const { return (offset_ + i) & mask_; }
_ZN4absl12lts_2024011618container_internal7BitMaskItLi16ELi0EEppEv:
  443|      2|  BitMask& operator++() {
  444|      2|    if (Shift == 3) {
  ------------------
  |  Branch (444:9): [Folded, False: 2]
  ------------------
  445|      0|      constexpr uint64_t msbs = 0x8080808080808080ULL;
  446|      0|      this->mask_ &= msbs;
  447|      0|    }
  448|      2|    this->mask_ &= (this->mask_ - 1);
  449|      2|    return *this;
  450|      2|  }
_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|     29|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|     29|  return _mm_cmpgt_epi8(a, b);
  610|     29|}
_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: 6, False: 2]
  ------------------
 1549|       |      // Offset fall on kSentinel or into the mostly occupied first half.
 1550|      6|      offset = old_capacity / 2;
 1551|      6|    }
 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|     31|inline bool IsEmptyOrDeleted(ctrl_t c) { return c < ctrl_t::kSentinel; }
_ZNK4absl12lts_2024011618container_internal13GroupSse2Impl26CountLeadingEmptyOrDeletedEv:
  657|      3|  uint32_t CountLeadingEmptyOrDeleted() const {
  658|      3|    auto special = _mm_set1_epi8(static_cast<char>(ctrl_t::kSentinel));
  659|      3|    return TrailingZeros(static_cast<uint32_t>(
  660|      3|        _mm_movemask_epi8(_mm_cmpgt_epi8_fixed(special, ctrl)) + 1));
  661|      3|  }
_ZN4absl12lts_2024011618container_internal13TrailingZerosIjEEjT_:
  372|      3|uint32_t TrailingZeros(T x) {
  373|      3|  ABSL_ASSUME(x != 0);
  ------------------
  |  |  259|      3|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
  374|      3|  return static_cast<uint32_t>(countr_zero(x));
  375|      3|}
_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|    256|  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|     66|  slot_type* slot_array() const {
 3198|     66|    return static_cast<slot_type*>(common().slot_array());
 3199|     66|  }
_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|     31|      while (IsEmptyOrDeleted(*ctrl_)) {
  ------------------
  |  Branch (2000:14): [True: 3, False: 28]
  ------------------
 2001|      3|        uint32_t shift =
 2002|      3|            GroupEmptyOrDeleted{ctrl_}.CountLeadingEmptyOrDeleted();
 2003|      3|        ctrl_ += shift;
 2004|      3|        slot_ += shift;
 2005|      3|      }
 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|      2|    bool operator()(const K2& lhs, Args&&...) const {
 2814|      2|      return eq(lhs, rhs);
 2815|      2|    }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE6eq_refEv:
 3204|      2|  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: 2, False: 26]
  ------------------
 3094|      2|        if (ABSL_PREDICT_TRUE(PolicyTraits::apply(
  ------------------
  |  |  179|      2|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (179:30): [True: 0, False: 2]
  |  |  |  Branch (179:48): [Folded, False: 2]
  |  |  |  Branch (179:57): [True: 0, False: 2]
  |  |  ------------------
  ------------------
 3095|      2|                EqualElement<K>{key, eq_ref()},
 3096|      2|                PolicyTraits::element(slot_array() + seq.offset(i)))))
 3097|      0|          return {seq.offset(i), false};
 3098|      2|      }
 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|    224|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|     94|            [](const CommandLineFlag* lhs, const CommandLineFlag* rhs) {
  210|     94|              return lhs->Name() < rhs->Name();
  211|     94|            });

_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|  4.93k|    countl_zero(T x) noexcept {
  104|  4.93k|  return numeric_internal::CountLeadingZeroes(x);
  105|  4.93k|}
_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|     28|    countr_zero(T x) noexcept {
  119|     28|  return numeric_internal::CountTrailingZeroes(x);
  120|     28|}
_ZN4absl12lts_2024011611countr_zeroIjEENSt3__19enable_ifIXsr3std11is_unsignedIT_EE5valueEiE4typeES4_:
  118|      3|    countr_zero(T x) noexcept {
  119|      3|  return numeric_internal::CountTrailingZeroes(x);
  120|      3|}
_ZN4absl12lts_202401169bit_widthImEENSt3__19enable_ifIXsr3std11is_unsignedIT_EE5valueEiE4typeES4_:
  160|  4.09k|    bit_width(T x) noexcept {
  161|  4.09k|  return std::numeric_limits<T>::digits - countl_zero(x);
  162|  4.09k|}

_ZN4absl12lts_20240116mlENS0_7uint128ES1_:
  982|    865|inline uint128 operator*(uint128 lhs, uint128 rhs) {
  983|    865|#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|    865|  return static_cast<unsigned __int128>(lhs) *
  987|    865|         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|    865|}
_ZNK4absl12lts_202401167uint128cvoEv:
  776|  13.0k|constexpr uint128::operator unsigned __int128() const {
  777|  13.0k|  return (static_cast<unsigned __int128>(hi_) << 64) + lo_;
  778|  13.0k|}
_ZN4absl12lts_202401167uint128C2Eo:
  674|  8.30k|    : lo_{static_cast<uint64_t>(v & ~uint64_t{0})},
  675|  8.30k|      hi_{static_cast<uint64_t>(v >> 64)} {}
_ZN4absl12lts_202401167uint128C2Em:
  665|  5.82k|constexpr uint128::uint128(unsigned long v) : lo_{v}, hi_{0} {}
_ZNK4absl12lts_202401167uint128cvmEv:
  759|  4.42k|constexpr uint128::operator unsigned long() const {  // NOLINT(runtime/int)
  760|  4.42k|  return static_cast<unsigned long>(lo_);            // NOLINT(runtime/int)
  761|  4.42k|}
_ZN4absl12lts_20240116rsENS0_7uint128Ei:
  922|    886|constexpr uint128 operator>>(uint128 lhs, int amount) {
  923|    886|#ifdef ABSL_HAVE_INTRINSIC_INT128
  924|    886|  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|    886|}
_ZN4absl12lts_202401167uint128rSEi:
  613|    886|inline uint128& uint128::operator>>=(int amount) {
  614|    886|  *this = *this >> amount;
  615|    886|  return *this;
  616|    886|}
_ZN4absl12lts_202401167uint128pLES1_:
  618|     10|inline uint128& uint128::operator+=(uint128 other) {
  619|     10|  *this = *this + other;
  620|     10|  return *this;
  621|     10|}
_ZN4absl12lts_202401167uint128mLES1_:
  628|    354|inline uint128& uint128::operator*=(uint128 other) {
  629|    354|  *this = *this * other;
  630|    354|  return *this;
  631|    354|}
_ZN4absl12lts_2024011612Uint128Low64ENS0_7uint128E:
  643|    543|constexpr uint64_t Uint128Low64(uint128 v) { return v.lo_; }
_ZN4absl12lts_2024011613Uint128High64ENS0_7uint128E:
  645|  2.65k|constexpr uint64_t Uint128High64(uint128 v) { return v.hi_; }
_ZN4absl12lts_20240116eqENS0_7uint128ES1_:
  798|    605|constexpr bool operator==(uint128 lhs, uint128 rhs) {
  799|    605|#if defined(ABSL_HAVE_INTRINSIC_INT128)
  800|    605|  return static_cast<unsigned __int128>(lhs) ==
  801|    605|         static_cast<unsigned __int128>(rhs);
  802|       |#else
  803|       |  return (Uint128Low64(lhs) == Uint128Low64(rhs) &&
  804|       |          Uint128High64(lhs) == Uint128High64(rhs));
  805|       |#endif
  806|    605|}
_ZN4absl12lts_20240116ltENS0_7uint128ES1_:
  810|    553|constexpr bool operator<(uint128 lhs, uint128 rhs) {
  811|    553|#ifdef ABSL_HAVE_INTRINSIC_INT128
  812|    553|  return static_cast<unsigned __int128>(lhs) <
  813|    553|         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|    553|}
_ZN4absl12lts_20240116gtENS0_7uint128ES1_:
  821|    553|constexpr bool operator>(uint128 lhs, uint128 rhs) { return rhs < lhs; }
_ZN4absl12lts_20240116anENS0_7uint128ES1_:
  871|    559|constexpr inline uint128 operator&(uint128 lhs, uint128 rhs) {
  872|    559|#if defined(ABSL_HAVE_INTRINSIC_INT128)
  873|    559|  return static_cast<unsigned __int128>(lhs) &
  874|    559|         static_cast<unsigned __int128>(rhs);
  875|       |#else
  876|       |  return MakeUint128(Uint128High64(lhs) & Uint128High64(rhs),
  877|       |                     Uint128Low64(lhs) & Uint128Low64(rhs));
  878|       |#endif
  879|    559|}
_ZN4absl12lts_20240116lsENS0_7uint128Ei:
  908|  4.97k|constexpr uint128 operator<<(uint128 lhs, int amount) {
  909|  4.97k|#ifdef ABSL_HAVE_INTRINSIC_INT128
  910|  4.97k|  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|  4.97k|}
_ZN4absl12lts_20240116plENS0_7uint128ES1_:
  947|    213|constexpr uint128 operator+(uint128 lhs, uint128 rhs) {
  948|    213|#if defined(ABSL_HAVE_INTRINSIC_INT128)
  949|    213|  return static_cast<unsigned __int128>(lhs) +
  950|    213|         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|    213|}
_ZN4absl12lts_20240116miENS0_7uint128ES1_:
  970|    802|constexpr uint128 operator-(uint128 lhs, uint128 rhs) {
  971|    802|#if defined(ABSL_HAVE_INTRINSIC_INT128)
  972|    802|  return static_cast<unsigned __int128>(lhs) -
  973|    802|         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|    802|}
_ZN4absl12lts_202401167uint128ppEv:
 1035|      3|inline uint128& uint128::operator++() {
 1036|      3|  *this += 1;
 1037|      3|  return *this;
 1038|      3|}
_ZN4absl12lts_202401167uint128C2Ei:
  654|  2.12k|    : lo_{static_cast<uint64_t>(v)},
  655|  2.12k|      hi_{v < 0 ? (std::numeric_limits<uint64_t>::max)() : 0} {}
  ------------------
  |  Branch (655:11): [True: 0, False: 2.12k]
  ------------------

_ZN4absl12lts_2024011616numeric_internal18CountLeadingZeroesImEEiT_:
  234|  4.93k|CountLeadingZeroes(T x) {
  235|  4.93k|  static_assert(std::is_unsigned<T>::value, "T must be unsigned");
  236|  4.93k|  static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
  237|  4.93k|                "T must have a power-of-2 size");
  238|  4.93k|  static_assert(sizeof(T) <= sizeof(uint64_t), "T too large");
  239|  4.93k|  return sizeof(T) <= sizeof(uint16_t)
  ------------------
  |  Branch (239:10): [Folded, False: 4.93k]
  ------------------
  240|  4.93k|             ? CountLeadingZeroes16(static_cast<uint16_t>(x)) -
  241|      0|                   (std::numeric_limits<uint16_t>::digits -
  242|      0|                    std::numeric_limits<T>::digits)
  243|  4.93k|             : (sizeof(T) <= sizeof(uint32_t)
  ------------------
  |  Branch (243:17): [Folded, False: 4.93k]
  ------------------
  244|  4.93k|                    ? CountLeadingZeroes32(static_cast<uint32_t>(x)) -
  245|      0|                          (std::numeric_limits<uint32_t>::digits -
  246|      0|                           std::numeric_limits<T>::digits)
  247|  4.93k|                    : CountLeadingZeroes64(x));
  248|  4.93k|}
_ZN4absl12lts_2024011616numeric_internal20CountLeadingZeroes64Em:
  180|  4.93k|CountLeadingZeroes64(uint64_t x) {
  181|  4.93k|#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|  4.93k|  static_assert(sizeof(unsigned long long) == sizeof(x),  // NOLINT(runtime/int)
  187|  4.93k|                "__builtin_clzll does not take 64-bit arg");
  188|       |
  189|       |  // Handle 0 as a special case because __builtin_clzll(0) is undefined.
  190|  4.93k|  return x == 0 ? 64 : __builtin_clzll(x);
  ------------------
  |  Branch (190:10): [True: 0, False: 4.93k]
  ------------------
  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|  4.93k|}
_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|     28|CountTrailingZeroes(T x) noexcept {
  318|     28|  static_assert(std::is_unsigned<T>::value, "T must be unsigned");
  319|     28|  static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
  320|     28|                "T must have a power-of-2 size");
  321|     28|  static_assert(sizeof(T) <= sizeof(uint64_t), "T too large");
  322|     28|  return x == 0 ? std::numeric_limits<T>::digits
  ------------------
  |  Branch (322:10): [True: 0, False: 28]
  ------------------
  323|     28|                : (sizeof(T) <= sizeof(uint16_t)
  ------------------
  |  Branch (323:20): [True: 28, Folded]
  ------------------
  324|     28|                       ? CountTrailingZeroesNonzero16(static_cast<uint16_t>(x))
  325|     28|                       : (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|     28|}
_ZN4absl12lts_2024011616numeric_internal28CountTrailingZeroesNonzero16Et:
  305|     28|CountTrailingZeroesNonzero16(uint16_t x) {
  306|     28|#if ABSL_HAVE_BUILTIN(__builtin_ctzs)
  307|     28|  static_assert(sizeof(unsigned short) == sizeof(x),  // NOLINT(runtime/int)
  308|     28|                "__builtin_ctzs does not take 16-bit arg");
  309|     28|  return __builtin_ctzs(x);
  310|       |#else
  311|       |  return CountTrailingZeroesNonzero32(x);
  312|       |#endif
  313|     28|}
_ZN4absl12lts_2024011616numeric_internal19CountTrailingZeroesIjEEiT_:
  317|      3|CountTrailingZeroes(T x) noexcept {
  318|      3|  static_assert(std::is_unsigned<T>::value, "T must be unsigned");
  319|      3|  static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
  320|      3|                "T must have a power-of-2 size");
  321|      3|  static_assert(sizeof(T) <= sizeof(uint64_t), "T too large");
  322|      3|  return x == 0 ? std::numeric_limits<T>::digits
  ------------------
  |  Branch (322:10): [True: 0, False: 3]
  ------------------
  323|      3|                : (sizeof(T) <= sizeof(uint16_t)
  ------------------
  |  Branch (323:20): [Folded, False: 3]
  ------------------
  324|      3|                       ? CountTrailingZeroesNonzero16(static_cast<uint16_t>(x))
  325|      3|                       : (sizeof(T) <= sizeof(uint32_t)
  ------------------
  |  Branch (325:27): [True: 3, Folded]
  ------------------
  326|      3|                              ? CountTrailingZeroesNonzero32(
  327|      3|                                    static_cast<uint32_t>(x))
  328|      3|                              : CountTrailingZeroesNonzero64(x)));
  329|      3|}
_ZN4absl12lts_2024011616numeric_internal28CountTrailingZeroesNonzero32Ej:
  251|      3|CountTrailingZeroesNonzero32(uint32_t x) {
  252|      3|#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_ctz)
  253|      3|  static_assert(sizeof(unsigned int) == sizeof(x),
  254|      3|                "__builtin_ctz does not take 32-bit arg");
  255|      3|  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|      3|}

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

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

_ZN4absl12lts_2024011610from_charsEPKcS2_RdNS0_12chars_formatE:
  953|  5.18k|                             chars_format fmt) {
  954|  5.18k|  return FromCharsImpl(first, last, value, fmt);
  955|  5.18k|}
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_113FromCharsImplIdEENS0_17from_chars_resultEPKcS5_RT_NS0_12chars_formatE:
  866|  5.18k|                                FloatType& value, chars_format fmt_flags) {
  867|  5.18k|  from_chars_result result;
  868|  5.18k|  result.ptr = first;  // overwritten on successful parse
  869|  5.18k|  result.ec = std::errc();
  870|       |
  871|  5.18k|  bool negative = false;
  872|  5.18k|  if (first != last && *first == '-') {
  ------------------
  |  Branch (872:7): [True: 5.17k, False: 3]
  |  Branch (872:24): [True: 109, False: 5.06k]
  ------------------
  873|    109|    ++first;
  874|    109|    negative = true;
  875|    109|  }
  876|       |  // If the `hex` flag is *not* set, then we will accept a 0x prefix and try
  877|       |  // to parse a hexadecimal float.
  878|  5.18k|  if ((fmt_flags & chars_format::hex) == chars_format{} && last - first >= 2 &&
  ------------------
  |  Branch (878:7): [True: 5.18k, False: 0]
  |  Branch (878:60): [True: 5.00k, False: 175]
  ------------------
  879|  5.00k|      *first == '0' && (first[1] == 'x' || first[1] == 'X')) {
  ------------------
  |  Branch (879:7): [True: 4.29k, False: 707]
  |  Branch (879:25): [True: 3.65k, False: 646]
  |  Branch (879:44): [True: 611, False: 35]
  ------------------
  880|  4.26k|    const char* hex_first = first + 2;
  881|  4.26k|    strings_internal::ParsedFloat hex_parse =
  882|  4.26k|        strings_internal::ParseFloat<16>(hex_first, last, fmt_flags);
  883|  4.26k|    if (hex_parse.end == nullptr ||
  ------------------
  |  Branch (883:9): [True: 6, False: 4.25k]
  ------------------
  884|  4.25k|        hex_parse.type != strings_internal::FloatType::kNumber) {
  ------------------
  |  Branch (884:9): [True: 0, False: 4.25k]
  ------------------
  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|      6|      if (fmt_flags == chars_format::scientific) {
  ------------------
  |  Branch (892:11): [True: 0, False: 6]
  ------------------
  893|      0|        result.ec = std::errc::invalid_argument;
  894|      6|      } else {
  895|      6|        result.ptr = first + 1;
  896|      6|        value = negative ? -0.0 : 0.0;
  ------------------
  |  Branch (896:17): [True: 1, False: 5]
  ------------------
  897|      6|      }
  898|      6|      return result;
  899|      6|    }
  900|       |    // We matched a value.
  901|  4.25k|    result.ptr = hex_parse.end;
  902|  4.25k|    if (HandleEdgeCase(hex_parse, negative, &value)) {
  ------------------
  |  Branch (902:9): [True: 166, False: 4.09k]
  ------------------
  903|    166|      return result;
  904|    166|    }
  905|  4.09k|    CalculatedFloat calculated =
  906|  4.09k|        CalculateFromParsedHexadecimal<FloatType>(hex_parse);
  907|  4.09k|    EncodeResult(calculated, negative, &result, &value);
  908|  4.09k|    return result;
  909|  4.25k|  }
  910|       |  // Otherwise, we choose the number base based on the flags.
  911|    917|  if ((fmt_flags & chars_format::hex) == chars_format::hex) {
  ------------------
  |  Branch (911:7): [True: 0, False: 917]
  ------------------
  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|    917|  } else {
  927|    917|    strings_internal::ParsedFloat decimal_parse =
  928|    917|        strings_internal::ParseFloat<10>(first, last, fmt_flags);
  929|    917|    if (decimal_parse.end == nullptr) {
  ------------------
  |  Branch (929:9): [True: 20, False: 897]
  ------------------
  930|     20|      result.ec = std::errc::invalid_argument;
  931|     20|      return result;
  932|     20|    }
  933|    897|    result.ptr = decimal_parse.end;
  934|    897|    if (HandleEdgeCase(decimal_parse, negative, &value)) {
  ------------------
  |  Branch (934:9): [True: 65, False: 832]
  ------------------
  935|     65|      return result;
  936|     65|    }
  937|       |    // A nullptr subrange_begin means that the decimal_parse.mantissa is exact
  938|       |    // (not truncated), a precondition of the Eisel-Lemire algorithm.
  939|    832|    if ((decimal_parse.subrange_begin == nullptr) &&
  ------------------
  |  Branch (939:9): [True: 504, False: 328]
  ------------------
  940|    504|        EiselLemire<FloatType>(decimal_parse, negative, &value, &result.ec)) {
  ------------------
  |  Branch (940:9): [True: 496, False: 8]
  ------------------
  941|    496|      return result;
  942|    496|    }
  943|    336|    CalculatedFloat calculated =
  944|    336|        CalculateFromParsedDecimal<FloatType>(decimal_parse);
  945|    336|    EncodeResult(calculated, negative, &result, &value);
  946|    336|    return result;
  947|    832|  }
  948|    917|}
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_114HandleEdgeCaseIdEEbRKNS0_16strings_internal11ParsedFloatEbPT_:
  360|  5.15k|                    absl::Nonnull<FloatType*> value) {
  361|  5.15k|  if (input.type == strings_internal::FloatType::kNan) {
  ------------------
  |  Branch (361:7): [True: 0, False: 5.15k]
  ------------------
  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|      0|    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|      0|    char n_char_sequence[kNanBufferSize];
  375|      0|#endif
  376|      0|    if (input.subrange_begin == nullptr) {
  ------------------
  |  Branch (376:9): [True: 0, False: 0]
  ------------------
  377|      0|      n_char_sequence[0] = '\0';
  378|      0|    } 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|      0|    char* nan_argument = const_cast<char*>(n_char_sequence);
  385|      0|    *value = negative ? -FloatTraits<FloatType>::MakeNan(nan_argument)
  ------------------
  |  Branch (385:14): [True: 0, False: 0]
  ------------------
  386|      0|                      : FloatTraits<FloatType>::MakeNan(nan_argument);
  387|      0|    return true;
  388|      0|  }
  389|  5.15k|  if (input.type == strings_internal::FloatType::kInfinity) {
  ------------------
  |  Branch (389:7): [True: 14, False: 5.14k]
  ------------------
  390|     14|    *value = negative ? -std::numeric_limits<FloatType>::infinity()
  ------------------
  |  Branch (390:14): [True: 0, False: 14]
  ------------------
  391|     14|                      : std::numeric_limits<FloatType>::infinity();
  392|     14|    return true;
  393|     14|  }
  394|  5.14k|  if (input.mantissa == 0) {
  ------------------
  |  Branch (394:7): [True: 217, False: 4.92k]
  ------------------
  395|    217|    *value = negative ? -0.0 : 0.0;
  ------------------
  |  Branch (395:14): [True: 25, False: 192]
  ------------------
  396|    217|    return true;
  397|    217|  }
  398|  4.92k|  return false;
  399|  5.14k|}
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_130CalculateFromParsedHexadecimalIdEENS1_15CalculatedFloatERKNS0_16strings_internal11ParsedFloatE:
  602|  4.09k|    const strings_internal::ParsedFloat& parsed_hex) {
  603|  4.09k|  uint64_t mantissa = parsed_hex.mantissa;
  604|  4.09k|  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.09k|  int mantissa_width = static_cast<int>(bit_width(mantissa));
  608|  4.09k|  const int shift = NormalizedShiftSize<FloatType>(mantissa_width, exponent);
  609|  4.09k|  bool result_exact;
  610|  4.09k|  exponent += shift;
  611|  4.09k|  mantissa = ShiftRightAndRound(mantissa, shift,
  612|  4.09k|                                /* 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.09k|  return CalculatedFloatFromRawValues<FloatType>(mantissa, exponent);
  616|  4.09k|}
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_119NormalizedShiftSizeIdEEiii:
  335|  4.42k|int NormalizedShiftSize(int mantissa_width, int binary_exponent) {
  336|  4.42k|  const int normal_shift =
  337|  4.42k|      mantissa_width - FloatTraits<FloatType>::kTargetMantissaBits;
  338|  4.42k|  const int minimum_shift =
  339|  4.42k|      FloatTraits<FloatType>::kMinNormalExponent - binary_exponent;
  340|  4.42k|  return std::max(normal_shift, minimum_shift);
  341|  4.42k|}
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_118ShiftRightAndRoundENS0_7uint128EibPb:
  456|  4.42k|                            absl::Nonnull<bool*> output_exact) {
  457|  4.42k|  if (shift <= 0) {
  ------------------
  |  Branch (457:7): [True: 3.87k, False: 554]
  ------------------
  458|  3.87k|    *output_exact = input_exact;
  459|  3.87k|    return static_cast<uint64_t>(value << -shift);
  460|  3.87k|  }
  461|    554|  if (shift >= 128) {
  ------------------
  |  Branch (461:7): [True: 1, False: 553]
  ------------------
  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|      1|    *output_exact = true;
  466|      1|    return 0;
  467|      1|  }
  468|       |
  469|    553|  *output_exact = true;
  470|    553|  const uint128 shift_mask = (uint128(1) << shift) - 1;
  471|    553|  const uint128 halfway_point = uint128(1) << (shift - 1);
  472|       |
  473|    553|  const uint128 shifted_bits = value & shift_mask;
  474|    553|  value >>= shift;
  475|    553|  if (shifted_bits > halfway_point) {
  ------------------
  |  Branch (475:7): [True: 203, False: 350]
  ------------------
  476|       |    // Shifted bits greater than 10000... require rounding up.
  477|    203|    return static_cast<uint64_t>(value + 1);
  478|    203|  }
  479|    350|  if (shifted_bits == halfway_point) {
  ------------------
  |  Branch (479:7): [True: 6, False: 344]
  ------------------
  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|      6|    if ((value & 1) == 1 || !input_exact) {
  ------------------
  |  Branch (486:9): [True: 2, False: 4]
  |  Branch (486:29): [True: 1, False: 3]
  ------------------
  487|      3|      ++value;
  488|      3|    }
  489|      6|    return static_cast<uint64_t>(value);
  490|      6|  }
  491|    344|  if (!input_exact && shifted_bits == halfway_point - 1) {
  ------------------
  |  Branch (491:7): [True: 249, False: 95]
  |  Branch (491:23): [True: 174, False: 75]
  ------------------
  492|       |    // Rounding direction is unclear, due to error.
  493|    174|    *output_exact = false;
  494|    174|  }
  495|       |  // Otherwise, round down.
  496|    344|  return static_cast<uint64_t>(value);
  497|    350|}
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_128CalculatedFloatFromRawValuesIdEENS1_15CalculatedFloatEmi:
  583|  4.42k|CalculatedFloat CalculatedFloatFromRawValues(uint64_t mantissa, int exponent) {
  584|  4.42k|  CalculatedFloat result;
  585|  4.42k|  if (mantissa == uint64_t{1} << FloatTraits<FloatType>::kTargetMantissaBits) {
  ------------------
  |  Branch (585:7): [True: 22, False: 4.40k]
  ------------------
  586|     22|    mantissa >>= 1;
  587|     22|    exponent += 1;
  588|     22|  }
  589|  4.42k|  if (exponent > FloatTraits<FloatType>::kMaxExponent) {
  ------------------
  |  Branch (589:7): [True: 645, False: 3.78k]
  ------------------
  590|    645|    result.exponent = kOverflow;
  591|  3.78k|  } else if (mantissa == 0) {
  ------------------
  |  Branch (591:14): [True: 1, False: 3.78k]
  ------------------
  592|      1|    result.exponent = kUnderflow;
  593|  3.78k|  } else {
  594|  3.78k|    result.exponent = exponent;
  595|  3.78k|    result.mantissa = mantissa;
  596|  3.78k|  }
  597|  4.42k|  return result;
  598|  4.42k|}
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_112EncodeResultIdEEvRKNS1_15CalculatedFloatEbPNS0_17from_chars_resultEPT_:
  410|  4.42k|                  absl::Nonnull<FloatType*> value) {
  411|  4.42k|  if (calculated.exponent == kOverflow) {
  ------------------
  |  Branch (411:7): [True: 647, False: 3.78k]
  ------------------
  412|    647|    result->ec = std::errc::result_out_of_range;
  413|    647|    *value = negative ? -std::numeric_limits<FloatType>::max()
  ------------------
  |  Branch (413:14): [True: 4, False: 643]
  ------------------
  414|    647|                      : std::numeric_limits<FloatType>::max();
  415|    647|    return;
  416|  3.78k|  } else if (calculated.mantissa == 0 || calculated.exponent == kUnderflow) {
  ------------------
  |  Branch (416:14): [True: 1, False: 3.78k]
  |  Branch (416:42): [True: 0, False: 3.78k]
  ------------------
  417|      1|    result->ec = std::errc::result_out_of_range;
  418|      1|    *value = negative ? -0.0 : 0.0;
  ------------------
  |  Branch (418:14): [True: 0, False: 1]
  ------------------
  419|      1|    return;
  420|      1|  }
  421|  3.78k|  *value = FloatTraits<FloatType>::Make(
  422|  3.78k|      static_cast<typename FloatTraits<FloatType>::mantissa_t>(
  423|  3.78k|          calculated.mantissa),
  424|  3.78k|      calculated.exponent, negative);
  425|  3.78k|}
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_111FloatTraitsIdE4MakeEmib:
  150|  3.78k|  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|  3.78k|    constexpr uint64_t kMantissaMask =
  158|  3.78k|        (uint64_t{1} << (kTargetMantissaBits - 1)) - 1;
  159|  3.78k|    uint64_t dbl = static_cast<uint64_t>(sign) << 63;
  160|  3.78k|    if (mantissa > kMantissaMask) {
  ------------------
  |  Branch (160:9): [True: 3.78k, False: 0]
  ------------------
  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|  3.78k|      dbl += static_cast<uint64_t>(exponent + 1023 + kTargetMantissaBits - 1)
  166|  3.78k|             << 52;
  167|  3.78k|      mantissa &= kMantissaMask;
  168|  3.78k|    } else {
  169|       |      // subnormal value
  170|       |      assert(exponent == kMinNormalExponent);
  171|      0|    }
  172|  3.78k|    dbl += mantissa;
  173|  3.78k|    return absl::bit_cast<double>(dbl);
  174|  3.78k|#endif  // ABSL_BIT_PACK_FLOATS
  175|  3.78k|  }
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_111EiselLemireIdEEbRKNS0_16strings_internal11ParsedFloatEbPT_PNSt3__14errcE:
  691|    504|                 absl::Nonnull<std::errc*> ec) {
  692|    504|  uint64_t man = input.mantissa;
  693|    504|  int exp10 = input.exponent;
  694|    504|  if (exp10 < FloatTraits<FloatType>::kEiselLemireMinInclusiveExp10) {
  ------------------
  |  Branch (694:7): [True: 0, False: 504]
  ------------------
  695|      0|    *value = negative ? -0.0 : 0.0;
  ------------------
  |  Branch (695:14): [True: 0, False: 0]
  ------------------
  696|      0|    *ec = std::errc::result_out_of_range;
  697|      0|    return true;
  698|    504|  } else if (exp10 >= FloatTraits<FloatType>::kEiselLemireMaxExclusiveExp10) {
  ------------------
  |  Branch (698:14): [True: 0, False: 504]
  ------------------
  699|       |    // Return max (a finite value) consistent with from_chars and DR 3081. For
  700|       |    // SimpleAtod and SimpleAtof, post-processing will return infinity.
  701|      0|    *value = negative ? -std::numeric_limits<FloatType>::max()
  ------------------
  |  Branch (701:14): [True: 0, False: 0]
  ------------------
  702|      0|                      : std::numeric_limits<FloatType>::max();
  703|      0|    *ec = std::errc::result_out_of_range;
  704|      0|    return true;
  705|      0|  }
  706|       |
  707|       |  // Assert kPower10TableMinInclusive <= exp10 < kPower10TableMaxExclusive.
  708|       |  // Equivalently, !Power10Underflow(exp10) and !Power10Overflow(exp10).
  709|    504|  static_assert(
  710|    504|      FloatTraits<FloatType>::kEiselLemireMinInclusiveExp10 >=
  711|    504|          kPower10TableMinInclusive,
  712|    504|      "(exp10-kPower10TableMinInclusive) in kPower10MantissaHighTable bounds");
  713|    504|  static_assert(
  714|    504|      FloatTraits<FloatType>::kEiselLemireMaxExclusiveExp10 <=
  715|    504|          kPower10TableMaxExclusive,
  716|    504|      "(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|    504|  int clz = countl_zero(man);
  732|    504|  man <<= static_cast<unsigned int>(clz);
  733|       |  // The 217706 etc magic numbers are from the Power10Exponent function.
  734|    504|  uint64_t ret_exp2 =
  735|    504|      static_cast<uint64_t>((217706 * exp10 >> 16) + 64 +
  736|    504|                            FloatTraits<FloatType>::kExponentBias - clz);
  737|       |
  738|       |  // (+) Multiplication.
  739|    504|  uint128 x = static_cast<uint128>(man) *
  740|    504|              static_cast<uint128>(
  741|    504|                  kPower10MantissaHighTable[exp10 - kPower10TableMinInclusive]);
  742|       |
  743|       |  // (+) Wider Approximation.
  744|    504|  static constexpr uint64_t high64_mask =
  745|    504|      FloatTraits<FloatType>::kEiselLemireMask;
  746|    504|  if (((Uint128High64(x) & high64_mask) == high64_mask) &&
  ------------------
  |  Branch (746:7): [True: 12, False: 492]
  ------------------
  747|     12|      (man > (std::numeric_limits<uint64_t>::max() - Uint128Low64(x)))) {
  ------------------
  |  Branch (747:7): [True: 7, False: 5]
  ------------------
  748|      7|    uint128 y =
  749|      7|        static_cast<uint128>(man) *
  750|      7|        static_cast<uint128>(
  751|      7|            kPower10MantissaLowTable[exp10 - kPower10TableMinInclusive]);
  752|      7|    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|      7|    if (((Uint128High64(x) & high64_mask) == high64_mask) &&
  ------------------
  |  Branch (762:9): [True: 7, False: 0]
  ------------------
  763|      7|        ((Uint128Low64(x) + 1) == 0) &&
  ------------------
  |  Branch (763:9): [True: 7, False: 0]
  ------------------
  764|      7|        (man > (std::numeric_limits<uint64_t>::max() - Uint128Low64(y)))) {
  ------------------
  |  Branch (764:9): [True: 7, False: 0]
  ------------------
  765|      7|      return false;
  766|      7|    }
  767|      7|  }
  768|       |
  769|       |  // (+) Shifting to 54 Bits (or for single precision, to 25 bits).
  770|    497|  uint64_t msb = Uint128High64(x) >> 63;
  771|    497|  uint64_t ret_man =
  772|    497|      Uint128High64(x) >> (msb + FloatTraits<FloatType>::kEiselLemireShift);
  773|    497|  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|    497|  if ((Uint128Low64(x) == 0) && ((Uint128High64(x) & high64_mask) == 0) &&
  ------------------
  |  Branch (784:7): [True: 451, False: 46]
  |  Branch (784:33): [True: 423, False: 28]
  ------------------
  785|    423|      ((ret_man & 3) == 1)) {
  ------------------
  |  Branch (785:7): [True: 1, False: 422]
  ------------------
  786|      1|    return false;
  787|      1|  }
  788|       |
  789|       |  // (+) From 54 to 53 Bits (or for single precision, from 25 to 24 bits).
  790|    496|  ret_man += ret_man & 1;  // Line From54a.
  791|    496|  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|    496|  if ((ret_man >> FloatTraits<FloatType>::kTargetMantissaBits) > 0) {
  ------------------
  |  Branch (800:7): [True: 2, False: 494]
  ------------------
  801|      2|    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|      2|  }
  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|    496|  static constexpr uint64_t max_exp2 =
  825|    496|      (1 << FloatTraits<FloatType>::kTargetExponentBits) - 1;
  826|    496|  if ((ret_exp2 - 1) >= (max_exp2 - 1)) {
  ------------------
  |  Branch (826:7): [True: 0, False: 496]
  ------------------
  827|      0|    return false;
  828|      0|  }
  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|    496|  if (FloatTraits<FloatType>::kTargetBits == 64) {
  ------------------
  |  Branch (843:7): [True: 496, Folded]
  ------------------
  844|    496|    uint64_t ret_bits = (ret_exp2 << 52) | (ret_man & 0x000FFFFFFFFFFFFFu);
  845|    496|    if (negative) {
  ------------------
  |  Branch (845:9): [True: 53, False: 443]
  ------------------
  846|     53|      ret_bits |= 0x8000000000000000u;
  847|     53|    }
  848|    496|    *value = absl::bit_cast<double>(ret_bits);
  849|    496|    return true;
  850|    496|  } 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|    496|}
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_126CalculateFromParsedDecimalIdEENS1_15CalculatedFloatERKNS0_16strings_internal11ParsedFloatE:
  620|    336|    const strings_internal::ParsedFloat& parsed_decimal) {
  621|    336|  CalculatedFloat result;
  622|       |
  623|       |  // Large or small enough decimal exponents will always result in overflow
  624|       |  // or underflow.
  625|    336|  if (Power10Underflow(parsed_decimal.exponent)) {
  ------------------
  |  Branch (625:7): [True: 0, False: 336]
  ------------------
  626|      0|    result.exponent = kUnderflow;
  627|      0|    return result;
  628|    336|  } else if (Power10Overflow(parsed_decimal.exponent)) {
  ------------------
  |  Branch (628:14): [True: 2, False: 334]
  ------------------
  629|      2|    result.exponent = kOverflow;
  630|      2|    return result;
  631|      2|  }
  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|    334|  uint128 wide_binary_mantissa = parsed_decimal.mantissa;
  636|    334|  wide_binary_mantissa *= Power10Mantissa(parsed_decimal.exponent);
  637|    334|  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|    334|  bool mantissa_exact;
  645|    334|  int mantissa_width;
  646|    334|  if (parsed_decimal.subrange_begin) {
  ------------------
  |  Branch (646:7): [True: 326, False: 8]
  ------------------
  647|       |    // Truncated mantissa
  648|    326|    mantissa_width = 58;
  649|    326|    mantissa_exact = false;
  650|    326|    binary_exponent +=
  651|    326|        TruncateToBitWidth(mantissa_width, &wide_binary_mantissa);
  652|    326|  } else if (!Power10Exact(parsed_decimal.exponent)) {
  ------------------
  |  Branch (652:14): [True: 7, False: 1]
  ------------------
  653|       |    // Exact mantissa, truncated power of ten
  654|      7|    mantissa_width = 63;
  655|      7|    mantissa_exact = false;
  656|      7|    binary_exponent +=
  657|      7|        TruncateToBitWidth(mantissa_width, &wide_binary_mantissa);
  658|      7|  } else {
  659|       |    // Product is exact
  660|      1|    mantissa_width = BitWidth(wide_binary_mantissa);
  661|      1|    mantissa_exact = true;
  662|      1|  }
  663|       |
  664|       |  // Shift into an FloatType-sized mantissa, and round to nearest.
  665|    334|  const int shift =
  666|    334|      NormalizedShiftSize<FloatType>(mantissa_width, binary_exponent);
  667|    334|  bool result_exact;
  668|    334|  binary_exponent += shift;
  669|    334|  uint64_t binary_mantissa = ShiftRightAndRound(wide_binary_mantissa, shift,
  670|    334|                                                mantissa_exact, &result_exact);
  671|    334|  if (!result_exact) {
  ------------------
  |  Branch (671:7): [True: 174, False: 160]
  ------------------
  672|       |    // We could not determine the rounding direction using int128 math.  Use
  673|       |    // full resolution math instead.
  674|    174|    if (MustRoundUp(binary_mantissa, binary_exponent, parsed_decimal)) {
  ------------------
  |  Branch (674:9): [True: 140, False: 34]
  ------------------
  675|    140|      binary_mantissa += 1;
  676|    140|    }
  677|    174|  }
  678|       |
  679|    334|  return CalculatedFloatFromRawValues<FloatType>(binary_mantissa,
  680|    334|                                                 binary_exponent);
  681|    336|}
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_116Power10UnderflowEi:
  288|    336|bool Power10Underflow(int n) { return n < kPower10TableMinInclusive; }
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_115Power10OverflowEi:
  284|    336|bool Power10Overflow(int n) { return n >= kPower10TableMaxExclusive; }
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_115Power10MantissaEi:
  270|    334|uint64_t Power10Mantissa(int n) {
  271|    334|  return kPower10MantissaHighTable[n - kPower10TableMinInclusive];
  272|    334|}
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_115Power10ExponentEi:
  274|    334|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|    334|  return (217706 * n >> 16) - 63;
  280|    334|}
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_118TruncateToBitWidthEiPNS0_7uint128E:
  348|    333|int TruncateToBitWidth(int bit_width, absl::Nonnull<uint128*> value) {
  349|    333|  const int current_bit_width = BitWidth(*value);
  350|    333|  const int shift = current_bit_width - bit_width;
  351|    333|  *value >>= shift;
  352|    333|  return shift;
  353|    333|}
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_112Power10ExactEi:
  293|      8|bool Power10Exact(int n) { return n >= 0 && n <= 27; }
  ------------------
  |  Branch (293:35): [True: 1, False: 7]
  |  Branch (293:45): [True: 1, False: 0]
  ------------------
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_18BitWidthENS0_7uint128E:
  317|    334|int BitWidth(uint128 value) {
  318|    334|  if (Uint128High64(value) == 0) {
  ------------------
  |  Branch (318:7): [True: 0, False: 334]
  ------------------
  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|      0|    return static_cast<int>(bit_width(Uint128Low64(value)));
  322|      0|  }
  323|    334|  return 128 - countl_zero(Uint128High64(value));
  324|    334|}
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_111MustRoundUpEmiRKNS0_16strings_internal11ParsedFloatE:
  513|    174|                 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|    174|  absl::strings_internal::BigUnsigned<84> exact_mantissa;
  519|    174|  int exact_exponent = exact_mantissa.ReadFloatMantissa(parsed_decimal, 768);
  520|       |
  521|       |  // Adjust the `guess` arguments to be halfway between A and B.
  522|    174|  guess_mantissa = guess_mantissa * 2 + 1;
  523|    174|  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|    174|  absl::strings_internal::BigUnsigned<84>& lhs = exact_mantissa;
  533|    174|  int comparison;
  534|    174|  if (exact_exponent >= 0) {
  ------------------
  |  Branch (534:7): [True: 8, False: 166]
  ------------------
  535|      8|    lhs.MultiplyByFiveToTheNth(exact_exponent);
  536|      8|    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|      8|    if (exact_exponent > guess_exponent) {
  ------------------
  |  Branch (539:9): [True: 0, False: 8]
  ------------------
  540|      0|      lhs.ShiftLeft(exact_exponent - guess_exponent);
  541|      8|    } else {
  542|      8|      rhs.ShiftLeft(guess_exponent - exact_exponent);
  543|      8|    }
  544|      8|    comparison = Compare(lhs, rhs);
  545|    166|  } 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|    166|    absl::strings_internal::BigUnsigned<84> rhs =
  550|    166|        absl::strings_internal::BigUnsigned<84>::FiveToTheNth(-exact_exponent);
  551|    166|    rhs.MultiplyBy(guess_mantissa);
  552|    166|    if (exact_exponent > guess_exponent) {
  ------------------
  |  Branch (552:9): [True: 8, False: 158]
  ------------------
  553|      8|      lhs.ShiftLeft(exact_exponent - guess_exponent);
  554|    158|    } else {
  555|    158|      rhs.ShiftLeft(guess_exponent - exact_exponent);
  556|    158|    }
  557|    166|    comparison = Compare(lhs, rhs);
  558|    166|  }
  559|    174|  if (comparison < 0) {
  ------------------
  |  Branch (559:7): [True: 34, False: 140]
  ------------------
  560|     34|    return false;
  561|    140|  } else if (comparison > 0) {
  ------------------
  |  Branch (561:14): [True: 140, False: 0]
  ------------------
  562|    140|    return true;
  563|    140|  } 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|      0|    return (guess_mantissa & 2) == 2;
  569|      0|  }
  570|    174|}

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

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

_ZN4absl12lts_2024011616strings_internal11BigUnsignedILi84EEC2Ev:
   62|    174|  BigUnsigned() : size_(0), words_{} {}
_ZN4absl12lts_2024011616strings_internal11BigUnsignedILi84EE22MultiplyByFiveToTheNthEi:
  164|    174|  void MultiplyByFiveToTheNth(int n) {
  165|    264|    while (n >= kMaxSmallPowerOfFive) {
  ------------------
  |  Branch (165:12): [True: 90, False: 174]
  ------------------
  166|     90|      MultiplyBy(kFiveToNth[kMaxSmallPowerOfFive]);
  167|     90|      n -= kMaxSmallPowerOfFive;
  168|     90|    }
  169|    174|    if (n > 0) {
  ------------------
  |  Branch (169:9): [True: 151, False: 23]
  ------------------
  170|    151|      MultiplyBy(kFiveToNth[n]);
  171|    151|    }
  172|    174|  }
_ZN4absl12lts_2024011616strings_internal11BigUnsignedILi84EE10MultiplyByEj:
  130|  5.96k|  void MultiplyBy(uint32_t v) {
  131|  5.96k|    if (size_ == 0 || v == 1) {
  ------------------
  |  Branch (131:9): [True: 174, False: 5.79k]
  |  Branch (131:23): [True: 0, False: 5.79k]
  ------------------
  132|    174|      return;
  133|    174|    }
  134|  5.79k|    if (v == 0) {
  ------------------
  |  Branch (134:9): [True: 0, False: 5.79k]
  ------------------
  135|      0|      SetToZero();
  136|      0|      return;
  137|      0|    }
  138|  5.79k|    const uint64_t factor = v;
  139|  5.79k|    uint64_t window = 0;
  140|   159k|    for (int i = 0; i < size_; ++i) {
  ------------------
  |  Branch (140:21): [True: 153k, False: 5.79k]
  ------------------
  141|   153k|      window += factor * words_[i];
  142|   153k|      words_[i] = window & 0xffffffff;
  143|   153k|      window >>= 32;
  144|   153k|    }
  145|       |    // If carry bits remain and there's space for them, grow size_.
  146|  5.79k|    if (window && size_ < max_words) {
  ------------------
  |  Branch (146:9): [True: 5.34k, False: 447]
  |  Branch (146:19): [True: 5.34k, False: 0]
  ------------------
  147|  5.34k|      words_[size_] = window & 0xffffffff;
  148|  5.34k|      ++size_;
  149|  5.34k|    }
  150|  5.79k|  }
_ZN4absl12lts_2024011616strings_internal11BigUnsignedILi84EE9SetToZeroEv:
  199|    348|  void SetToZero() {
  200|    348|    std::fill_n(words_, size_, 0u);
  201|    348|    size_ = 0;
  202|    348|  }
_ZN4absl12lts_2024011616strings_internal11BigUnsignedILi84EEC2Em:
   64|    174|      : size_((v >> 32) ? 2 : v ? 1 : 0),
  ------------------
  |  Branch (64:15): [True: 8, False: 166]
  |  Branch (64:31): [True: 166, False: 0]
  ------------------
   65|    174|        words_{static_cast<uint32_t>(v & 0xffffffffu),
   66|    174|               static_cast<uint32_t>(v >> 32)} {}
_ZN4absl12lts_2024011616strings_internal11BigUnsignedILi84EE9ShiftLeftEi:
  102|    174|  void ShiftLeft(int count) {
  103|    174|    if (count > 0) {
  ------------------
  |  Branch (103:9): [True: 173, False: 1]
  ------------------
  104|    173|      const int word_shift = count / 32;
  105|    173|      if (word_shift >= max_words) {
  ------------------
  |  Branch (105:11): [True: 0, False: 173]
  ------------------
  106|      0|        SetToZero();
  107|      0|        return;
  108|      0|      }
  109|    173|      size_ = (std::min)(size_ + word_shift, max_words);
  110|    173|      count %= 32;
  111|    173|      if (count == 0) {
  ------------------
  |  Branch (111:11): [True: 5, False: 168]
  ------------------
  112|      5|        std::copy_backward(words_, words_ + size_ - word_shift, words_ + size_);
  113|    168|      } else {
  114|  3.96k|        for (int i = (std::min)(size_, max_words - 1); i > word_shift; --i) {
  ------------------
  |  Branch (114:56): [True: 3.79k, False: 168]
  ------------------
  115|  3.79k|          words_[i] = (words_[i - word_shift] << count) |
  116|  3.79k|                      (words_[i - word_shift - 1] >> (32 - count));
  117|  3.79k|        }
  118|    168|        words_[word_shift] = words_[0] << count;
  119|       |        // Grow size_ if necessary.
  120|    168|        if (size_ < max_words && words_[size_]) {
  ------------------
  |  Branch (120:13): [True: 168, False: 0]
  |  Branch (120:34): [True: 67, False: 101]
  ------------------
  121|     67|          ++size_;
  122|     67|        }
  123|    168|      }
  124|    173|      std::fill_n(words_, word_shift, 0u);
  125|    173|    }
  126|    174|  }
_ZN4absl12lts_2024011616strings_internal7CompareILi84ELi84EEEiRKNS1_11BigUnsignedIXT_EEERKNS3_IXT0_EEE:
  353|    174|int Compare(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs) {
  354|    174|  int limit = (std::max)(lhs.size(), rhs.size());
  355|    508|  for (int i = limit - 1; i >= 0; --i) {
  ------------------
  |  Branch (355:27): [True: 508, False: 0]
  ------------------
  356|    508|    const uint32_t lhs_word = lhs.GetWord(i);
  357|    508|    const uint32_t rhs_word = rhs.GetWord(i);
  358|    508|    if (lhs_word < rhs_word) {
  ------------------
  |  Branch (358:9): [True: 34, False: 474]
  ------------------
  359|     34|      return -1;
  360|    474|    } else if (lhs_word > rhs_word) {
  ------------------
  |  Branch (360:16): [True: 140, False: 334]
  ------------------
  361|    140|      return 1;
  362|    140|    }
  363|    508|  }
  364|      0|  return 0;
  365|    174|}
_ZNK4absl12lts_2024011616strings_internal11BigUnsignedILi84EE4sizeEv:
  217|    348|  int size() const { return size_; }
_ZNK4absl12lts_2024011616strings_internal11BigUnsignedILi84EE7GetWordEi:
  206|  1.01k|  uint32_t GetWord(int index) const {
  207|  1.01k|    if (index < 0 || index >= size_) {
  ------------------
  |  Branch (207:9): [True: 0, False: 1.01k]
  |  Branch (207:22): [True: 0, False: 1.01k]
  ------------------
  208|      0|      return 0;
  209|      0|    }
  210|  1.01k|    return words_[index];
  211|  1.01k|  }
_ZN4absl12lts_2024011616strings_internal11BigUnsignedILi84EE10MultiplyByEm:
  152|    166|  void MultiplyBy(uint64_t v) {
  153|    166|    uint32_t words[2];
  154|    166|    words[0] = static_cast<uint32_t>(v);
  155|    166|    words[1] = static_cast<uint32_t>(v >> 32);
  156|    166|    if (words[1] == 0) {
  ------------------
  |  Branch (156:9): [True: 0, False: 166]
  ------------------
  157|      0|      MultiplyBy(words[0]);
  158|    166|    } else {
  159|    166|      MultiplyBy(2, words);
  160|    166|    }
  161|    166|  }
_ZN4absl12lts_2024011616strings_internal11BigUnsignedILi84EE10MultiplyByEiPKj:
  270|    198|  void MultiplyBy(int other_size, const uint32_t* other_words) {
  271|    198|    const int original_size = size_;
  272|    198|    const int first_step =
  273|    198|        (std::min)(original_size + other_size - 2, max_words - 1);
  274|  5.61k|    for (int step = first_step; step >= 0; --step) {
  ------------------
  |  Branch (274:33): [True: 5.41k, False: 198]
  ------------------
  275|  5.41k|      MultiplyStep(original_size, other_words, other_size, step);
  276|  5.41k|    }
  277|    198|  }
_ZN4absl12lts_2024011616strings_internal11BigUnsignedILi84EE12AddWithCarryEij:
  280|  8.06k|  void AddWithCarry(int index, uint32_t value) {
  281|  8.06k|    if (value) {
  ------------------
  |  Branch (281:9): [True: 8.06k, False: 0]
  ------------------
  282|  17.4k|      while (index < max_words && value > 0) {
  ------------------
  |  Branch (282:14): [True: 17.4k, False: 0]
  |  Branch (282:35): [True: 9.34k, False: 8.06k]
  ------------------
  283|  9.34k|        words_[index] += value;
  284|       |        // carry if we overflowed in this word:
  285|  9.34k|        if (value > words_[index]) {
  ------------------
  |  Branch (285:13): [True: 1.28k, False: 8.06k]
  ------------------
  286|  1.28k|          value = 1;
  287|  1.28k|          ++index;
  288|  8.06k|        } else {
  289|  8.06k|          value = 0;
  290|  8.06k|        }
  291|  9.34k|      }
  292|  8.06k|      size_ = (std::min)(max_words, (std::max)(index + 1, size_));
  293|  8.06k|    }
  294|  8.06k|  }
_ZN4absl12lts_2024011616strings_internal11BigUnsignedILi84EE12AddWithCarryEim:
  296|  5.41k|  void AddWithCarry(int index, uint64_t value) {
  297|  5.41k|    if (value && index < max_words) {
  ------------------
  |  Branch (297:9): [True: 5.34k, False: 70]
  |  Branch (297:18): [True: 5.34k, False: 0]
  ------------------
  298|  5.34k|      uint32_t high = value >> 32;
  299|  5.34k|      uint32_t low = value & 0xffffffff;
  300|  5.34k|      words_[index] += low;
  301|  5.34k|      if (words_[index] < low) {
  ------------------
  |  Branch (301:11): [True: 1.80k, False: 3.54k]
  ------------------
  302|  1.80k|        ++high;
  303|  1.80k|        if (high == 0) {
  ------------------
  |  Branch (303:13): [True: 0, False: 1.80k]
  ------------------
  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|  1.80k|      }
  310|  5.34k|      if (high > 0) {
  ------------------
  |  Branch (310:11): [True: 2.34k, False: 3.00k]
  ------------------
  311|  2.34k|        AddWithCarry(index + 1, high);
  312|  3.00k|      } 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|  3.00k|        size_ = (std::min)(max_words, (std::max)(index + 1, size_));
  316|  3.00k|      }
  317|  5.34k|    }
  318|  5.41k|  }

_ZN4absl12lts_2024011616strings_internal10ParseFloatILi10EEENS1_11ParsedFloatEPKcS5_NS0_12chars_formatE:
  356|    917|                                         chars_format format_flags) {
  357|    917|  strings_internal::ParsedFloat result;
  358|       |
  359|       |  // Exit early if we're given an empty range.
  360|    917|  if (begin == end) return result;
  ------------------
  |  Branch (360:7): [True: 4, False: 913]
  ------------------
  361|       |
  362|       |  // Handle the infinity and NaN cases.
  363|    913|  if (ParseInfinityOrNan(begin, end, &result)) {
  ------------------
  |  Branch (363:7): [True: 14, False: 899]
  ------------------
  364|     14|    return result;
  365|     14|  }
  366|       |
  367|    899|  const char* const mantissa_begin = begin;
  368|    977|  while (begin < end && *begin == '0') {
  ------------------
  |  Branch (368:10): [True: 946, False: 31]
  |  Branch (368:25): [True: 78, False: 868]
  ------------------
  369|     78|    ++begin;  // skip leading zeros
  370|     78|  }
  371|    899|  uint64_t mantissa = 0;
  372|       |
  373|    899|  int exponent_adjustment = 0;
  374|    899|  bool mantissa_is_inexact = false;
  375|    899|  int pre_decimal_digits = ConsumeDigits<base>(
  376|    899|      begin, end, MantissaDigitsMax<base>(), &mantissa, &mantissa_is_inexact);
  377|    899|  begin += pre_decimal_digits;
  378|    899|  int digits_left;
  379|    899|  if (pre_decimal_digits >= DigitLimit<base>()) {
  ------------------
  |  Branch (379:7): [True: 0, False: 899]
  ------------------
  380|       |    // refuse to parse pathological inputs
  381|      0|    return result;
  382|    899|  } else if (pre_decimal_digits > MantissaDigitsMax<base>()) {
  ------------------
  |  Branch (382:14): [True: 104, False: 795]
  ------------------
  383|       |    // We dropped some non-fraction digits on the floor.  Adjust our exponent
  384|       |    // to compensate.
  385|    104|    exponent_adjustment =
  386|    104|        static_cast<int>(pre_decimal_digits - MantissaDigitsMax<base>());
  387|    104|    digits_left = 0;
  388|    795|  } else {
  389|    795|    digits_left =
  390|    795|        static_cast<int>(MantissaDigitsMax<base>() - pre_decimal_digits);
  391|    795|  }
  392|    899|  if (begin < end && *begin == '.') {
  ------------------
  |  Branch (392:7): [True: 405, False: 494]
  |  Branch (392:22): [True: 304, False: 101]
  ------------------
  393|    304|    ++begin;
  394|    304|    if (mantissa == 0) {
  ------------------
  |  Branch (394:9): [True: 36, False: 268]
  ------------------
  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|     36|      const char* begin_zeros = begin;
  398|     39|      while (begin < end && *begin == '0') {
  ------------------
  |  Branch (398:14): [True: 37, False: 2]
  |  Branch (398:29): [True: 3, False: 34]
  ------------------
  399|      3|        ++begin;
  400|      3|      }
  401|     36|      int zeros_skipped = static_cast<int>(begin - begin_zeros);
  402|     36|      if (zeros_skipped >= DigitLimit<base>()) {
  ------------------
  |  Branch (402:11): [True: 0, False: 36]
  ------------------
  403|       |        // refuse to parse pathological inputs
  404|      0|        return result;
  405|      0|      }
  406|     36|      exponent_adjustment -= static_cast<int>(zeros_skipped);
  407|     36|    }
  408|    304|    int post_decimal_digits = ConsumeDigits<base>(
  409|    304|        begin, end, digits_left, &mantissa, &mantissa_is_inexact);
  410|    304|    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|    304|    if (post_decimal_digits >= DigitLimit<base>()) {
  ------------------
  |  Branch (416:9): [True: 0, False: 304]
  ------------------
  417|       |      // refuse to parse pathological inputs
  418|      0|      return result;
  419|    304|    } else if (post_decimal_digits > digits_left) {
  ------------------
  |  Branch (419:16): [True: 235, False: 69]
  ------------------
  420|    235|      exponent_adjustment -= digits_left;
  421|    235|    } else {
  422|     69|      exponent_adjustment -= post_decimal_digits;
  423|     69|    }
  424|    304|  }
  425|       |  // If we've found no mantissa whatsoever, this isn't a number.
  426|    899|  if (mantissa_begin == begin) {
  ------------------
  |  Branch (426:7): [True: 14, False: 885]
  ------------------
  427|     14|    return result;
  428|     14|  }
  429|       |  // A bare "." doesn't count as a mantissa either.
  430|    885|  if (begin - mantissa_begin == 1 && *mantissa_begin == '.') {
  ------------------
  |  Branch (430:7): [True: 185, False: 700]
  |  Branch (430:38): [True: 2, False: 183]
  ------------------
  431|      2|    return result;
  432|      2|  }
  433|       |
  434|    883|  if (mantissa_is_inexact) {
  ------------------
  |  Branch (434:7): [True: 328, False: 555]
  ------------------
  435|       |    // We dropped significant digits on the floor.  Handle this appropriately.
  436|    328|    if (base == 10) {
  ------------------
  |  Branch (436:9): [True: 328, 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|    328|      result.subrange_begin = mantissa_begin;
  440|    328|      result.subrange_end = begin;
  441|    328|    } 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|    328|  }
  447|    883|  result.mantissa = mantissa;
  448|       |
  449|    883|  const char* const exponent_begin = begin;
  450|    883|  result.literal_exponent = 0;
  451|    883|  bool found_exponent = false;
  452|    883|  if (AllowExponent(format_flags) && begin < end &&
  ------------------
  |  Branch (452:7): [True: 883, False: 0]
  |  Branch (452:38): [True: 188, False: 695]
  ------------------
  453|    188|      IsExponentCharacter<base>(*begin)) {
  ------------------
  |  Branch (453:7): [True: 2, False: 186]
  ------------------
  454|      2|    bool negative_exponent = false;
  455|      2|    ++begin;
  456|      2|    if (begin < end && *begin == '-') {
  ------------------
  |  Branch (456:9): [True: 2, False: 0]
  |  Branch (456:24): [True: 0, False: 2]
  ------------------
  457|      0|      negative_exponent = true;
  458|      0|      ++begin;
  459|      2|    } else if (begin < end && *begin == '+') {
  ------------------
  |  Branch (459:16): [True: 2, False: 0]
  |  Branch (459:31): [True: 0, False: 2]
  ------------------
  460|      0|      ++begin;
  461|      0|    }
  462|      2|    const char* const exponent_digits_begin = begin;
  463|       |    // Exponent is always expressed in decimal, even for hexadecimal floats.
  464|      2|    begin += ConsumeDigits<10>(begin, end, kDecimalExponentDigitsMax,
  465|      2|                               &result.literal_exponent, nullptr);
  466|      2|    if (begin == exponent_digits_begin) {
  ------------------
  |  Branch (466:9): [True: 1, False: 1]
  ------------------
  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|      1|      found_exponent = false;
  470|      1|      begin = exponent_begin;
  471|      1|    } else {
  472|      1|      found_exponent = true;
  473|      1|      if (negative_exponent) {
  ------------------
  |  Branch (473:11): [True: 0, False: 1]
  ------------------
  474|      0|        result.literal_exponent = -result.literal_exponent;
  475|      0|      }
  476|      1|    }
  477|      2|  }
  478|       |
  479|    883|  if (!found_exponent && RequireExponent(format_flags)) {
  ------------------
  |  Branch (479:7): [True: 882, False: 1]
  |  Branch (479:26): [True: 0, False: 882]
  ------------------
  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|    883|  result.type = strings_internal::FloatType::kNumber;
  487|    883|  if (result.mantissa > 0) {
  ------------------
  |  Branch (487:7): [True: 832, False: 51]
  ------------------
  488|    832|    result.exponent = result.literal_exponent +
  489|    832|                      (DigitMagnitude<base>() * exponent_adjustment);
  490|    832|  } else {
  491|     51|    result.exponent = 0;
  492|     51|  }
  493|    883|  result.end = begin;
  494|    883|  return result;
  495|    883|}
_ZN4absl12lts_2024011616strings_internal10ParseFloatILi16EEENS1_11ParsedFloatEPKcS5_NS0_12chars_formatE:
  356|  4.26k|                                         chars_format format_flags) {
  357|  4.26k|  strings_internal::ParsedFloat result;
  358|       |
  359|       |  // Exit early if we're given an empty range.
  360|  4.26k|  if (begin == end) return result;
  ------------------
  |  Branch (360:7): [True: 1, False: 4.26k]
  ------------------
  361|       |
  362|       |  // Handle the infinity and NaN cases.
  363|  4.26k|  if (ParseInfinityOrNan(begin, end, &result)) {
  ------------------
  |  Branch (363:7): [True: 0, False: 4.26k]
  ------------------
  364|      0|    return result;
  365|      0|  }
  366|       |
  367|  4.26k|  const char* const mantissa_begin = begin;
  368|  4.43k|  while (begin < end && *begin == '0') {
  ------------------
  |  Branch (368:10): [True: 4.43k, False: 1]
  |  Branch (368:25): [True: 168, False: 4.26k]
  ------------------
  369|    168|    ++begin;  // skip leading zeros
  370|    168|  }
  371|  4.26k|  uint64_t mantissa = 0;
  372|       |
  373|  4.26k|  int exponent_adjustment = 0;
  374|  4.26k|  bool mantissa_is_inexact = false;
  375|  4.26k|  int pre_decimal_digits = ConsumeDigits<base>(
  376|  4.26k|      begin, end, MantissaDigitsMax<base>(), &mantissa, &mantissa_is_inexact);
  377|  4.26k|  begin += pre_decimal_digits;
  378|  4.26k|  int digits_left;
  379|  4.26k|  if (pre_decimal_digits >= DigitLimit<base>()) {
  ------------------
  |  Branch (379:7): [True: 0, False: 4.26k]
  ------------------
  380|       |    // refuse to parse pathological inputs
  381|      0|    return result;
  382|  4.26k|  } else if (pre_decimal_digits > MantissaDigitsMax<base>()) {
  ------------------
  |  Branch (382:14): [True: 162, False: 4.10k]
  ------------------
  383|       |    // We dropped some non-fraction digits on the floor.  Adjust our exponent
  384|       |    // to compensate.
  385|    162|    exponent_adjustment =
  386|    162|        static_cast<int>(pre_decimal_digits - MantissaDigitsMax<base>());
  387|    162|    digits_left = 0;
  388|  4.10k|  } else {
  389|  4.10k|    digits_left =
  390|  4.10k|        static_cast<int>(MantissaDigitsMax<base>() - pre_decimal_digits);
  391|  4.10k|  }
  392|  4.26k|  if (begin < end && *begin == '.') {
  ------------------
  |  Branch (392:7): [True: 4.12k, False: 137]
  |  Branch (392:22): [True: 497, False: 3.62k]
  ------------------
  393|    497|    ++begin;
  394|    497|    if (mantissa == 0) {
  ------------------
  |  Branch (394:9): [True: 57, False: 440]
  ------------------
  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|     57|      const char* begin_zeros = begin;
  398|     69|      while (begin < end && *begin == '0') {
  ------------------
  |  Branch (398:14): [True: 67, False: 2]
  |  Branch (398:29): [True: 12, False: 55]
  ------------------
  399|     12|        ++begin;
  400|     12|      }
  401|     57|      int zeros_skipped = static_cast<int>(begin - begin_zeros);
  402|     57|      if (zeros_skipped >= DigitLimit<base>()) {
  ------------------
  |  Branch (402:11): [True: 0, False: 57]
  ------------------
  403|       |        // refuse to parse pathological inputs
  404|      0|        return result;
  405|      0|      }
  406|     57|      exponent_adjustment -= static_cast<int>(zeros_skipped);
  407|     57|    }
  408|    497|    int post_decimal_digits = ConsumeDigits<base>(
  409|    497|        begin, end, digits_left, &mantissa, &mantissa_is_inexact);
  410|    497|    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|    497|    if (post_decimal_digits >= DigitLimit<base>()) {
  ------------------
  |  Branch (416:9): [True: 0, False: 497]
  ------------------
  417|       |      // refuse to parse pathological inputs
  418|      0|      return result;
  419|    497|    } else if (post_decimal_digits > digits_left) {
  ------------------
  |  Branch (419:16): [True: 51, False: 446]
  ------------------
  420|     51|      exponent_adjustment -= digits_left;
  421|    446|    } else {
  422|    446|      exponent_adjustment -= post_decimal_digits;
  423|    446|    }
  424|    497|  }
  425|       |  // If we've found no mantissa whatsoever, this isn't a number.
  426|  4.26k|  if (mantissa_begin == begin) {
  ------------------
  |  Branch (426:7): [True: 4, False: 4.25k]
  ------------------
  427|      4|    return result;
  428|      4|  }
  429|       |  // A bare "." doesn't count as a mantissa either.
  430|  4.25k|  if (begin - mantissa_begin == 1 && *mantissa_begin == '.') {
  ------------------
  |  Branch (430:7): [True: 3.06k, False: 1.19k]
  |  Branch (430:38): [True: 1, False: 3.06k]
  ------------------
  431|      1|    return result;
  432|      1|  }
  433|       |
  434|  4.25k|  if (mantissa_is_inexact) {
  ------------------
  |  Branch (434:7): [True: 212, False: 4.04k]
  ------------------
  435|       |    // We dropped significant digits on the floor.  Handle this appropriately.
  436|    212|    if (base == 10) {
  ------------------
  |  Branch (436:9): [Folded, False: 212]
  ------------------
  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|    212|    } else if (base == 16) {
  ------------------
  |  Branch (441:16): [True: 212, 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|    212|      mantissa |= 1;
  445|    212|    }
  446|    212|  }
  447|  4.25k|  result.mantissa = mantissa;
  448|       |
  449|  4.25k|  const char* const exponent_begin = begin;
  450|  4.25k|  result.literal_exponent = 0;
  451|  4.25k|  bool found_exponent = false;
  452|  4.25k|  if (AllowExponent(format_flags) && begin < end &&
  ------------------
  |  Branch (452:7): [True: 4.25k, False: 0]
  |  Branch (452:38): [True: 3.64k, False: 615]
  ------------------
  453|  3.64k|      IsExponentCharacter<base>(*begin)) {
  ------------------
  |  Branch (453:7): [True: 3.61k, False: 32]
  ------------------
  454|  3.61k|    bool negative_exponent = false;
  455|  3.61k|    ++begin;
  456|  3.61k|    if (begin < end && *begin == '-') {
  ------------------
  |  Branch (456:9): [True: 3.60k, False: 3]
  |  Branch (456:24): [True: 3, False: 3.60k]
  ------------------
  457|      3|      negative_exponent = true;
  458|      3|      ++begin;
  459|  3.60k|    } else if (begin < end && *begin == '+') {
  ------------------
  |  Branch (459:16): [True: 3.60k, False: 3]
  |  Branch (459:31): [True: 3.57k, False: 29]
  ------------------
  460|  3.57k|      ++begin;
  461|  3.57k|    }
  462|  3.61k|    const char* const exponent_digits_begin = begin;
  463|       |    // Exponent is always expressed in decimal, even for hexadecimal floats.
  464|  3.61k|    begin += ConsumeDigits<10>(begin, end, kDecimalExponentDigitsMax,
  465|  3.61k|                               &result.literal_exponent, nullptr);
  466|  3.61k|    if (begin == exponent_digits_begin) {
  ------------------
  |  Branch (466:9): [True: 27, False: 3.58k]
  ------------------
  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|     27|      found_exponent = false;
  470|     27|      begin = exponent_begin;
  471|  3.58k|    } else {
  472|  3.58k|      found_exponent = true;
  473|  3.58k|      if (negative_exponent) {
  ------------------
  |  Branch (473:11): [True: 3, False: 3.58k]
  ------------------
  474|      3|        result.literal_exponent = -result.literal_exponent;
  475|      3|      }
  476|  3.58k|    }
  477|  3.61k|  }
  478|       |
  479|  4.25k|  if (!found_exponent && RequireExponent(format_flags)) {
  ------------------
  |  Branch (479:7): [True: 674, False: 3.58k]
  |  Branch (479:26): [True: 0, False: 674]
  ------------------
  480|       |    // Provided flags required an exponent, but none was found.  This results
  481|       |    // in a failure to scan.
  482|      0|    return result;
  483|      0|  }
  484|       |
  485|       |  // Success!
  486|  4.25k|  result.type = strings_internal::FloatType::kNumber;
  487|  4.25k|  if (result.mantissa > 0) {
  ------------------
  |  Branch (487:7): [True: 4.09k, False: 166]
  ------------------
  488|  4.09k|    result.exponent = result.literal_exponent +
  489|  4.09k|                      (DigitMagnitude<base>() * exponent_adjustment);
  490|  4.09k|  } else {
  491|    166|    result.exponent = 0;
  492|    166|  }
  493|  4.25k|  result.end = begin;
  494|  4.25k|  return result;
  495|  4.25k|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_113AllowExponentENS0_12chars_formatE:
  122|  5.14k|bool AllowExponent(chars_format flags) {
  123|  5.14k|  bool fixed = (flags & chars_format::fixed) == chars_format::fixed;
  124|  5.14k|  bool scientific =
  125|  5.14k|      (flags & chars_format::scientific) == chars_format::scientific;
  126|  5.14k|  return scientific || !fixed;
  ------------------
  |  Branch (126:10): [True: 5.14k, False: 0]
  |  Branch (126:24): [True: 0, False: 0]
  ------------------
  127|  5.14k|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_115RequireExponentENS0_12chars_formatE:
  130|  1.55k|bool RequireExponent(chars_format flags) {
  131|  1.55k|  bool fixed = (flags & chars_format::fixed) == chars_format::fixed;
  132|  1.55k|  bool scientific =
  133|  1.55k|      (flags & chars_format::scientific) == chars_format::scientific;
  134|  1.55k|  return scientific && !fixed;
  ------------------
  |  Branch (134:10): [True: 1.55k, False: 0]
  |  Branch (134:24): [True: 0, False: 1.55k]
  ------------------
  135|  1.55k|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_119IsExponentCharacterILi10EEEbc:
  201|    188|bool IsExponentCharacter<10>(char ch) {
  202|    188|  return ch == 'e' || ch == 'E';
  ------------------
  |  Branch (202:10): [True: 1, False: 187]
  |  Branch (202:23): [True: 1, False: 186]
  ------------------
  203|    188|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_119IsExponentCharacterILi16EEEbc:
  206|  3.64k|bool IsExponentCharacter<16>(char ch) {
  207|  3.64k|  return ch == 'p' || ch == 'P';
  ------------------
  |  Branch (207:10): [True: 17, False: 3.62k]
  |  Branch (207:23): [True: 3.59k, False: 32]
  ------------------
  208|  3.64k|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_117MantissaDigitsMaxILi10EEEiv:
  211|  2.69k|constexpr int MantissaDigitsMax<10>() {
  212|  2.69k|  return kDecimalMantissaDigitsMax;
  213|  2.69k|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_117MantissaDigitsMaxILi16EEEiv:
  215|  12.7k|constexpr int MantissaDigitsMax<16>() {
  216|  12.7k|  return kHexadecimalMantissaDigitsMax;
  217|  12.7k|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_110DigitLimitILi10EEEiv:
  220|  1.23k|constexpr int DigitLimit<10>() {
  221|  1.23k|  return kDecimalDigitLimit;
  222|  1.23k|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_110DigitLimitILi16EEEiv:
  224|  4.81k|constexpr int DigitLimit<16>() {
  225|  4.81k|  return kHexadecimalDigitLimit;
  226|  4.81k|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_114DigitMagnitudeILi10EEEiv:
  229|    832|constexpr int DigitMagnitude<10>() {
  230|    832|  return 1;
  231|    832|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_114DigitMagnitudeILi16EEEiv:
  233|  4.09k|constexpr int DigitMagnitude<16>() {
  234|  4.09k|  return 4;
  235|  4.09k|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_118ParseInfinityOrNanEPKcS3_PNS0_16strings_internal11ParsedFloatE:
  298|  5.17k|                        strings_internal::ParsedFloat* out) {
  299|  5.17k|  if (end - begin < 3) {
  ------------------
  |  Branch (299:7): [True: 672, False: 4.50k]
  ------------------
  300|    672|    return false;
  301|    672|  }
  302|  4.50k|  switch (*begin) {
  303|     14|    case 'i':
  ------------------
  |  Branch (303:5): [True: 14, False: 4.49k]
  ------------------
  304|     14|    case 'I': {
  ------------------
  |  Branch (304:5): [True: 0, False: 4.50k]
  ------------------
  305|       |      // An infinity string consists of the characters "inf" or "infinity",
  306|       |      // case insensitive.
  307|     14|      if (strings_internal::memcasecmp(begin + 1, "nf", 2) != 0) {
  ------------------
  |  Branch (307:11): [True: 0, False: 14]
  ------------------
  308|      0|        return false;
  309|      0|      }
  310|     14|      out->type = strings_internal::FloatType::kInfinity;
  311|     14|      if (end - begin >= 8 &&
  ------------------
  |  Branch (311:11): [True: 14, False: 0]
  ------------------
  312|     14|          strings_internal::memcasecmp(begin + 3, "inity", 5) == 0) {
  ------------------
  |  Branch (312:11): [True: 0, False: 14]
  ------------------
  313|      0|        out->end = begin + 8;
  314|     14|      } else {
  315|     14|        out->end = begin + 3;
  316|     14|      }
  317|     14|      return true;
  318|     14|    }
  319|      0|    case 'n':
  ------------------
  |  Branch (319:5): [True: 0, False: 4.50k]
  ------------------
  320|      0|    case 'N': {
  ------------------
  |  Branch (320:5): [True: 0, False: 4.50k]
  ------------------
  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|      0|      if (strings_internal::memcasecmp(begin + 1, "an", 2) != 0) {
  ------------------
  |  Branch (324:11): [True: 0, False: 0]
  ------------------
  325|      0|        return false;
  326|      0|      }
  327|      0|      out->type = strings_internal::FloatType::kNan;
  328|      0|      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|      0|      begin += 3;
  332|      0|      if (begin < end && *begin == '(') {
  ------------------
  |  Branch (332:11): [True: 0, False: 0]
  |  Branch (332:26): [True: 0, False: 0]
  ------------------
  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|      0|      return true;
  345|      0|    }
  346|  4.49k|    default:
  ------------------
  |  Branch (346:5): [True: 4.49k, False: 14]
  ------------------
  347|  4.49k|      return false;
  348|  4.50k|  }
  349|  4.50k|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_113ConsumeDigitsILi10EmEEiPKcS4_iPT0_Pb:
  250|  1.20k|                  bool* dropped_nonzero_digit) {
  251|  1.20k|  if (base == 10) {
  ------------------
  |  Branch (251:7): [True: 1.20k, Folded]
  ------------------
  252|  1.20k|    assert(max_digits <= std::numeric_limits<T>::digits10);
  253|  1.20k|  } else if (base == 16) {
  ------------------
  |  Branch (253:14): [Folded, False: 0]
  ------------------
  254|      0|    assert(max_digits * 4 <= std::numeric_limits<T>::digits);
  255|      0|  }
  256|  1.20k|  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|  1.20k|  while (!*out && end != begin && *begin == '0') ++begin;
  ------------------
  |  Branch (261:10): [True: 935, False: 268]
  |  Branch (261:19): [True: 902, False: 33]
  |  Branch (261:35): [True: 0, False: 902]
  ------------------
  262|       |
  263|  1.20k|  T accumulator = *out;
  264|  1.20k|  const char* significant_digits_end =
  265|  1.20k|      (end - begin > max_digits) ? begin + max_digits : end;
  ------------------
  |  Branch (265:7): [True: 620, False: 583]
  ------------------
  266|  11.8k|  while (begin < significant_digits_end && IsDigit<base>(*begin)) {
  ------------------
  |  Branch (266:10): [True: 10.9k, False: 820]
  |  Branch (266:44): [True: 10.6k, False: 383]
  ------------------
  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|  10.6k|    auto digit = static_cast<T>(ToDigit<base>(*begin));
  270|  10.6k|    assert(accumulator * base >= accumulator);
  271|  10.6k|    accumulator *= base;
  272|  10.6k|    assert(accumulator + digit >= accumulator);
  273|  10.6k|    accumulator += digit;
  274|  10.6k|    ++begin;
  275|  10.6k|  }
  276|  1.20k|  bool dropped_nonzero = false;
  277|  14.8M|  while (begin < end && IsDigit<base>(*begin)) {
  ------------------
  |  Branch (277:10): [True: 14.8M, False: 695]
  |  Branch (277:25): [True: 14.8M, False: 508]
  ------------------
  278|  14.8M|    dropped_nonzero = dropped_nonzero || (*begin != '0');
  ------------------
  |  Branch (278:23): [True: 14.8M, False: 352]
  |  Branch (278:42): [True: 334, False: 18]
  ------------------
  279|  14.8M|    ++begin;
  280|  14.8M|  }
  281|  1.20k|  if (dropped_nonzero && dropped_nonzero_digit != nullptr) {
  ------------------
  |  Branch (281:7): [True: 334, False: 869]
  |  Branch (281:26): [True: 334, False: 0]
  ------------------
  282|    334|    *dropped_nonzero_digit = true;
  283|    334|  }
  284|  1.20k|  *out = accumulator;
  285|  1.20k|  return static_cast<int>(begin - original_begin);
  286|  1.20k|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_17IsDigitILi10EEEbc:
  183|  14.8M|bool IsDigit<10>(char ch) {
  184|  14.8M|  return ch >= '0' && ch <= '9';
  ------------------
  |  Branch (184:10): [True: 14.8M, False: 771]
  |  Branch (184:23): [True: 14.8M, False: 189]
  ------------------
  185|  14.8M|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_17ToDigitILi10EEEjc:
  192|  17.8k|unsigned ToDigit<10>(char ch) {
  193|  17.8k|  return static_cast<unsigned>(ch - '0');
  194|  17.8k|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_113ConsumeDigitsILi10EiEEiPKcS4_iPT0_Pb:
  250|  3.61k|                  bool* dropped_nonzero_digit) {
  251|  3.61k|  if (base == 10) {
  ------------------
  |  Branch (251:7): [True: 3.61k, Folded]
  ------------------
  252|  3.61k|    assert(max_digits <= std::numeric_limits<T>::digits10);
  253|  3.61k|  } else if (base == 16) {
  ------------------
  |  Branch (253:14): [Folded, False: 0]
  ------------------
  254|      0|    assert(max_digits * 4 <= std::numeric_limits<T>::digits);
  255|      0|  }
  256|  3.61k|  const char* const original_begin = begin;
  257|       |
  258|       |  // Skip leading zeros, but only if *out is zero.
  259|       |  // They don't cause an overflow so we don't have to count them for
  260|       |  // `max_digits`.
  261|  3.88k|  while (!*out && end != begin && *begin == '0') ++begin;
  ------------------
  |  Branch (261:10): [True: 3.88k, False: 0]
  |  Branch (261:19): [True: 3.62k, False: 267]
  |  Branch (261:35): [True: 275, False: 3.34k]
  ------------------
  262|       |
  263|  3.61k|  T accumulator = *out;
  264|  3.61k|  const char* significant_digits_end =
  265|  3.61k|      (end - begin > max_digits) ? begin + max_digits : end;
  ------------------
  |  Branch (265:7): [True: 310, False: 3.30k]
  ------------------
  266|  10.8k|  while (begin < significant_digits_end && IsDigit<base>(*begin)) {
  ------------------
  |  Branch (266:10): [True: 7.26k, False: 3.58k]
  |  Branch (266:44): [True: 7.23k, False: 30]
  ------------------
  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|  7.23k|    auto digit = static_cast<T>(ToDigit<base>(*begin));
  270|  7.23k|    assert(accumulator * base >= accumulator);
  271|  7.23k|    accumulator *= base;
  272|  7.23k|    assert(accumulator + digit >= accumulator);
  273|  7.23k|    accumulator += digit;
  274|  7.23k|    ++begin;
  275|  7.23k|  }
  276|  3.61k|  bool dropped_nonzero = false;
  277|  5.39k|  while (begin < end && IsDigit<base>(*begin)) {
  ------------------
  |  Branch (277:10): [True: 1.82k, False: 3.57k]
  |  Branch (277:25): [True: 1.78k, False: 39]
  ------------------
  278|  1.78k|    dropped_nonzero = dropped_nonzero || (*begin != '0');
  ------------------
  |  Branch (278:23): [True: 1.48k, False: 299]
  |  Branch (278:42): [True: 291, False: 8]
  ------------------
  279|  1.78k|    ++begin;
  280|  1.78k|  }
  281|  3.61k|  if (dropped_nonzero && dropped_nonzero_digit != nullptr) {
  ------------------
  |  Branch (281:7): [True: 291, False: 3.32k]
  |  Branch (281:26): [True: 0, False: 291]
  ------------------
  282|      0|    *dropped_nonzero_digit = true;
  283|      0|  }
  284|  3.61k|  *out = accumulator;
  285|  3.61k|  return static_cast<int>(begin - original_begin);
  286|  3.61k|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_113ConsumeDigitsILi16EmEEiPKcS4_iPT0_Pb:
  250|  4.76k|                  bool* dropped_nonzero_digit) {
  251|  4.76k|  if (base == 10) {
  ------------------
  |  Branch (251:7): [Folded, False: 4.76k]
  ------------------
  252|      0|    assert(max_digits <= std::numeric_limits<T>::digits10);
  253|  4.76k|  } else if (base == 16) {
  ------------------
  |  Branch (253:14): [True: 4.76k, Folded]
  ------------------
  254|  4.76k|    assert(max_digits * 4 <= std::numeric_limits<T>::digits);
  255|  4.76k|  }
  256|  4.76k|  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|  4.76k|  while (!*out && end != begin && *begin == '0') ++begin;
  ------------------
  |  Branch (261:10): [True: 4.32k, False: 440]
  |  Branch (261:19): [True: 4.31k, False: 3]
  |  Branch (261:35): [True: 0, False: 4.31k]
  ------------------
  262|       |
  263|  4.76k|  T accumulator = *out;
  264|  4.76k|  const char* significant_digits_end =
  265|  4.76k|      (end - begin > max_digits) ? begin + max_digits : end;
  ------------------
  |  Branch (265:7): [True: 533, False: 4.22k]
  ------------------
  266|  13.3k|  while (begin < significant_digits_end && IsDigit<base>(*begin)) {
  ------------------
  |  Branch (266:10): [True: 12.6k, False: 739]
  |  Branch (266:44): [True: 8.62k, False: 4.02k]
  ------------------
  267|       |    // Do not guard against *out overflow; max_digits was chosen to avoid this.
  268|       |    // Do assert against it, to detect problems in debug builds.
  269|  8.62k|    auto digit = static_cast<T>(ToDigit<base>(*begin));
  270|  8.62k|    assert(accumulator * base >= accumulator);
  271|  8.62k|    accumulator *= base;
  272|  8.62k|    assert(accumulator + digit >= accumulator);
  273|  8.62k|    accumulator += digit;
  274|  8.62k|    ++begin;
  275|  8.62k|  }
  276|  4.76k|  bool dropped_nonzero = false;
  277|  8.21M|  while (begin < end && IsDigit<base>(*begin)) {
  ------------------
  |  Branch (277:10): [True: 8.20M, False: 616]
  |  Branch (277:25): [True: 8.20M, False: 4.14k]
  ------------------
  278|  8.20M|    dropped_nonzero = dropped_nonzero || (*begin != '0');
  ------------------
  |  Branch (278:23): [True: 8.20M, False: 226]
  |  Branch (278:42): [True: 212, False: 14]
  ------------------
  279|  8.20M|    ++begin;
  280|  8.20M|  }
  281|  4.76k|  if (dropped_nonzero && dropped_nonzero_digit != nullptr) {
  ------------------
  |  Branch (281:7): [True: 212, False: 4.54k]
  |  Branch (281:26): [True: 212, False: 0]
  ------------------
  282|    212|    *dropped_nonzero_digit = true;
  283|    212|  }
  284|  4.76k|  *out = accumulator;
  285|  4.76k|  return static_cast<int>(begin - original_begin);
  286|  4.76k|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_17IsDigitILi16EEEbc:
  187|  8.22M|bool IsDigit<16>(char ch) {
  188|  8.22M|  return kAsciiToInt[static_cast<unsigned char>(ch)] >= 0;
  189|  8.22M|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_17ToDigitILi16EEEjc:
  196|  8.62k|unsigned ToDigit<16>(char ch) {
  197|  8.62k|  return static_cast<unsigned>(kAsciiToInt[static_cast<unsigned char>(ch)]);
  198|  8.62k|}

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

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

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

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

_ZN4absl12lts_2024011619str_format_internal11FILERawSink5WriteENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   42|    996|void FILERawSink::Write(string_view v) {
   43|  1.99k|  while (!v.empty() && !error_) {
  ------------------
  |  Branch (43:10): [True: 996, False: 996]
  |  Branch (43:24): [True: 996, False: 0]
  ------------------
   44|       |    // Reset errno to zero in case the libc implementation doesn't set errno
   45|       |    // when a failure occurs.
   46|    996|    ClearErrnoGuard guard;
   47|       |
   48|    996|    if (size_t result = std::fwrite(v.data(), 1, v.size(), output_)) {
  ------------------
  |  Branch (48:16): [True: 996, False: 0]
  ------------------
   49|       |      // Some progress was made.
   50|    996|      count_ += result;
   51|    996|      v.remove_prefix(result);
   52|    996|    } 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|    996|  }
   68|    996|}
output.cc:_ZN4absl12lts_2024011619str_format_internal12_GLOBAL__N_115ClearErrnoGuardC2Ev:
   26|    996|  ClearErrnoGuard() : old_value(errno) { errno = 0; }
output.cc:_ZN4absl12lts_2024011619str_format_internal12_GLOBAL__N_115ClearErrnoGuardD2Ev:
   27|    996|  ~ClearErrnoGuard() {
   28|    996|    if (!errno) errno = old_value;
  ------------------
  |  Branch (28:9): [True: 996, False: 0]
  ------------------
   29|    996|  }

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

bind.cc:_ZN4absl12lts_2024011619str_format_internal17ParseFormatStringINS1_12_GLOBAL__N_117ConverterConsumerINS3_16DefaultConverterEEEEEbNSt3__117basic_string_viewIcNS7_11char_traitsIcEEEET_:
   57|    996|bool ParseFormatString(string_view src, Consumer consumer) {
   58|    996|  int next_arg = 0;
   59|    996|  const char* p = src.data();
   60|    996|  const char* const end = p + src.size();
   61|    996|  while (p != end) {
  ------------------
  |  Branch (61:10): [True: 996, False: 0]
  ------------------
   62|    996|    const char* percent =
   63|    996|        static_cast<const char*>(memchr(p, '%', static_cast<size_t>(end - p)));
   64|    996|    if (!percent) {
  ------------------
  |  Branch (64:9): [True: 996, False: 0]
  ------------------
   65|       |      // We found the last substring.
   66|    996|      return consumer.Append(string_view(p, static_cast<size_t>(end - p)));
   67|    996|    }
   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|    996|}

_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|  5.18k|bool SimpleAtod(absl::string_view str, absl::Nonnull<double*> out) {
   84|  5.18k|  *out = 0.0;
   85|  5.18k|  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|  5.18k|  if (!str.empty() && str[0] == '+') {
  ------------------
  |  Branch (88:7): [True: 5.17k, False: 2]
  |  Branch (88:23): [True: 80, False: 5.09k]
  ------------------
   89|     80|    str.remove_prefix(1);
   90|     80|    if (!str.empty() && str[0] == '-') {
  ------------------
  |  Branch (90:9): [True: 79, False: 1]
  |  Branch (90:25): [True: 0, False: 79]
  ------------------
   91|      0|      return false;
   92|      0|    }
   93|     80|  }
   94|  5.18k|  auto result = absl::from_chars(str.data(), str.data() + str.size(), *out);
   95|  5.18k|  if (result.ec == std::errc::invalid_argument) {
  ------------------
  |  Branch (95:7): [True: 20, False: 5.16k]
  ------------------
   96|     20|    return false;
   97|     20|  }
   98|  5.16k|  if (result.ptr != str.data() + str.size()) {
  ------------------
  |  Branch (98:7): [True: 295, False: 4.86k]
  ------------------
   99|       |    // not all non-whitespace characters consumed
  100|    295|    return false;
  101|    295|  }
  102|       |  // from_chars() with DR 3081's current wording will return max() on
  103|       |  // overflow.  SimpleAtod returns infinity instead.
  104|  4.86k|  if (result.ec == std::errc::result_out_of_range) {
  ------------------
  |  Branch (104:7): [True: 638, False: 4.22k]
  ------------------
  105|    638|    if (*out > 1.0) {
  ------------------
  |  Branch (105:9): [True: 634, False: 4]
  ------------------
  106|    634|      *out = std::numeric_limits<double>::infinity();
  107|    634|    } else if (*out < -1.0) {
  ------------------
  |  Branch (107:16): [True: 4, False: 0]
  ------------------
  108|      4|      *out = -std::numeric_limits<double>::infinity();
  109|      4|    }
  110|    638|  }
  111|  4.86k|  return true;
  112|  5.16k|}
_ZN4absl12lts_2024011616numbers_internal18safe_strtou64_baseENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPmi:
 1360|     25|                        int base) {
 1361|     25|  return safe_uint_internal<uint64_t>(text, value, base);
 1362|     25|}
numbers.cc:_ZN4absl12lts_2024011612_GLOBAL__N_124safe_parse_sign_and_baseEPNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPiPb:
  923|     25|    absl::Nonnull<bool*> negative_ptr /*output*/) {
  924|     25|  if (text->data() == nullptr) {
  ------------------
  |  Branch (924:7): [True: 0, False: 25]
  ------------------
  925|      0|    return false;
  926|      0|  }
  927|       |
  928|     25|  const char* start = text->data();
  929|     25|  const char* end = start + text->size();
  930|     25|  int base = *base_ptr;
  931|       |
  932|       |  // Consume whitespace.
  933|     25|  while (start < end &&
  ------------------
  |  Branch (933:10): [True: 25, False: 0]
  ------------------
  934|     25|         absl::ascii_isspace(static_cast<unsigned char>(start[0]))) {
  ------------------
  |  Branch (934:10): [True: 0, False: 25]
  ------------------
  935|      0|    ++start;
  936|      0|  }
  937|     25|  while (start < end &&
  ------------------
  |  Branch (937:10): [True: 25, False: 0]
  ------------------
  938|     25|         absl::ascii_isspace(static_cast<unsigned char>(end[-1]))) {
  ------------------
  |  Branch (938:10): [True: 0, False: 25]
  ------------------
  939|      0|    --end;
  940|      0|  }
  941|     25|  if (start >= end) {
  ------------------
  |  Branch (941:7): [True: 0, False: 25]
  ------------------
  942|      0|    return false;
  943|      0|  }
  944|       |
  945|       |  // Consume sign.
  946|     25|  *negative_ptr = (start[0] == '-');
  947|     25|  if (*negative_ptr || start[0] == '+') {
  ------------------
  |  Branch (947:7): [True: 0, False: 25]
  |  Branch (947:24): [True: 0, False: 25]
  ------------------
  948|      0|    ++start;
  949|      0|    if (start >= end) {
  ------------------
  |  Branch (949:9): [True: 0, False: 0]
  ------------------
  950|      0|      return false;
  951|      0|    }
  952|      0|  }
  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|     25|  if (base == 0) {
  ------------------
  |  Branch (958:7): [True: 0, False: 25]
  ------------------
  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|     25|  } else if (base == 16) {
  ------------------
  |  Branch (973:14): [True: 0, False: 25]
  ------------------
  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|     25|  } else if (base >= 2 && base <= 36) {
  ------------------
  |  Branch (982:14): [True: 25, False: 0]
  |  Branch (982:27): [True: 25, False: 0]
  ------------------
  983|       |    // okay
  984|     25|  } else {
  985|      0|    return false;
  986|      0|  }
  987|     25|  *text = absl::string_view(start, static_cast<size_t>(end - start));
  988|     25|  *base_ptr = base;
  989|     25|  return true;
  990|     25|}
numbers.cc:_ZN4absl12lts_2024011612_GLOBAL__N_118safe_uint_internalImEEbNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPT_i:
 1305|     25|                               absl::Nonnull<IntType*> value_p, int base) {
 1306|     25|  *value_p = 0;
 1307|     25|  bool negative;
 1308|     25|  if (!safe_parse_sign_and_base(&text, &base, &negative) || negative) {
  ------------------
  |  Branch (1308:7): [True: 0, False: 25]
  |  Branch (1308:61): [True: 0, False: 25]
  ------------------
 1309|      0|    return false;
 1310|      0|  }
 1311|     25|  return safe_parse_positive_int(text, base, value_p);
 1312|     25|}
numbers.cc:_ZN4absl12lts_2024011612_GLOBAL__N_123safe_parse_positive_intImEEbNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEiPT_:
 1208|     25|                                    absl::Nonnull<IntType*> value_p) {
 1209|     25|  IntType value = 0;
 1210|     25|  const IntType vmax = std::numeric_limits<IntType>::max();
 1211|     25|  assert(vmax > 0);
 1212|     25|  assert(base >= 0);
 1213|     25|  const IntType base_inttype = static_cast<IntType>(base);
 1214|     25|  assert(vmax >= base_inttype);
 1215|     25|  const IntType vmax_over_base = LookupTables<IntType>::kVmaxOverBase[base];
 1216|     25|  assert(base < 2 ||
 1217|     25|         std::numeric_limits<IntType>::max() / base_inttype == vmax_over_base);
 1218|     25|  const char* start = text.data();
 1219|     25|  const char* end = start + text.size();
 1220|       |  // loop over digits
 1221|    161|  for (; start < end; ++start) {
  ------------------
  |  Branch (1221:10): [True: 159, False: 2]
  ------------------
 1222|    159|    unsigned char c = static_cast<unsigned char>(start[0]);
 1223|    159|    IntType digit = static_cast<IntType>(kAsciiToInt[c]);
 1224|    159|    if (digit >= base_inttype) {
  ------------------
  |  Branch (1224:9): [True: 21, False: 138]
  ------------------
 1225|     21|      *value_p = value;
 1226|     21|      return false;
 1227|     21|    }
 1228|    138|    if (value > vmax_over_base) {
  ------------------
  |  Branch (1228:9): [True: 2, False: 136]
  ------------------
 1229|      2|      *value_p = vmax;
 1230|      2|      return false;
 1231|      2|    }
 1232|    136|    value *= base_inttype;
 1233|    136|    if (value > vmax - digit) {
  ------------------
  |  Branch (1233:9): [True: 0, False: 136]
  ------------------
 1234|      0|      *value_p = vmax;
 1235|      0|      return false;
 1236|      0|    }
 1237|    136|    value += digit;
 1238|    136|  }
 1239|      2|  *value_p = value;
 1240|      2|  return true;
 1241|     25|}

_ZN4absl12lts_2024011616numbers_internal16safe_strtoi_baseImEEbNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPT_i:
  354|     25|                                           int base) {
  355|     25|  static_assert(sizeof(*out) == 4 || sizeof(*out) == 8,
  356|     25|                "SimpleAtoi works only with 32-bit or 64-bit integers.");
  357|     25|  static_assert(!std::is_floating_point<int_type>::value,
  358|     25|                "Use SimpleAtof or SimpleAtod instead.");
  359|     25|  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|     25|  constexpr bool kIsSigned = static_cast<int_type>(1) - 2 < 0;
  365|     25|  constexpr bool kUse64Bit = sizeof(*out) == 64 / 8;
  366|     25|  if (kIsSigned) {
  ------------------
  |  Branch (366:7): [Folded, False: 25]
  ------------------
  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|     25|  } else {
  377|     25|    if (kUse64Bit) {
  ------------------
  |  Branch (377:9): [True: 25, Folded]
  ------------------
  378|     25|      uint64_t val;
  379|     25|      parsed = numbers_internal::safe_strtou64_base(s, &val, base);
  380|     25|      *out = static_cast<int_type>(val);
  381|     25|    } 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|     25|  }
  387|     25|  return parsed;
  388|     25|}
_ZN4absl12lts_2024011610SimpleAtoiImEEbNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPT_:
  423|     25|                                     absl::Nonnull<int_type*> out) {
  424|     25|  return numbers_internal::safe_strtoi_base(str, out, 10);
  425|     25|}

_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|    996|  explicit UntypedFormatSpec(string_view s) : spec_(s) {}
_ZN4absl12lts_202401167FPrintFIJEEEiP8_IO_FILERKNS0_19str_format_internal18FormatSpecTemplateIJXspclsr19str_format_internalE14ArgumentToConvIT_EEEEEEDpRKS6_:
  441|    996|            const Args&... args) {
  442|    996|  return str_format_internal::FprintF(
  443|    996|      output, str_format_internal::UntypedFormatSpecImpl::Extract(format),
  444|    996|      {str_format_internal::FormatArgImpl(args)...});
  445|    996|}

_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|  1.13k|inline GraphId InvalidGraphId() {
   59|  1.13k|  return GraphId{0};
   60|  1.13k|}

_ZN4absl12lts_202401165Mutex4LockEv:
 1524|  1.13k|void Mutex::Lock() {
 1525|  1.13k|  ABSL_TSAN_MUTEX_PRE_LOCK(this, 0);
 1526|  1.13k|  GraphId id = DebugOnlyDeadlockCheck(this);
 1527|  1.13k|  intptr_t v = mu_.load(std::memory_order_relaxed);
 1528|       |  // try fast acquire, then spin loop
 1529|  1.13k|  if (ABSL_PREDICT_FALSE((v & (kMuWriter | kMuReader | kMuEvent)) != 0) ||
  ------------------
  |  |  178|  2.27k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 1.13k]
  |  |  |  Branch (178:49): [Folded, False: 1.13k]
  |  |  |  Branch (178:58): [True: 0, False: 1.13k]
  |  |  ------------------
  ------------------
 1530|  1.13k|      ABSL_PREDICT_FALSE(!mu_.compare_exchange_strong(
  ------------------
  |  |  178|  1.13k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 1.13k]
  |  |  |  Branch (178:49): [Folded, False: 1.13k]
  |  |  |  Branch (178:58): [True: 0, False: 1.13k]
  |  |  ------------------
  ------------------
 1531|  1.13k|          v, kMuWriter | v, std::memory_order_acquire,
 1532|  1.13k|          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|  1.13k|  DebugOnlyLockEnter(this, id);
 1539|  1.13k|  ABSL_TSAN_MUTEX_POST_LOCK(this, 0, 0);
 1540|  1.13k|}
_ZN4absl12lts_202401165Mutex6UnlockEv:
 1702|  1.13k|void Mutex::Unlock() {
 1703|  1.13k|  ABSL_TSAN_MUTEX_PRE_UNLOCK(this, 0);
 1704|  1.13k|  DebugOnlyLockLeave(this);
 1705|  1.13k|  intptr_t v = mu_.load(std::memory_order_relaxed);
 1706|       |
 1707|  1.13k|  if (kDebugMode && ((v & (kMuWriter | kMuReader)) != kMuWriter)) {
  ------------------
  |  Branch (1707:7): [Folded, False: 1.13k]
  |  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|  1.13k|  bool should_try_cas = ((v & (kMuEvent | kMuWriter)) == kMuWriter &&
  ------------------
  |  Branch (1714:26): [True: 1.13k, False: 0]
  ------------------
 1715|  1.13k|                         (v & (kMuWait | kMuDesig)) != kMuWait);
  ------------------
  |  Branch (1715:26): [True: 1.13k, 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|  1.13k|  intptr_t x = (v ^ (kMuWriter | kMuWait)) & (kMuWriter | kMuEvent);
 1720|  1.13k|  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|  1.13k|  if (kDebugMode && should_try_cas != (x < y)) {
  ------------------
  |  Branch (1725:7): [Folded, False: 1.13k]
  |  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|  1.13k|  if (x < y && mu_.compare_exchange_strong(v, v & ~(kMuWrWait | kMuWriter),
  ------------------
  |  Branch (1732:7): [True: 1.13k, False: 0]
  |  Branch (1732:16): [True: 1.13k, False: 0]
  ------------------
 1733|  1.13k|                                           std::memory_order_release,
 1734|  1.13k|                                           std::memory_order_relaxed)) {
 1735|       |    // fast writer release (writer with no waiters or with designated waker)
 1736|  1.13k|  } else {
 1737|      0|    this->UnlockSlow(nullptr /*no waitp*/);  // take slow path
 1738|      0|  }
 1739|  1.13k|  ABSL_TSAN_MUTEX_POST_UNLOCK(this, 0);
 1740|  1.13k|}
mutex.cc:_ZN4absl12lts_20240116L22DebugOnlyDeadlockCheckEPNS0_5MutexE:
 1466|  1.13k|static inline GraphId DebugOnlyDeadlockCheck(Mutex* mu) {
 1467|  1.13k|  if (kDebugMode && synch_deadlock_detection.load(std::memory_order_acquire) !=
  ------------------
  |  Branch (1467:7): [Folded, False: 1.13k]
  |  Branch (1467:21): [True: 0, False: 0]
  ------------------
 1468|      0|                        OnDeadlockCycle::kIgnore) {
 1469|      0|    return DeadlockCheck(mu);
 1470|  1.13k|  } else {
 1471|  1.13k|    return InvalidGraphId();
 1472|  1.13k|  }
 1473|  1.13k|}
mutex.cc:_ZN4absl12lts_20240116L18DebugOnlyLockEnterEPNS0_5MutexENS0_24synchronization_internal7GraphIdE:
 1298|  1.13k|static inline void DebugOnlyLockEnter(Mutex* mu, GraphId id) {
 1299|  1.13k|  if (kDebugMode) {
  ------------------
  |  Branch (1299:7): [Folded, False: 1.13k]
  ------------------
 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|  1.13k|}
mutex.cc:_ZN4absl12lts_20240116L18DebugOnlyLockLeaveEPNS0_5MutexE:
 1308|  1.13k|static inline void DebugOnlyLockLeave(Mutex* mu) {
 1309|  1.13k|  if (kDebugMode) {
  ------------------
  |  Branch (1309:7): [Folded, False: 1.13k]
  ------------------
 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|  1.13k|}

_ZN4absl12lts_202401169MutexLockC2EPNS0_5MutexE:
  583|  1.10k|  explicit MutexLock(Mutex* mu) ABSL_EXCLUSIVE_LOCK_FUNCTION(mu) : mu_(mu) {
  584|  1.10k|    this->mu_->Lock();
  585|  1.10k|  }
_ZN4absl12lts_202401169MutexLockD2Ev:
  601|  1.10k|  ~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|  8.90k|Time Now() {
   40|       |  // TODO(bww): Get a timespec instead so we don't have to divide.
   41|  8.90k|  int64_t n = absl::GetCurrentTimeNanos();
   42|  8.90k|  if (n >= 0) {
  ------------------
  |  Branch (42:7): [True: 8.90k, False: 0]
  ------------------
   43|  8.90k|    return time_internal::FromUnixDuration(
   44|  8.90k|        time_internal::MakeDuration(n / 1000000000, n % 1000000000 * 4));
   45|  8.90k|  }
   46|      0|  return time_internal::FromUnixDuration(absl::Nanoseconds(n));
   47|  8.90k|}
_ZN4absl12lts_2024011619GetCurrentTimeNanosEv:
   77|  8.90k|int64_t GetCurrentTimeNanos() { return GET_CURRENT_TIME_NANOS_FROM_SYSTEM(); }
  ------------------
  |  |   71|  8.90k|  ::absl::time_internal::GetCurrentTimeNanosFromSystem()
  ------------------

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

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

_ZN4absl12lts_202401168DurationC2Ev:
  169|  4.45k|  constexpr Duration() : rep_hi_(0), rep_lo_(0) {}  // zero-length duration
_ZN4absl12lts_202401168DurationC2Elj:
  231|  14.3k|  constexpr Duration(int64_t hi, uint32_t lo) : rep_hi_(hi), rep_lo_(lo) {}
_ZN4absl12lts_202401168Duration5HiRepC2El:
  251|  18.8k|          lo_(0),
  252|  18.8k|          hi_(0)
  253|       |#endif
  254|  18.8k|    {
  255|  18.8k|      *this = value;
  256|  18.8k|    }
_ZNK4absl12lts_202401168Duration5HiRep3GetEv:
  258|  33.1k|    constexpr int64_t Get() const {
  259|  33.1k|      const uint64_t unsigned_value =
  260|  33.1k|          (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|  33.1k|      static_assert(
  268|  33.1k|          (static_cast<int64_t>((std::numeric_limits<uint64_t>::max)()) ==
  269|  33.1k|           int64_t{-1}) &&
  270|  33.1k|              (static_cast<int64_t>(static_cast<uint64_t>(
  271|  33.1k|                                        (std::numeric_limits<int64_t>::max)()) +
  272|  33.1k|                                    1) ==
  273|  33.1k|               (std::numeric_limits<int64_t>::min)()),
  274|  33.1k|          "static_cast<int64_t>(uint64_t) does not have c++20 semantics");
  275|  33.1k|      return static_cast<int64_t>(unsigned_value);
  276|  33.1k|    }
_ZN4absl12lts_202401168Duration5HiRepaSEl:
  278|  23.2k|    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|  23.2k|      const auto unsigned_value = static_cast<uint64_t>(value);
  284|  23.2k|      hi_ = static_cast<uint32_t>(unsigned_value >> 32);
  285|  23.2k|      lo_ = static_cast<uint32_t>(unsigned_value);
  286|  23.2k|      return *this;
  287|  23.2k|    }
_ZN4absl12lts_202401164TimeC2ENS0_8DurationE:
  850|  14.3k|  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|  4.45k|                                                        Duration rhs) {
  338|  4.45k|  return lhs -= rhs;
  339|  4.45k|}
_ZN4absl12lts_2024011612ZeroDurationEv:
  416|  4.45k|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr Duration ZeroDuration() {
  417|  4.45k|  return Duration();
  418|  4.45k|}
_ZN4absl12lts_20240116eqENS0_4TimeES1_:
  867|  5.44k|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr bool operator==(Time lhs, Time rhs) {
  868|  5.44k|  return lhs.rep_ == rhs.rep_;
  869|  5.44k|}
_ZN4absl12lts_20240116neENS0_4TimeES1_:
  870|  5.44k|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr bool operator!=(Time lhs, Time rhs) {
  871|  5.44k|  return !(lhs == rhs);
  872|  5.44k|}
_ZN4absl12lts_20240116miENS0_4TimeES1_:
  884|  4.45k|ABSL_ATTRIBUTE_CONST_FUNCTION inline Duration operator-(Time lhs, Time rhs) {
  885|  4.45k|  return lhs.rep_ - rhs.rep_;
  886|  4.45k|}
_ZN4absl12lts_2024011614InfiniteFutureEv:
  907|  5.45k|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr Time InfiniteFuture() {
  908|  5.45k|  return Time(time_internal::MakeDuration((std::numeric_limits<int64_t>::max)(),
  909|  5.45k|                                          ~uint32_t{0}));
  910|  5.45k|}
_ZN4absl12lts_2024011613time_internal12MakeDurationElj:
 1561|  14.3k|                                                              uint32_t lo = 0) {
 1562|  14.3k|  return Duration(hi, lo);
 1563|  14.3k|}
_ZN4absl12lts_2024011613time_internal12MakeDurationEll:
 1566|  8.90k|                                                              int64_t lo) {
 1567|  8.90k|  return MakeDuration(hi, static_cast<uint32_t>(lo));
 1568|  8.90k|}
_ZN4absl12lts_2024011613time_internal8GetRepHiENS0_8DurationE:
 1593|  10.9k|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr int64_t GetRepHi(Duration d) {
 1594|  10.9k|  return d.rep_hi_.Get();
 1595|  10.9k|}
_ZN4absl12lts_2024011613time_internal8GetRepLoENS0_8DurationE:
 1596|  19.8k|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr uint32_t GetRepLo(Duration d) {
 1597|  19.8k|  return d.rep_lo_;
 1598|  19.8k|}
_ZN4absl12lts_2024011613time_internal18IsInfiniteDurationENS0_8DurationE:
 1601|  8.90k|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr bool IsInfiniteDuration(Duration d) {
 1602|  8.90k|  return GetRepLo(d) == ~uint32_t{0};
 1603|  8.90k|}
_ZN4absl12lts_2024011613time_internal16FromUnixDurationENS0_8DurationE:
 1626|  8.90k|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr Time FromUnixDuration(Duration d) {
 1627|  8.90k|  return Time(d);
 1628|  8.90k|}
_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|  5.44k|                                                        Duration rhs) {
 1732|  5.44k|  return time_internal::GetRepHi(lhs) == time_internal::GetRepHi(rhs) &&
  ------------------
  |  Branch (1732:10): [True: 5.44k, False: 0]
  ------------------
 1733|  5.44k|         time_internal::GetRepLo(lhs) == time_internal::GetRepLo(rhs);
  ------------------
  |  Branch (1733:10): [True: 5.44k, False: 0]
  ------------------
 1734|  5.44k|}
_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|  4.45k|    -> decltype(GetDataImpl(c, 0)) {
   51|  4.45k|  return GetDataImpl(c, 0);
   52|  4.45k|}
_ZN4absl12lts_2024011613span_internal11GetDataImplIKNSt3__16vectorIN8fuzztest8internal8IRObjectENS3_9allocatorIS7_EEEEEEDTcldtfp_4dataEERT_c:
   38|  4.45k|    -> decltype(c.data()) {
   39|  4.45k|  return c.data();
   40|  4.45k|}
_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|    996|      : ptr_(array), len_(length) {}
_ZN4absl12lts_202401164SpanIKNS0_19str_format_internal13FormatArgImplEEC2Ev:
  191|    996|  constexpr Span() noexcept : Span(nullptr, 0) {}
_ZN4absl12lts_202401164SpanIKN8fuzztest8internal8IRObjectEEC2INSt3__16vectorIS4_NS8_9allocatorIS4_EEEEvSC_iEERKT_:
  217|  4.45k|      : Span(span_internal::GetData(v), v.size()) {}
_ZN4absl12lts_202401164SpanIKN8fuzztest8internal8IRObjectEEC2EPS5_m:
  193|  4.45k|      : ptr_(array), len_(length) {}
_ZN4absl12lts_202401164SpanIKN8fuzztest8internal8IRObjectEEC2Ev:
  191|      1|  constexpr Span() noexcept : Span(nullptr, 0) {}
_ZNK4absl12lts_202401164SpanIKN8fuzztest8internal8IRObjectEE4sizeEv:
  286|  4.45k|  constexpr size_type size() const noexcept { return len_; }
_ZNK4absl12lts_202401164SpanIKN8fuzztest8internal8IRObjectEE5beginEv:
  336|  4.45k|  constexpr iterator begin() const noexcept { return data(); }
_ZNK4absl12lts_202401164SpanIKN8fuzztest8internal8IRObjectEE4dataEv:
  281|  4.45k|  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|  4.45k|      : AnyBase(std::in_place, std::true_type{},
  170|  4.45k|                new T(std::forward<U>(args)...)) {}
_ZN8fuzztest8internal7AnyBaseC2INSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEENS3_10in_place_tENS3_17integral_constantIbLb1EEEPT_:
   34|  4.45k|  explicit AnyBase(std::in_place_t, std::true_type, T* value) {
   35|  4.45k|    static constexpr VTable kVTable = {type_id<T>, DestroyImpl<T>, CopyImpl<T>};
   36|  4.45k|    vtable_ = &kVTable;
   37|  4.45k|    value_ = const_cast<void*>(static_cast<const void*>(value));
   38|  4.45k|  }
_ZN8fuzztest8internal7AnyBase11DestroyImplINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEEvPv:
  122|  8.90k|  static void DestroyImpl(void* p) {
  123|  8.90k|    delete static_cast<T*>(p);
  124|  8.90k|  }
_ZNR8fuzztest8internal7AnyBase5GetAsINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEERT_v:
   58|  4.45k|  T& GetAs() & {
   59|  4.45k|    FUZZTEST_INTERNAL_CHECK_PRECONDITION(has_value(), "Object is empty!");
  ------------------
  |  |   42|  4.45k|  ((P) ? (void)0                                     \
  |  |  ------------------
  |  |  |  Branch (42:4): [True: 4.45k, False: 0]
  |  |  ------------------
  |  |   43|  4.45k|       : ::fuzztest::internal::Abort(                \
  |  |   44|      0|             __FILE__, __LINE__,                     \
  |  |   45|      0|             absl::StrCat("Failed precondition (", #P, "): ", __VA_ARGS__)))
  ------------------
   60|  4.45k|    FUZZTEST_INTERNAL_CHECK_PRECONDITION(Has<T>(), "Wrong type!");
  ------------------
  |  |   42|  4.45k|  ((P) ? (void)0                                     \
  |  |  ------------------
  |  |  |  Branch (42:4): [True: 4.45k, False: 0]
  |  |  ------------------
  |  |   43|  4.45k|       : ::fuzztest::internal::Abort(                \
  |  |   44|      0|             __FILE__, __LINE__,                     \
  |  |   45|      0|             absl::StrCat("Failed precondition (", #P, "): ", __VA_ARGS__)))
  ------------------
   61|  4.45k|    return *static_cast<T*>(value_);
   62|  4.45k|  }
_ZNK8fuzztest8internal7AnyBase9has_valueEv:
   46|  48.9k|  bool has_value() const {
   47|  48.9k|    FUZZTEST_INTERNAL_CHECK((vtable_ == nullptr) == (value_ == nullptr),
  ------------------
  |  |   48|  48.9k|  ((cond) ? (void)0                                            \
  |  |  ------------------
  |  |  |  Branch (48:4): [True: 48.9k, False: 0]
  |  |  ------------------
  |  |   49|  48.9k|          : ::fuzztest::internal::Abort(                       \
  |  |   50|      0|                __FILE__, __LINE__,                            \
  |  |   51|      0|                absl::StrCat("Internal error! Check (", #cond, \
  |  |   52|      0|                             ") failed: ", __VA_ARGS__)))
  ------------------
   48|  48.9k|                            "Inconsistent state between value and vtable.");
   49|  48.9k|    return value_ != nullptr;
   50|  48.9k|  }
_ZNK8fuzztest8internal7AnyBase3HasINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEEbv:
   53|  13.3k|  bool Has() const {
   54|  13.3k|    return has_value() && vtable_->type_id == type_id<T>;
  ------------------
  |  Branch (54:12): [True: 13.3k, False: 0]
  |  Branch (54:27): [True: 13.3k, False: 0]
  ------------------
   55|  13.3k|  }
_ZNKR8fuzztest8internal7AnyBase5GetAsINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEERKT_v:
   65|  8.90k|  const T& GetAs() const& {
   66|  8.90k|    FUZZTEST_INTERNAL_CHECK_PRECONDITION(has_value(), "Object is empty!");
  ------------------
  |  |   42|  8.90k|  ((P) ? (void)0                                     \
  |  |  ------------------
  |  |  |  Branch (42:4): [True: 8.90k, False: 0]
  |  |  ------------------
  |  |   43|  8.90k|       : ::fuzztest::internal::Abort(                \
  |  |   44|      0|             __FILE__, __LINE__,                     \
  |  |   45|      0|             absl::StrCat("Failed precondition (", #P, "): ", __VA_ARGS__)))
  ------------------
   67|  8.90k|    FUZZTEST_INTERNAL_CHECK_PRECONDITION(Has<T>(), "Wrong type!");
  ------------------
  |  |   42|  8.90k|  ((P) ? (void)0                                     \
  |  |  ------------------
  |  |  |  Branch (42:4): [True: 8.90k, False: 0]
  |  |  ------------------
  |  |   43|  8.90k|       : ::fuzztest::internal::Abort(                \
  |  |   44|      0|             __FILE__, __LINE__,                     \
  |  |   45|      0|             absl::StrCat("Failed precondition (", #P, "): ", __VA_ARGS__)))
  ------------------
   68|  8.90k|    return *static_cast<T*>(value_);
   69|  8.90k|  }
_ZN8fuzztest8internal11CopyableAnyC2EOS1_:
  174|  13.3k|  CopyableAny(CopyableAny&& other) = default;
_ZN8fuzztest8internal7AnyBaseC2EOS1_:
   89|  13.3k|      : vtable_(std::exchange(other.vtable_, nullptr)),
   90|  13.3k|        value_(std::exchange(other.value_, nullptr)) {}
_ZN8fuzztest8internal7AnyBaseD2Ev:
  100|  22.2k|  ~AnyBase() { Destroy(); }
_ZN8fuzztest8internal7AnyBase7DestroyEv:
  102|  22.2k|  void Destroy() {
  103|  22.2k|    if (has_value()) vtable_->destroy(value_);
  ------------------
  |  Branch (103:9): [True: 8.90k, False: 13.3k]
  ------------------
  104|  22.2k|  }
_ZN8fuzztest8internal11MoveOnlyAnyC2INSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEJSB_EEENS3_15in_place_type_tIT_EEDpOT0_:
  150|  4.45k|      : AnyBase(std::in_place, std::false_type{},
  151|  4.45k|                new T(std::forward<U>(args)...)) {}
_ZN8fuzztest8internal7AnyBaseC2INSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEENS3_10in_place_tENS3_17integral_constantIbLb0EEEPT_:
   40|  4.45k|  explicit AnyBase(std::in_place_t, std::false_type, T* value) {
   41|  4.45k|    static constexpr VTable kVTable = {type_id<T>, DestroyImpl<T>, nullptr};
   42|  4.45k|    vtable_ = &kVTable;
   43|  4.45k|    value_ = const_cast<void*>(static_cast<const void*>(value));
   44|  4.45k|  }

_ZN8fuzztest8internal25SetExternalEngineCallbackEPNS0_22ExternalEngineCallbackE:
   33|      2|void SetExternalEngineCallback(ExternalEngineCallback* callback) {
   34|      2|  external_engine_callback = callback;
   35|      2|}
_ZN8fuzztest8internal25GetExternalEngineCallbackEv:
   37|  5.45k|ExternalEngineCallback* GetExternalEngineCallback() {
   38|  5.45k|  return external_engine_callback;
   39|  5.45k|}
_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|  5.44k|void FuzzTestExternalEngineAdaptor::RunOneInputData(absl::string_view data) {
  118|  5.44k|  auto& impl = GetFuzzerImpl();
  119|  5.44k|  if (impl.ShouldStop()) {
  ------------------
  |  Branch (119:7): [True: 0, False: 5.44k]
  ------------------
  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|  5.44k|  runtime_.SetCurrentTest(&impl.test_, nullptr);
  128|  5.44k|  if (data.size() == 0) return;
  ------------------
  |  Branch (128:7): [True: 0, False: 5.44k]
  ------------------
  129|  5.44k|  auto input = impl.TryParse(data);
  130|  5.44k|  if (!input) return;
  ------------------
  |  Branch (130:7): [True: 996, False: 4.45k]
  ------------------
  131|  4.45k|  impl.RunOneInput({*std::move(input)});
  132|  4.45k|}
_ZN8fuzztest8internal29FuzzTestExternalEngineAdaptor13GetFuzzerImplEv:
  160|  5.45k|FuzzTestExternalEngineAdaptor::GetFuzzerImpl() {
  161|       |  // Postpone the creation to override libFuzzer signal setup.
  162|  5.45k|  if (!fuzzer_impl_) {
  ------------------
  |  Branch (162:7): [True: 2, False: 5.44k]
  ------------------
  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|  5.45k|  return *fuzzer_impl_;
  168|  5.45k|}
compatibility_mode.cc:_ZZN8fuzztest8internal29FuzzTestExternalEngineAdaptor16RunInFuzzingModeEPiPPPcRKNS0_13ConfigurationEENK3$_1clEPKhm:
   92|  5.44k|  LLVMFuzzerRunDriver(argc, argv, [](const uint8_t* data, size_t size) -> int {
   93|  5.44k|    GetExternalEngineCallback()->RunOneInputData(
   94|  5.44k|        absl::string_view(reinterpret_cast<const char*>(data), size));
   95|  5.44k|    return 0;
   96|  5.44k|  });

_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|  4.45k|  absl::Status ValidateCorpusValue(const corpus_type& corpus_value) const {
  167|  4.45k|    absl::Status result = absl::OkStatus();
  168|  4.45k|    ApplyIndex<sizeof...(Inner)>([&](auto... I) {
  169|  4.45k|      (
  170|  4.45k|          [&] {
  171|  4.45k|            if (!result.ok()) return;
  172|  4.45k|            const absl::Status s = std::get<I>(inner_).ValidateCorpusValue(
  173|  4.45k|                std::get<I>(corpus_value));
  174|  4.45k|            result = Prefix(s, "Invalid value in aggregate");
  175|  4.45k|          }(),
  176|  4.45k|          ...);
  177|  4.45k|    });
  178|  4.45k|    return result;
  179|  4.45k|  }
_ZZNK8fuzztest8internal15AggregateOfImplINSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplIS9_NS0_13ArbitraryImplIcvEEEEEE19ValidateCorpusValueERKSA_ENKUlDpT_E_clIJNS2_17integral_constantImLm0EEEEEEDaSK_:
  168|  4.45k|    ApplyIndex<sizeof...(Inner)>([&](auto... I) {
  169|  4.45k|      (
  170|  4.45k|          [&] {
  171|  4.45k|            if (!result.ok()) return;
  172|  4.45k|            const absl::Status s = std::get<I>(inner_).ValidateCorpusValue(
  173|  4.45k|                std::get<I>(corpus_value));
  174|  4.45k|            result = Prefix(s, "Invalid value in aggregate");
  175|  4.45k|          }(),
  176|  4.45k|          ...);
  177|  4.45k|    });
_ZZZNK8fuzztest8internal15AggregateOfImplINSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplIS9_NS0_13ArbitraryImplIcvEEEEEE19ValidateCorpusValueERKSA_ENKUlDpT_E_clIJNS2_17integral_constantImLm0EEEEEEDaSK_ENKUlvE_clEv:
  170|  4.45k|          [&] {
  171|  4.45k|            if (!result.ok()) return;
  ------------------
  |  Branch (171:17): [True: 0, False: 4.45k]
  ------------------
  172|  4.45k|            const absl::Status s = std::get<I>(inner_).ValidateCorpusValue(
  173|  4.45k|                std::get<I>(corpus_value));
  174|  4.45k|            result = Prefix(s, "Invalid value in aggregate");
  175|  4.45k|          }(),
_ZNK8fuzztest8internal15AggregateOfImplINSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplIS9_NS0_13ArbitraryImplIcvEEEEEE11ParseCorpusERKNS0_8IRObjectE:
  150|  4.66k|  std::optional<corpus_type> ParseCorpus(const IRObject& obj) const {
  151|       |    if constexpr (has_custom_corpus_type) {
  152|       |      return ParseWithDomainTuple(inner_, obj);
  153|  4.66k|    } else {
  154|  4.66k|      return obj.ToCorpus<corpus_type>();
  155|  4.66k|    }
  156|  4.66k|  }
_ZNK8fuzztest8internal15AggregateOfImplINSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplIS9_NS0_13ArbitraryImplIcvEEEEEE8GetValueERKSA_:
  108|  4.45k|  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|  4.45k|    } else {
  125|  4.45k|      return value;
  126|  4.45k|    }
  127|  4.45k|  }
_ZN8fuzztest8internal15AggregateOfImplINSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplIS9_NS0_13ArbitraryImplIcvEEEEEEC2ENS2_10in_place_tESF_:
   58|      2|      : inner_(std::move(inner)...) {}

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

_ZNK8fuzztest8internal19ContainerOfImplBaseINS0_23SequenceContainerOfImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_13ArbitraryImplIcvEEEEE19ValidateCorpusValueERKS9_:
  319|  4.45k|  absl::Status ValidateCorpusValue(const corpus_type& corpus_value) const {
  320|       |    // Check size.
  321|  4.45k|    if (corpus_value.size() < min_size()) {
  ------------------
  |  Branch (321:9): [True: 0, False: 4.45k]
  ------------------
  322|      0|      return absl::InvalidArgumentError(absl::StrCat(
  323|      0|          "Invalid size: ", corpus_value.size(), ". Min size: ", min_size()));
  324|      0|    }
  325|  4.45k|    if (corpus_value.size() > max_size()) {
  ------------------
  |  Branch (325:9): [True: 0, False: 4.45k]
  ------------------
  326|      0|      return absl::InvalidArgumentError(absl::StrCat(
  327|      0|          "Invalid size: ", corpus_value.size(), ". Max size: ", max_size()));
  328|      0|    }
  329|       |    // Check elements.
  330|  4.45k|    int i = 0;
  331|  25.9M|    for (const auto& elem : corpus_value) {
  ------------------
  |  Branch (331:27): [True: 25.9M, False: 4.45k]
  ------------------
  332|  25.9M|      const absl::Status s = inner_.ValidateCorpusValue(elem);
  333|  25.9M|      if (!s.ok()) {
  ------------------
  |  Branch (333:11): [True: 0, False: 25.9M]
  ------------------
  334|      0|        return Prefix(s,
  335|      0|                      absl::StrCat("Invalid value in container at index ", i));
  336|      0|      }
  337|  25.9M|      i++;
  338|  25.9M|    }
  339|  4.45k|    return absl::OkStatus();
  340|  4.45k|  }
_ZNK8fuzztest8internal19ContainerOfImplBaseINS0_23SequenceContainerOfImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_13ArbitraryImplIcvEEEEE8min_sizeEv:
  371|  4.45k|  size_t min_size() const { return min_size_; }
_ZNK8fuzztest8internal19ContainerOfImplBaseINS0_23SequenceContainerOfImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_13ArbitraryImplIcvEEEEE8max_sizeEv:
  372|  4.45k|  size_t max_size() const {
  373|  4.45k|    return max_size_.value_or(std::max(min_size_, kDefaultContainerMaxSize));
  374|  4.45k|  }
_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|  4.45k|  value_type GetValue(const corpus_type& corpus_value) const {
  311|  4.45k|    return inner_->UntypedGetValue(corpus_value);
  312|  4.45k|  }
_ZNK8fuzztest13UntypedDomain11ParseCorpusERKNS_8internal8IRObjectE:
  314|  4.66k|  std::optional<corpus_type> ParseCorpus(const internal::IRObject& obj) const {
  315|  4.66k|    return inner_->UntypedParseCorpus(obj);
  316|  4.66k|  }
_ZNK8fuzztest13UntypedDomain19ValidateCorpusValueERKNS_8internal11CopyableAnyE:
  322|  4.45k|  absl::Status ValidateCorpusValue(const corpus_type& corpus_value) const {
  323|  4.45k|    return inner_->UntypedValidateCorpusValue(corpus_value);
  324|  4.45k|  }

_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|  4.66k|      const IRObject& obj) const final {
  166|  4.66k|    if (auto res = domain_.ParseCorpus(obj)) {
  ------------------
  |  Branch (166:14): [True: 4.45k, False: 209]
  ------------------
  167|  4.45k|      return GenericDomainCorpusType(std::in_place_type<CorpusType>,
  168|  4.45k|                                     *std::move(res));
  169|  4.45k|    } else {
  170|    209|      return std::nullopt;
  171|    209|    }
  172|  4.66k|  }
_ZNK8fuzztest8internal11DomainModelINS0_15AggregateOfImplINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplISA_NS0_13ArbitraryImplIcvEEEEEEEE26UntypedValidateCorpusValueERKNS0_11CopyableAnyE:
  180|  4.45k|      const GenericDomainCorpusType& corpus_value) const final {
  181|  4.45k|    return domain_.ValidateCorpusValue(corpus_value.GetAs<CorpusType>());
  182|  4.45k|  }
_ZNK8fuzztest8internal18TypedDomainConceptINSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEE15UntypedGetValueERKNS0_11CopyableAnyE:
  109|  4.45k|      const GenericDomainCorpusType& v) const final {
  110|  4.45k|    return GenericDomainValueType(std::in_place_type<ValueType>,
  111|  4.45k|                                  TypedGetValue(v));
  112|  4.45k|  }
_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|  4.45k|  ValueType TypedGetValue(const GenericDomainCorpusType& v) const final {
  151|  4.45k|    return domain_.GetValue(v.GetAs<CorpusType>());
  152|  4.45k|  }

_ZN8fuzztest8internal20UntypedFixtureDriver13SetUpFuzzTestEv:
   20|      2|void UntypedFixtureDriver::SetUpFuzzTest() {}
_ZN8fuzztest8internal20UntypedFixtureDriver14SetUpIterationEv:
   21|  4.45k|void UntypedFixtureDriver::SetUpIteration() {}
_ZN8fuzztest8internal20UntypedFixtureDriver17TearDownIterationEv:
   22|  4.45k|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|  4.45k|  void Test(MoveOnlyAny&& args_untyped) const override {
  292|  4.45k|    std::apply(
  293|  4.45k|        [&](auto&&... args) {
  294|  4.45k|          target_function_(ForceVectorForStringView<Args>(std::move(args))...);
  295|  4.45k|        },
  296|  4.45k|        args_untyped.GetAs<value_type_t<DomainT>>());
  297|  4.45k|  }
_ZZNK8fuzztest8internal13FixtureDriverINS_6DomainINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEENS0_9NoFixtureEPFvNS3_17basic_string_viewIcS7_EEEPvE4TestEONS0_11MoveOnlyAnyEENKUlDpOT_E_clIJRSA_EEEDaSO_:
  293|  4.45k|        [&](auto&&... args) {
  294|  4.45k|          target_function_(ForceVectorForStringView<Args>(std::move(args))...);
  295|  4.45k|        },
_ZN8fuzztest8internal24ForceVectorForStringViewINSt3__117basic_string_viewIcNS2_11char_traitsIcEEEENS2_12basic_stringIcS5_NS2_9allocatorIcEEEEEEDcOT0_:
  181|  4.45k|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|  4.45k|                               void(std::string_view, std::string)>) {
  186|  4.45k|    return ForceVector{std::vector<char>(src.begin(), src.end())};
  187|       |  } else {
  188|       |    return std::forward<Src>(src);
  189|       |  }
  190|  4.45k|}
_ZNK8fuzztest8internal11ForceVectorcvNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEEv:
  176|  4.45k|  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|    998|FILE* GetStderr() {
  126|    998|  absl::MutexLock lock(&stderr_file_guard_);
  127|    998|  if (!stderr_file_) {
  ------------------
  |  Branch (127:7): [True: 2, False: 996]
  ------------------
  128|       |    stderr_file_ = stderr;
  129|      2|  }
  130|    998|  return stderr_file_;
  131|    998|}

_ZN8fuzztest8internal10ApplyIndexILm1EZNKS0_15AggregateOfImplINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplISA_NS0_13ArbitraryImplIcvEEEEEE19ValidateCorpusValueERKSB_EUlDpT_E_EEDaT0_:
   54|  4.45k|constexpr auto ApplyIndex(F f) {
   55|  4.45k|  return ApplyIndexImpl(f, std::make_index_sequence<N>{});
   56|  4.45k|}
_ZN8fuzztest8internal14ApplyIndexImplIJLm0EEZNKS0_15AggregateOfImplINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplISA_NS0_13ArbitraryImplIcvEEEEEE19ValidateCorpusValueERKSB_EUlDpT_E_EEDaT0_NS3_16integer_sequenceImJXspT_EEEE:
   39|  4.45k|constexpr auto ApplyIndexImpl(F f, std::index_sequence<I...>) {
   40|  4.45k|  return f(std::integral_constant<size_t, I>{}...);
   41|  4.45k|}
_ZN8fuzztest8internal10ApplyIndexILm1EZNKS0_8IRObject8ToCorpusINSt3__15tupleIJNS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEEEENS4_8optionalIT_EEvEUlDpT_E_EEDaT0_:
   54|  4.45k|constexpr auto ApplyIndex(F f) {
   55|  4.45k|  return ApplyIndexImpl(f, std::make_index_sequence<N>{});
   56|  4.45k|}
_ZN8fuzztest8internal14ApplyIndexImplIJLm0EEZNKS0_8IRObject8ToCorpusINSt3__15tupleIJNS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEEEENS4_8optionalIT_EEvEUlDpT_E_EEDaT0_NS4_16integer_sequenceImJXspT_EEEE:
   39|  4.45k|constexpr auto ApplyIndexImpl(F f, std::index_sequence<I...>) {
   40|  4.45k|  return f(std::integral_constant<size_t, I>{}...);
   41|  4.45k|}
_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|  4.45k|void Runtime::CheckWatchdogLimits() {
  259|       |  // Centipede runner has its own watchdog.
  260|  4.45k|#ifndef FUZZTEST_USE_CENTIPEDE
  261|  4.45k|  if (current_configuration_ == nullptr) return;
  ------------------
  |  Branch (261:7): [True: 4.45k, 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|  4.45k|void Runtime::OnTestIterationEnd() {
  284|  4.45k|  test_iteration_started_ = false;
  285|  4.45k|  while (watchdog_spinlock_.test_and_set()) std::this_thread::yield();
  ------------------
  |  Branch (285:10): [True: 0, False: 4.45k]
  ------------------
  286|  4.45k|  CheckWatchdogLimits();
  287|  4.45k|  watchdog_spinlock_.clear();
  288|  4.45k|}
_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|  5.44k|    absl::string_view data) {
  467|  5.44k|  auto ir_value = IRObject::FromString(data);
  468|  5.44k|  if (!ir_value) {
  ------------------
  |  Branch (468:7): [True: 787, False: 4.66k]
  ------------------
  469|    787|    absl::FPrintF(GetStderr(), "[!] Unexpected file format.\n");
  470|    787|    return std::nullopt;
  471|    787|  }
  472|  4.66k|  auto corpus_value = params_domain_.ParseCorpus(*ir_value);
  473|  4.66k|  if (!corpus_value) {
  ------------------
  |  Branch (473:7): [True: 209, False: 4.45k]
  ------------------
  474|    209|    absl::FPrintF(GetStderr(), "[!] Unexpected intermediate representation.\n");
  475|    209|    return std::nullopt;
  476|    209|  }
  477|       |
  478|  4.45k|  absl::Status is_valid = params_domain_.ValidateCorpusValue(*corpus_value);
  479|  4.45k|  if (!is_valid.ok()) {
  ------------------
  |  Branch (479:7): [True: 0, False: 4.45k]
  ------------------
  480|      0|    absl::FPrintF(GetStderr(), "[!] Invalid corpus value: %s\n",
  481|      0|                  is_valid.ToString());
  482|      0|    return std::nullopt;
  483|      0|  }
  484|  4.45k|  return corpus_value;
  485|  4.45k|}
_ZN8fuzztest8internal18FuzzTestFuzzerImpl10ShouldStopEv:
  775|  5.44k|bool FuzzTestFuzzerImpl::ShouldStop() {
  776|  5.44k|  if (runs_limit_.has_value() && stats_.runs >= *runs_limit_) return true;
  ------------------
  |  Branch (776:7): [True: 0, False: 5.44k]
  |  Branch (776:34): [True: 0, False: 0]
  ------------------
  777|  5.44k|  if (time_limit_ != absl::InfiniteFuture() && absl::Now() > time_limit_)
  ------------------
  |  Branch (777:7): [True: 0, False: 5.44k]
  |  Branch (777:48): [True: 0, False: 0]
  ------------------
  778|      0|    return true;
  779|  5.44k|  return runtime_.termination_requested();
  780|  5.44k|}
_ZN8fuzztest8internal18FuzzTestFuzzerImpl11RunOneInputERKNS1_5InputE:
  905|  4.45k|    const Input& input) {
  906|  4.45k|  ++stats_.runs;
  907|  4.45k|  auto untyped_args = params_domain_.GetValue(input.args);
  908|  4.45k|  Runtime::Args debug_args{input.args, params_domain_};
  909|  4.45k|  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|  4.45k|  if (execution_coverage_ != nullptr) {
  ------------------
  |  Branch (914:7): [True: 0, False: 4.45k]
  ------------------
  915|      0|    execution_coverage_->ResetState();
  916|      0|  }
  917|  4.45k|  absl::Time start = absl::Now();
  918|  4.45k|  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|  4.45k|  if (execution_coverage_ != nullptr) {
  ------------------
  |  Branch (922:7): [True: 0, False: 4.45k]
  ------------------
  923|      0|    execution_coverage_->SetIsTracing(true);
  924|      0|  }
  925|       |
  926|  4.45k|  fixture_driver_->SetUpIteration();
  927|  4.45k|  fixture_driver_->Test(std::move(untyped_args));
  928|  4.45k|  fixture_driver_->TearDownIteration();
  929|  4.45k|  if (execution_coverage_ != nullptr) {
  ------------------
  |  Branch (929:7): [True: 0, False: 4.45k]
  ------------------
  930|      0|    execution_coverage_->SetIsTracing(false);
  931|      0|  }
  932|  4.45k|  const absl::Duration run_time = absl::Now() - start;
  933|       |
  934|  4.45k|  bool new_coverage = false;
  935|  4.45k|  if (execution_coverage_ != nullptr) {
  ------------------
  |  Branch (935:7): [True: 0, False: 4.45k]
  ------------------
  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|  4.45k|  runtime_.OnTestIterationEnd();
  942|  4.45k|  runtime_.UnsetCurrentArgs();
  943|  4.45k|  return {new_coverage, run_time};
  944|  4.45k|}
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|  5.44k|  bool termination_requested() const {
  142|  5.44k|    return termination_requested_.load(std::memory_order_relaxed);
  143|  5.44k|  }
_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|  5.44k|                      const Configuration* configuration) {
  166|  5.44k|    current_test_ = test;
  167|  5.44k|    current_configuration_ = configuration;
  168|  5.44k|  }
_ZN8fuzztest8internal7Runtime20OnTestIterationStartERKN4absl12lts_202401164TimeE:
  169|  4.45k|  void OnTestIterationStart(const absl::Time& start_time) {
  170|  4.45k|    current_iteration_start_time_ = start_time;
  171|  4.45k|    test_iteration_started_ = true;
  172|  4.45k|  }
_ZN8fuzztest8internal7Runtime14SetCurrentArgsEPNS1_4ArgsE:
  175|  4.45k|  void SetCurrentArgs(Args* args) { current_args_ = args; }
_ZN8fuzztest8internal7Runtime16UnsetCurrentArgsEv:
  176|  4.45k|  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|  5.44k|std::optional<IRObject> IRObject::FromString(absl::string_view str) {
  332|  5.44k|  IRObject object;
  333|  5.44k|  if (IsInBinaryFormat(str)) {
  ------------------
  |  Branch (333:7): [True: 4.52k, False: 927]
  ------------------
  334|  4.52k|    BinaryParseBuf buf = {str.data(), str.size()};
  335|  4.52k|    buf.Advance(kBinaryHeader.size());
  336|  4.52k|    if (!BinaryParse(object, buf, /*recursion_depth=*/0) || !buf.empty())
  ------------------
  |  Branch (336:9): [True: 46, False: 4.47k]
  |  Branch (336:61): [True: 17, False: 4.45k]
  ------------------
  337|     63|      return std::nullopt;
  338|  4.52k|  } else {
  339|    927|    if (ReadToken(str) != kHeader) return std::nullopt;
  ------------------
  |  Branch (339:9): [True: 78, False: 849]
  ------------------
  340|    849|    if (!ParseImpl(object, str, /*recursion_depth=*/0) ||
  ------------------
  |  Branch (340:9): [True: 428, False: 421]
  |  Branch (340:9): [True: 646, False: 203]
  ------------------
  341|    421|        !ReadToken(str).empty())
  ------------------
  |  Branch (341:9): [True: 218, False: 203]
  ------------------
  342|    646|      return std::nullopt;
  343|    849|  }
  344|  4.66k|  return object;
  345|  5.44k|}
serialization.cc:_ZN8fuzztest8internal12_GLOBAL__N_116IsInBinaryFormatENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
  302|  5.44k|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|  5.44k|  return str.size() >= kBinaryHeader.size() &&
  ------------------
  |  Branch (305:10): [True: 5.44k, False: 8]
  ------------------
  306|  5.44k|         __builtin_memcmp(str.data(), kBinaryHeader.data(),
  ------------------
  |  Branch (306:10): [True: 4.52k, False: 919]
  ------------------
  307|  5.44k|                          kBinaryHeader.size()) == 0;
  308|  5.44k|}
serialization.cc:_ZN8fuzztest8internal12_GLOBAL__N_114BinaryParseBuf7AdvanceEm:
  242|  30.5k|  inline void Advance(size_t s) {
  243|  30.5k|    if (s > size) s = size;
  ------------------
  |  Branch (243:9): [True: 0, False: 30.5k]
  ------------------
  244|  30.5k|    str += s;
  245|  30.5k|    size -= s;
  246|  30.5k|  }
serialization.cc:_ZN8fuzztest8internal12_GLOBAL__N_111BinaryParseERNS0_8IRObjectERNS1_14BinaryParseBufEi:
  249|  10.8k|bool BinaryParse(IRObject& obj, BinaryParseBuf& buf, int recursion_depth) {
  250|  10.8k|  if (recursion_depth > kMaxParseRecursionDepth) return false;
  ------------------
  |  Branch (250:7): [True: 1, False: 10.8k]
  ------------------
  251|  10.8k|  if (buf.empty()) return false;
  ------------------
  |  Branch (251:7): [True: 3, False: 10.8k]
  ------------------
  252|  10.8k|  const auto h = static_cast<BinaryFormatHeader>(buf.str[0]);
  253|  10.8k|  buf.Advance(1);
  254|  10.8k|  switch (h) {
  ------------------
  |  Branch (254:11): [True: 10.8k, False: 15]
  ------------------
  255|    133|    case BinaryFormatHeader::kEmpty: {
  ------------------
  |  Branch (255:5): [True: 133, False: 10.6k]
  ------------------
  256|    133|      return true;
  257|      0|    }
  258|    141|    case BinaryFormatHeader::kUInt64: {
  ------------------
  |  Branch (258:5): [True: 141, False: 10.6k]
  ------------------
  259|    141|      if (buf.size < sizeof(uint64_t)) return false;
  ------------------
  |  Branch (259:11): [True: 1, False: 140]
  ------------------
  260|    140|      auto& t = obj.value.emplace<uint64_t>();
  261|    140|      std::memcpy(&t, buf.str, sizeof(uint64_t));
  262|    140|      buf.Advance(sizeof(uint64_t));
  263|    140|      return true;
  264|    141|    }
  265|      2|    case BinaryFormatHeader::kDouble: {
  ------------------
  |  Branch (265:5): [True: 2, False: 10.8k]
  ------------------
  266|      2|      if (buf.size < sizeof(double)) return false;
  ------------------
  |  Branch (266:11): [True: 0, False: 2]
  ------------------
  267|      2|      auto& t = obj.value.emplace<double>();
  268|      2|      std::memcpy(&t, buf.str, sizeof(t));
  269|      2|      buf.Advance(sizeof(double));
  270|      2|      return true;
  271|      2|    }
  272|  4.50k|    case BinaryFormatHeader::kString: {
  ------------------
  |  Branch (272:5): [True: 4.50k, False: 6.32k]
  ------------------
  273|  4.50k|      if (buf.size < sizeof(uint64_t)) return false;
  ------------------
  |  Branch (273:11): [True: 0, False: 4.50k]
  ------------------
  274|  4.50k|      uint64_t str_size;
  275|  4.50k|      std::memcpy(&str_size, buf.str, sizeof(str_size));
  276|  4.50k|      buf.Advance(sizeof(uint64_t));
  277|  4.50k|      if (buf.size < str_size) return false;
  ------------------
  |  Branch (277:11): [True: 6, False: 4.50k]
  ------------------
  278|  4.50k|      obj.value.emplace<std::string>() = {buf.str,
  279|  4.50k|                                          static_cast<size_t>(str_size)};
  280|  4.50k|      buf.Advance(str_size);
  281|  4.50k|      return true;
  282|  4.50k|    }
  283|  6.03k|    case BinaryFormatHeader::kObject: {
  ------------------
  |  Branch (283:5): [True: 6.03k, False: 4.79k]
  ------------------
  284|  6.03k|      if (buf.size < sizeof(uint64_t)) return false;
  ------------------
  |  Branch (284:11): [True: 1, False: 6.02k]
  ------------------
  285|  6.02k|      uint64_t vec_size;
  286|  6.02k|      std::memcpy(&vec_size, buf.str, sizeof(vec_size));
  287|  6.02k|      buf.Advance(sizeof(vec_size));
  288|       |      // This could happen for malformed inputs.
  289|  6.02k|      if (vec_size > buf.size) return false;
  ------------------
  |  Branch (289:11): [True: 19, False: 6.01k]
  ------------------
  290|  6.01k|      auto& v = obj.value.emplace<std::vector<IRObject>>();
  291|  6.01k|      v.reserve(vec_size);
  292|  11.0k|      for (uint64_t i = 0; i < vec_size; ++i) {
  ------------------
  |  Branch (292:28): [True: 6.31k, False: 4.70k]
  ------------------
  293|  6.31k|        if (!BinaryParse(v.emplace_back(), buf, recursion_depth + 1))
  ------------------
  |  Branch (293:13): [True: 1.31k, False: 5.00k]
  ------------------
  294|  1.31k|          return false;
  295|  6.31k|      }
  296|  4.70k|      return true;
  297|  6.01k|    }
  298|  10.8k|  }
  299|     15|  return false;
  300|  10.8k|}
serialization.cc:_ZNK8fuzztest8internal12_GLOBAL__N_114BinaryParseBuf5emptyEv:
  241|  15.3k|  inline bool empty() const { return size == 0; }
serialization.cc:_ZN8fuzztest8internal12_GLOBAL__N_19ReadTokenERNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
   78|  30.6k|absl::string_view ReadToken(absl::string_view& in) {
   79|  31.5k|  while (!in.empty() && std::isspace(in[0])) in.remove_prefix(1);
  ------------------
  |  Branch (79:10): [True: 31.2k, False: 268]
  |  Branch (79:25): [True: 888, False: 30.3k]
  ------------------
   80|  30.6k|  if (in.empty()) return in;
  ------------------
  |  Branch (80:7): [True: 268, False: 30.3k]
  ------------------
   81|  30.3k|  size_t end = 1;
   82|  30.3k|  const auto is_literal = [](char c) {
   83|  30.3k|    return std::isalnum(c) != 0 || c == '+' || c == '-' || c == '.';
   84|  30.3k|  };
   85|  30.3k|  if (is_literal(in[0])) {
  ------------------
  |  Branch (85:7): [True: 15.9k, False: 14.4k]
  ------------------
   86|  40.5M|    while (end < in.size() && is_literal(in[end])) ++end;
  ------------------
  |  Branch (86:12): [True: 40.5M, False: 411]
  |  Branch (86:31): [True: 40.5M, False: 15.5k]
  ------------------
   87|  15.9k|  } else if (in[0] == '"') {
  ------------------
  |  Branch (87:14): [True: 1, False: 14.4k]
  ------------------
   88|     10|    while (end < in.size() && in[end] != '"') ++end;
  ------------------
  |  Branch (88:12): [True: 9, False: 1]
  |  Branch (88:31): [True: 9, False: 0]
  ------------------
   89|      1|    if (end < in.size()) ++end;
  ------------------
  |  Branch (89:9): [True: 0, False: 1]
  ------------------
   90|      1|  }
   91|  30.3k|  absl::string_view res = in.substr(0, end);
   92|  30.3k|  in.remove_prefix(end);
   93|  30.3k|  return res;
   94|  30.6k|}
serialization.cc:_ZZN8fuzztest8internal12_GLOBAL__N_19ReadTokenERNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEENK3$_0clEc:
   82|  40.5M|  const auto is_literal = [](char c) {
   83|  40.5M|    return std::isalnum(c) != 0 || c == '+' || c == '-' || c == '.';
  ------------------
  |  Branch (83:12): [True: 40.4M, False: 152k]
  |  Branch (83:36): [True: 3.73k, False: 148k]
  |  Branch (83:48): [True: 117k, False: 30.7k]
  |  Branch (83:60): [True: 825, False: 29.9k]
  ------------------
   84|  40.5M|  };
serialization.cc:_ZN8fuzztest8internal12_GLOBAL__N_19ParseImplERNS0_8IRObjectERNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEi:
  136|  5.42k|bool ParseImpl(IRObject& obj, absl::string_view& str, int recursion_depth) {
  137|  5.42k|  if (recursion_depth > kMaxParseRecursionDepth) return false;
  ------------------
  |  Branch (137:7): [True: 0, False: 5.42k]
  ------------------
  138|  5.42k|  absl::string_view key = ReadToken(str);
  139|  5.42k|  if (key.empty() || key == "}") {
  ------------------
  |  Branch (139:7): [True: 2, False: 5.42k]
  |  Branch (139:22): [True: 0, False: 5.42k]
  ------------------
  140|       |    // The object is empty. Put the token back and return.
  141|      2|    str = absl::string_view(key.data(), str.data() + str.size() - key.data());
  142|      2|    return true;
  143|      2|  }
  144|       |
  145|  5.42k|  if (key == "sub") {
  ------------------
  |  Branch (145:7): [True: 210, False: 5.21k]
  ------------------
  146|    210|    auto& v = obj.value.emplace<std::vector<IRObject>>();
  147|  4.58k|    do {
  148|  4.58k|      if (ReadToken(str) != "{") return false;
  ------------------
  |  Branch (148:11): [True: 3, False: 4.58k]
  ------------------
  149|  4.58k|      if (!ParseImpl(v.emplace_back(), str, recursion_depth + 1)) return false;
  ------------------
  |  Branch (149:11): [True: 116, False: 4.46k]
  ------------------
  150|  4.46k|      if (ReadToken(str) != "}") return false;
  ------------------
  |  Branch (150:11): [True: 76, False: 4.38k]
  ------------------
  151|  4.38k|      key = ReadToken(str);
  152|  4.38k|    } while (key == "sub");
  ------------------
  |  Branch (152:14): [True: 4.37k, False: 15]
  ------------------
  153|       |    // We are done reading this repeated sub.
  154|       |    // Put the token back for the caller.
  155|     15|    str = absl::string_view(key.data(), str.data() + str.size() - key.data());
  156|     15|    return true;
  157|  5.21k|  } else {
  158|  5.21k|    if (ReadToken(str) != ":") return false;
  ------------------
  |  Branch (158:9): [True: 11, False: 5.20k]
  ------------------
  159|  5.20k|    auto value = ReadToken(str);
  160|  5.20k|    auto& v = obj.value;
  161|  5.20k|    if (key == "i") {
  ------------------
  |  Branch (161:9): [True: 25, False: 5.18k]
  ------------------
  162|     25|      return ReadScalar(v.emplace<uint64_t>(), value);
  163|  5.18k|    } else if (key == "d") {
  ------------------
  |  Branch (163:16): [True: 5.18k, False: 0]
  ------------------
  164|  5.18k|      return ReadScalar(v.emplace<double>(), value);
  165|  5.18k|    } else if (key == "s") {
  ------------------
  |  Branch (165:16): [True: 0, False: 0]
  ------------------
  166|      0|      return ReadScalar(v.emplace<std::string>(), value);
  167|      0|    } else {
  168|       |      // Unrecognized key
  169|      0|      return false;
  170|      0|    }
  171|  5.20k|  }
  172|  5.42k|}
serialization.cc:_ZN8fuzztest8internal12_GLOBAL__N_110ReadScalarERmNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   96|     25|bool ReadScalar(uint64_t& out, absl::string_view value) {
   97|     25|  return absl::SimpleAtoi(value, &out);
   98|     25|}
serialization.cc:_ZN8fuzztest8internal12_GLOBAL__N_110ReadScalarERdNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
  100|  5.18k|bool ReadScalar(double& out, absl::string_view value) {
  101|  5.18k|  return absl::SimpleAtod(value, &out);
  102|  5.18k|}

_ZNK8fuzztest8internal8IRObject8ToCorpusINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEENS3_8optionalIT_EEv:
  219|  4.66k|  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|  4.66k|    } else {
  279|       |      // Must be a tuple like object.
  280|  4.66k|      auto elems = Subs();
  281|  4.66k|      if (!elems || elems->size() != std::tuple_size_v<T>) return std::nullopt;
  ------------------
  |  Branch (281:11): [True: 203, False: 4.45k]
  |  Branch (281:21): [True: 4, False: 4.45k]
  ------------------
  282|  4.45k|      auto it = elems->begin();
  283|  4.45k|      auto parts = ApplyIndex<std::tuple_size_v<T>>([&](auto... I) {
  284|  4.45k|        return std::tuple{it++->ToCorpus<std::tuple_element_t<I, T>>()...};
  285|  4.45k|      });
  286|  4.45k|      return std::apply(
  287|  4.45k|          [&](auto&... part) -> std::optional<T> {
  288|  4.45k|            if ((!part || ...)) return std::nullopt;
  289|  4.45k|            return T{*std::move(part)...};
  290|  4.45k|          },
  291|  4.45k|          parts);
  292|  4.66k|    }
  293|  4.66k|  }
_ZNK8fuzztest8internal8IRObject4SubsEv:
  130|  4.66k|  std::optional<absl::Span<const IRObject>> Subs() const {
  131|  4.66k|    if (const auto* i = std::get_if<std::vector<IRObject>>(&value)) {
  ------------------
  |  Branch (131:21): [True: 4.45k, False: 204]
  ------------------
  132|  4.45k|      return *i;
  133|  4.45k|    }
  134|       |    // The empty vector is serialized the same way as the monostate: nothing.
  135|       |    // Handle that case too.
  136|    204|    if (std::holds_alternative<std::monostate>(value)) {
  ------------------
  |  Branch (136:9): [True: 1, False: 203]
  ------------------
  137|      1|      return absl::Span<const IRObject>{};
  138|      1|    }
  139|    203|    return std::nullopt;
  140|    204|  }
_ZZNK8fuzztest8internal8IRObject8ToCorpusINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEENS3_8optionalIT_EEvENKUlDpT_E_clIJNS3_17integral_constantImLm0EEEEEEDaSG_:
  283|  4.45k|      auto parts = ApplyIndex<std::tuple_size_v<T>>([&](auto... I) {
  284|  4.45k|        return std::tuple{it++->ToCorpus<std::tuple_element_t<I, T>>()...};
  285|  4.45k|      });
_ZNK8fuzztest8internal8IRObject8ToCorpusINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEENS3_8optionalIT_EEv:
  219|  4.45k|  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|  4.45k|    } else if constexpr (std::is_constructible_v<IRObject, T>) {
  228|  4.45k|      if (auto v = GetScalar<T>()) {
  ------------------
  |  Branch (228:16): [True: 4.45k, False: 2]
  ------------------
  229|  4.45k|        return static_cast<T>(*v);
  230|  4.45k|      }
  231|      2|      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|  4.45k|  }
_ZNK8fuzztest8internal8IRObject9GetScalarINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEDav:
   90|  4.45k|  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|  4.45k|    } else if constexpr (std::is_same_v<std::string, T>) {
  102|  4.45k|      std::optional<absl::string_view> out;
  103|  4.45k|      if (const auto* s = std::get_if<std::string>(&value)) {
  ------------------
  |  Branch (103:23): [True: 4.45k, False: 2]
  ------------------
  104|  4.45k|        out = *s;
  105|  4.45k|      }
  106|  4.45k|      return out;
  107|  4.45k|    }
  108|  4.45k|  }
_ZZNK8fuzztest8internal8IRObject8ToCorpusINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEENS3_8optionalIT_EEvENKUlDpRT_E_clIJNSC_ISA_EEEEENSC_ISB_EESH_:
  287|  4.45k|          [&](auto&... part) -> std::optional<T> {
  288|  4.45k|            if ((!part || ...)) return std::nullopt;
  ------------------
  |  Branch (288:18): [True: 2, False: 4.45k]
  ------------------
  289|  4.45k|            return T{*std::move(part)...};
  290|  4.45k|          },
_ZN8fuzztest8internal8IRObjectC2Ev:
   76|  16.3k|  IRObject() = default;

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

_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|      4|  const char* test_suite_name() const { return test_suite_name_.c_str(); }
_ZNK7testing8TestInfo4nameEv:
  549|      8|  const char* name() const { return name_.c_str(); }
_ZN7testing8UnitTest4implEv:
 1267|     48|  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; }
_ZN7testing9TestSuite13ShouldRunTestEPKNS_8TestInfoE:
  839|      4|  static bool ShouldRunTest(const TestInfo* test_info) {
  840|      4|    return test_info->should_run();
  841|      4|  }
_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|      2|  static void ClearTestResult(TestInfo* test_info) {
  640|      2|    test_info->result_.Clear();
  641|      2|  }
_ZNK7testing9TestSuite4nameEv:
  695|      4|  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|      4|  bool should_run() const { return should_run_; }
_ZNK7testing8TestInfo10should_runEv:
  590|      4|  bool should_run() const { return should_run_; }
_ZNK7testing8TestInfo10type_paramEv:
  553|      2|  const char* type_param() const {
  554|      2|    if (type_param_ != nullptr) return type_param_->c_str();
  ------------------
  |  Branch (554:9): [True: 0, False: 2]
  ------------------
  555|      2|    return nullptr;
  556|      2|  }
_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|      4|  void set_should_run(bool should) { should_run_ = should; }
_ZN7testing9TestSuite14test_info_listEv:
  759|      6|  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|      4|  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|      2|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|      2|  return &(TypeIdHelper<T>::dummy_);
  425|      2|}

_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|     10|  Mutex() {
 1707|     10|    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, nullptr));
  ------------------
  |  | 1092|     10|  if (const int gtest_error = (posix_call))    \
  |  |  ------------------
  |  |  |  Branch (1092:17): [True: 0, False: 10]
  |  |  ------------------
  |  | 1093|     10|  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|     10|    has_owner_ = false;
 1709|     10|  }
_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|     34|inline UnitTestImpl* GetUnitTestImpl() {
  967|     34|  return UnitTest::GetInstance()->impl();
  968|     34|}
_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|      2|                   TestInfo* test_info) {
  675|      2|#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|      2|    if (original_working_dir_.IsEmpty()) {
  ------------------
  |  Branch (683:9): [True: 2, False: 0]
  ------------------
  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|      2|#endif  // GTEST_HAS_FILE_SYSTEM
  689|       |
  690|      2|    GetTestSuite(test_info->test_suite_name(), test_info->type_param(),
  691|      2|                 set_up_tc, tear_down_tc)
  692|      2|        ->AddTestInfo(test_info);
  693|      2|  }
_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|      8|  for (auto it = c.begin(); it != c.end(); ++it) {
  ------------------
  |  Branch (279:29): [True: 4, False: 4]
  ------------------
  280|      4|    if (predicate(*it)) ++count;
  ------------------
  |  Branch (280:9): [True: 4, False: 0]
  ------------------
  281|      4|  }
  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|      2|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|  3.01k|  for (const char* ch = start; ch != end; ++ch) {
  ------------------
  |  Branch (2223:32): [True: 2.89k, False: 118]
  ------------------
 2224|  2.89k|    if (*ch == '\0') {
  ------------------
  |  Branch (2224:9): [True: 0, False: 2.89k]
  ------------------
 2225|      0|      result += "\\0";  // Replaces NUL with "\\0";
 2226|  2.89k|    } else {
 2227|  2.89k|      result += *ch;
 2228|  2.89k|    }
 2229|  2.89k|  }
 2230|       |
 2231|    118|  return result;
 2232|    118|}
_ZN7testing10TestResultC2Ev:
 2254|      6|    : death_test_count_(0), start_timestamp_(0), elapsed_time_(0) {}
_ZN7testing10TestResult5ClearEv:
 2400|      4|void TestResult::Clear() {
 2401|      4|  test_part_results_.clear();
 2402|      4|  test_properties_.clear();
 2403|      4|  death_test_count_ = 0;
 2404|      4|  elapsed_time_ = 0;
 2405|      4|}
_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|      2|    : test_suite_name_(a_test_suite_name),
 2727|       |      // begin()/end() is MSVC 17.3.3 ASAN crash workaround (GitHub issue #3997)
 2728|      2|      name_(a_name.begin(), a_name.end()),
 2729|      2|      type_param_(a_type_param ? new std::string(a_type_param) : nullptr),
  ------------------
  |  Branch (2729:19): [True: 0, False: 2]
  ------------------
 2730|      2|      value_param_(a_value_param ? new std::string(a_value_param) : nullptr),
  ------------------
  |  Branch (2730:20): [True: 0, False: 2]
  ------------------
 2731|      2|      location_(a_code_location),
 2732|      2|      fixture_class_id_(fixture_class_id),
 2733|      2|      should_run_(false),
 2734|      2|      is_disabled_(false),
 2735|      2|      matches_filter_(false),
 2736|      2|      is_in_another_shard_(false),
 2737|      2|      factory_(factory),
 2738|      2|      result_() {}
_ZN7testing8internal23MakeAndRegisterTestInfoEPKcS2_S2_S2_NS0_12CodeLocationEPKvPFvvES7_PNS0_15TestFactoryBaseE:
 2767|      2|    TearDownTestSuiteFunc tear_down_tc, TestFactoryBase* factory) {
 2768|      2|  TestInfo* const test_info =
 2769|      2|      new TestInfo(test_suite_name, name, type_param, value_param,
 2770|      2|                   code_location, fixture_class_id, factory);
 2771|      2|  GetUnitTestImpl()->AddTestInfo(set_up_tc, tear_down_tc, test_info);
 2772|      2|  return test_info;
 2773|      2|}
_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|      2|void TestSuite::AddTestInfo(TestInfo* test_info) {
 2963|      2|  test_info_list_.push_back(test_info);
 2964|      2|  test_indices_.push_back(static_cast<int>(test_indices_.size()));
 2965|      2|}
_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|     46|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|     46|  static UnitTest instance;
 5166|     46|  return &instance;
 5167|     46|#endif  // defined(__BORLANDC__)
 5168|     46|}
_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|      2|    internal::TearDownTestSuiteFunc tear_down_tc) {
 5753|       |  // Can we find a TestSuite with the given name?
 5754|      2|  const auto test_suite =
 5755|      2|      std::find_if(test_suites_.rbegin(), test_suites_.rend(),
 5756|      2|                   TestSuiteNameIs(test_suite_name));
 5757|       |
 5758|      2|  if (test_suite != test_suites_.rend()) return *test_suite;
  ------------------
  |  Branch (5758:7): [True: 0, 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|      2|}
_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|      4|    for (size_t j = 0; j < test_suite->test_info_list().size(); j++) {
  ------------------
  |  Branch (6111:24): [True: 2, False: 2]
  ------------------
 6112|      2|      TestInfo* const test_info = test_suite->test_info_list()[j];
 6113|      2|      const std::string test_name(test_info->name());
 6114|       |      // A test is disabled if test suite name or test name matches
 6115|       |      // kDisableTestFilter.
 6116|      2|      const bool is_disabled =
 6117|      2|          disable_test_filter.MatchesName(test_suite_name) ||
  ------------------
  |  Branch (6117:11): [True: 0, False: 2]
  ------------------
 6118|      2|          disable_test_filter.MatchesName(test_name);
  ------------------
  |  Branch (6118:11): [True: 0, False: 2]
  ------------------
 6119|      2|      test_info->is_disabled_ = is_disabled;
 6120|       |
 6121|      2|      const bool matches_filter =
 6122|      2|          gtest_flag_filter.MatchesTest(test_suite_name, test_name);
 6123|      2|      test_info->matches_filter_ = matches_filter;
 6124|       |
 6125|      2|      const bool is_runnable =
 6126|      2|          (GTEST_FLAG_GET(also_run_disabled_tests) || !is_disabled) &&
  ------------------
  |  | 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 (6126:55): [True: 2, False: 0]
  ------------------
 6127|      2|          matches_filter;
  ------------------
  |  Branch (6127:11): [True: 2, False: 0]
  ------------------
 6128|       |
 6129|      2|      const bool is_in_another_shard =
 6130|      2|          shard_tests != IGNORE_SHARDING_PROTOCOL &&
  ------------------
  |  Branch (6130:11): [True: 0, False: 2]
  ------------------
 6131|      0|          !ShouldRunTestOnShard(total_shards, shard_index, num_runnable_tests);
  ------------------
  |  Branch (6131:11): [True: 0, False: 0]
  ------------------
 6132|      2|      test_info->is_in_another_shard_ = is_in_another_shard;
 6133|      2|      const bool is_selected = is_runnable && !is_in_another_shard;
  ------------------
  |  Branch (6133:32): [True: 2, False: 0]
  |  Branch (6133:47): [True: 2, False: 0]
  ------------------
 6134|       |
 6135|      2|      num_runnable_tests += is_runnable;
 6136|      2|      num_selected_tests += is_selected;
 6137|       |
 6138|      2|      test_info->should_run_ = is_selected;
 6139|      2|      test_suite->set_should_run(test_suite->should_run() || is_selected);
  ------------------
  |  Branch (6139:34): [True: 0, False: 2]
  |  Branch (6139:62): [True: 2, False: 0]
  ------------------
 6140|      2|    }
 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|     18|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|    104|                     [](const char c) { return c == '?' || c == '*'; });
  ------------------
  |  Branch (754:48): [True: 0, False: 104]
  |  Branch (754:60): [True: 8, False: 96]
  ------------------
gtest-all.cc:_ZNK7testing8internal12_GLOBAL__N_114UnitTestFilter11MatchesNameERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
  780|     10|  bool MatchesName(const std::string& name) const {
  781|     10|    return exact_match_patterns_.count(name) > 0 ||
  ------------------
  |  Branch (781:12): [True: 2, False: 8]
  ------------------
  782|      8|           std::any_of(glob_patterns_.begin(), glob_patterns_.end(),
  ------------------
  |  Branch (782:12): [True: 0, False: 8]
  ------------------
  783|      8|                       [&name](const std::string& pattern) {
  784|      8|                         return PatternMatchesString(
  785|      8|                             name, pattern.c_str(),
  786|      8|                             pattern.c_str() + pattern.size());
  787|      8|                       });
  788|     10|  }
gtest-all.cc:_ZZNK7testing8internal12_GLOBAL__N_114UnitTestFilter11MatchesNameERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEENKUlSB_E_clESB_:
  783|     12|                       [&name](const std::string& pattern) {
  784|     12|                         return PatternMatchesString(
  785|     12|                             name, pattern.c_str(),
  786|     12|                             pattern.c_str() + pattern.size());
  787|     12|                       });
gtest-all.cc:_ZN7testing8internalL20PatternMatchesStringERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPKcSB_:
  704|     12|                                 const char* pattern, const char* pattern_end) {
  705|     12|  const char* name = name_str.c_str();
  706|     12|  const char* const name_begin = name;
  707|     12|  const char* const name_end = name + name_str.size();
  708|       |
  709|     12|  const char* pattern_next = pattern;
  710|     12|  const char* name_next = name;
  711|       |
  712|    308|  while (pattern < pattern_end || name < name_end) {
  ------------------
  |  Branch (712:10): [True: 308, False: 0]
  |  Branch (712:35): [True: 0, False: 0]
  ------------------
  713|    308|    if (pattern < pattern_end) {
  ------------------
  |  Branch (713:9): [True: 308, False: 0]
  ------------------
  714|    308|      switch (*pattern) {
  715|    156|        default:  // Match an ordinary character.
  ------------------
  |  Branch (715:9): [True: 156, False: 152]
  ------------------
  716|    156|          if (name < name_end && *name == *pattern) {
  ------------------
  |  Branch (716:15): [True: 148, False: 8]
  |  Branch (716:34): [True: 0, False: 148]
  ------------------
  717|      0|            ++pattern;
  718|      0|            ++name;
  719|      0|            continue;
  720|      0|          }
  721|    156|          break;
  722|    156|        case '?':  // Match any single character.
  ------------------
  |  Branch (722:9): [True: 0, False: 308]
  ------------------
  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|    152|        case '*':
  ------------------
  |  Branch (729:9): [True: 152, False: 156]
  ------------------
  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|    152|          pattern_next = pattern;
  734|    152|          name_next = name + 1;
  735|    152|          ++pattern;
  736|    152|          continue;
  737|    308|      }
  738|    308|    }
  739|       |    // Failed to match a character. Restart if possible.
  740|    156|    if (name_begin < name_next && name_next <= name_end) {
  ------------------
  |  Branch (740:9): [True: 152, False: 4]
  |  Branch (740:35): [True: 144, False: 8]
  ------------------
  741|    144|      pattern = pattern_next;
  742|    144|      name = name_next;
  743|    144|      continue;
  744|    144|    }
  745|     12|    return false;
  746|    156|  }
  747|      0|  return true;
  748|     12|}
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|      2|                   const std::string& test_name) const {
  834|      2|    return MatchesName(test_suite_name + "." + test_name);
  835|      2|  }
gtest-all.cc:_ZNK7testing8internal12_GLOBAL__N_133PositiveAndNegativeUnitTestFilter11MatchesNameERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
  839|      2|  bool MatchesName(const std::string& name) const {
  840|      2|    return positive_filter_.MatchesName(name) &&
  ------------------
  |  Branch (840:12): [True: 2, False: 0]
  ------------------
  841|      2|           !negative_filter_.MatchesName(name);
  ------------------
  |  Branch (841:12): [True: 2, False: 0]
  ------------------
  842|      2|  }
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|      2|  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|}
_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|}
_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|}

ClearAnimatedImage:
   85|  4.38k|void ClearAnimatedImage(AnimatedImage* const image) {
   86|  4.38k|  if (image != NULL) {
  ------------------
  |  Branch (86:7): [True: 4.38k, False: 0]
  ------------------
   87|  4.38k|    WebPFree(image->raw_mem);
   88|  4.38k|    WebPFree(image->frames);
   89|  4.38k|    image->num_frames = 0;
   90|  4.38k|    image->frames = NULL;
   91|       |    image->raw_mem = NULL;
   92|  4.38k|  }
   93|  4.38k|}
CheckMultiplicationOverflow:
   96|    737|int CheckMultiplicationOverflow(uint32_t val1, uint32_t val2, size_t* product) {
   97|    737|  const uint64_t size = (uint64_t)val1 * val2;
   98|    737|  if (CheckSizeForOverflow(size)) {
  ------------------
  |  Branch (98:7): [True: 737, False: 0]
  ------------------
   99|    737|    *product = (size_t)size;
  100|    737|    return 1;
  101|    737|  }
  102|      0|  return 0;
  103|    737|}
ReadAnimatedImageFromMemory:
  862|  4.38k|                                const char dump_folder[]) {
  863|  4.38k|  int ok = 0;
  864|  4.38k|  WebPData webp_data;
  865|       |
  866|  4.38k|  webp_data.bytes = data;
  867|  4.38k|  webp_data.size = size;
  868|  4.38k|  memset(image, 0, sizeof(*image));
  869|       |
  870|  4.38k|  if (IsWebP(&webp_data)) {
  ------------------
  |  Branch (870:7): [True: 3.90k, False: 472]
  ------------------
  871|  3.90k|    ok =
  872|  3.90k|        ReadAnimatedWebP(filename, &webp_data, image, dump_frames, dump_folder);
  873|  3.90k|  } else if (IsGIF(&webp_data)) {
  ------------------
  |  Branch (873:14): [True: 58, False: 414]
  ------------------
  874|     58|    ok = ReadAnimatedGIF(filename, &webp_data, image, dump_frames, dump_folder);
  875|    414|  } else {
  876|    414|    WFPRINTF(stderr,
  ------------------
  |  |  102|    414|#define WFPRINTF(STREAM, STR, ...) fprintf(STREAM, STR, __VA_ARGS__)
  ------------------
  877|    414|             "Unknown file type: %s. Supported file types are WebP and GIF\n",
  878|    414|             (const W_CHAR*)filename);
  879|    414|    ok = 0;
  880|    414|  }
  881|  4.38k|  if (!ok) ClearAnimatedImage(image);
  ------------------
  |  Branch (881:7): [True: 3.64k, False: 737]
  ------------------
  882|  4.38k|  return ok;
  883|  4.38k|}
anim_util.c:CheckSizeForOverflow:
   49|  8.48k|static int CheckSizeForOverflow(uint64_t size) {
   50|  8.48k|  return (size == (size_t)size);
   51|  8.48k|}
anim_util.c:IsWebP:
  268|  4.38k|static int IsWebP(const WebPData* const webp_data) {
  269|  4.38k|  return (WebPGetInfo(webp_data->bytes, webp_data->size, NULL, NULL) != 0);
  270|  4.38k|}
anim_util.c:ReadAnimatedWebP:
  276|  3.90k|                            const char dump_folder[]) {
  277|  3.90k|  int ok = 0;
  278|  3.90k|  int dump_ok = 1;
  279|  3.90k|  uint32_t frame_index = 0;
  280|  3.90k|  int prev_frame_timestamp = 0;
  281|  3.90k|  WebPAnimDecoder* dec;
  282|  3.90k|  WebPAnimInfo anim_info;
  283|       |
  284|  3.90k|  memset(image, 0, sizeof(*image));
  285|       |
  286|  3.90k|  dec = WebPAnimDecoderNew(webp_data, NULL);
  287|  3.90k|  if (dec == NULL) {
  ------------------
  |  Branch (287:7): [True: 34, False: 3.87k]
  ------------------
  288|     34|    WFPRINTF(stderr, "Error parsing image: %s\n", (const W_CHAR*)filename);
  ------------------
  |  |  102|     34|#define WFPRINTF(STREAM, STR, ...) fprintf(STREAM, STR, __VA_ARGS__)
  ------------------
  289|     34|    goto End;
  290|     34|  }
  291|       |
  292|  3.87k|  if (!WebPAnimDecoderGetInfo(dec, &anim_info)) {
  ------------------
  |  Branch (292:7): [True: 0, False: 3.87k]
  ------------------
  293|      0|    fprintf(stderr, "Error getting global info about the animation\n");
  294|      0|    goto End;
  295|      0|  }
  296|       |
  297|       |  // Animation properties.
  298|  3.87k|  image->canvas_width = anim_info.canvas_width;
  299|  3.87k|  image->canvas_height = anim_info.canvas_height;
  300|  3.87k|  image->loop_count = anim_info.loop_count;
  301|  3.87k|  image->bgcolor = anim_info.bgcolor;
  302|       |
  303|       |  // Allocate frames.
  304|  3.87k|  if (!AllocateFrames(image, anim_info.frame_count)) goto End;
  ------------------
  |  Branch (304:7): [True: 0, False: 3.87k]
  ------------------
  305|       |
  306|       |  // Decode frames.
  307|  4.61k|  while (WebPAnimDecoderHasMoreFrames(dec)) {
  ------------------
  |  Branch (307:10): [True: 3.87k, False: 737]
  ------------------
  308|  3.87k|    DecodedFrame* curr_frame;
  309|  3.87k|    uint8_t* curr_rgba;
  310|  3.87k|    uint8_t* frame_rgba;
  311|  3.87k|    int timestamp;
  312|  3.87k|    size_t size;
  313|       |
  314|  3.87k|    if (!WebPAnimDecoderGetNext(dec, &frame_rgba, &timestamp)) {
  ------------------
  |  Branch (314:9): [True: 3.13k, False: 737]
  ------------------
  315|  3.13k|      fprintf(stderr, "Error decoding frame #%u\n", frame_index);
  316|  3.13k|      goto End;
  317|  3.13k|    }
  318|  3.87k|    assert(frame_index < anim_info.frame_count);
  319|    737|    curr_frame = &image->frames[frame_index];
  320|    737|    curr_rgba = curr_frame->rgba;
  321|    737|    curr_frame->duration = timestamp - prev_frame_timestamp;
  322|    737|    curr_frame->is_key_frame = 0;  // Unused.
  323|    737|    if (!CheckMultiplicationOverflow(image->canvas_width * kNumChannels,
  ------------------
  |  Branch (323:9): [True: 0, False: 737]
  ------------------
  324|    737|                                     image->canvas_height, &size)) {
  325|      0|      goto End;
  326|      0|    }
  327|    737|    memcpy(curr_rgba, frame_rgba, size);
  328|       |
  329|       |    // Needed only because we may want to compare with GIF later.
  330|    737|    CleanupTransparentPixels((uint32_t*)curr_rgba, image->canvas_width,
  331|    737|                             image->canvas_height);
  332|       |
  333|    737|    if (dump_frames && dump_ok) {
  ------------------
  |  Branch (333:9): [True: 0, False: 737]
  |  Branch (333:24): [True: 0, False: 0]
  ------------------
  334|      0|      dump_ok = DumpFrame(filename, dump_folder, frame_index, curr_rgba,
  335|      0|                          image->canvas_width, image->canvas_height);
  336|      0|      if (!dump_ok) {  // Print error once, but continue decode loop.
  ------------------
  |  Branch (336:11): [True: 0, False: 0]
  ------------------
  337|      0|        fprintf(stderr, "Error dumping frames to %s\n", dump_folder);
  338|      0|      }
  339|      0|    }
  340|       |
  341|    737|    ++frame_index;
  342|    737|    prev_frame_timestamp = timestamp;
  343|    737|  }
  344|    737|  ok = dump_ok;
  345|    737|  if (ok) image->format = ANIM_WEBP;
  ------------------
  |  Branch (345:7): [True: 737, False: 0]
  ------------------
  346|       |
  347|  3.90k|End:
  348|  3.90k|  WebPAnimDecoderDelete(dec);
  349|  3.90k|  return ok;
  350|    737|}
anim_util.c:AllocateFrames:
   53|  3.87k|static int AllocateFrames(AnimatedImage* const image, uint32_t num_frames) {
   54|  3.87k|  uint32_t i;
   55|  3.87k|  uint8_t* mem = NULL;
   56|  3.87k|  DecodedFrame* frames = NULL;
   57|  3.87k|  const uint64_t rgba_size =
   58|  3.87k|      (uint64_t)image->canvas_width * kNumChannels * image->canvas_height;
   59|  3.87k|  const uint64_t total_size = (uint64_t)num_frames * rgba_size * sizeof(*mem);
   60|  3.87k|  const uint64_t total_frame_size = (uint64_t)num_frames * sizeof(*frames);
   61|  3.87k|  if (!CheckSizeForOverflow(total_size) ||
  ------------------
  |  Branch (61:7): [True: 0, False: 3.87k]
  ------------------
   62|  3.87k|      !CheckSizeForOverflow(total_frame_size)) {
  ------------------
  |  Branch (62:7): [True: 0, False: 3.87k]
  ------------------
   63|      0|    return 0;
   64|      0|  }
   65|  3.87k|  mem = (uint8_t*)WebPMalloc((size_t)total_size);
   66|  3.87k|  frames = (DecodedFrame*)WebPMalloc((size_t)total_frame_size);
   67|       |
   68|  3.87k|  if (mem == NULL || frames == NULL) {
  ------------------
  |  Branch (68:7): [True: 0, False: 3.87k]
  |  Branch (68:22): [True: 0, False: 3.87k]
  ------------------
   69|      0|    WebPFree(mem);
   70|      0|    WebPFree(frames);
   71|      0|    return 0;
   72|      0|  }
   73|  3.87k|  WebPFree(image->raw_mem);
   74|  3.87k|  image->num_frames = num_frames;
   75|  3.87k|  image->frames = frames;
   76|  7.74k|  for (i = 0; i < num_frames; ++i) {
  ------------------
  |  Branch (76:15): [True: 3.87k, False: 3.87k]
  ------------------
   77|  3.87k|    frames[i].rgba = mem + i * rgba_size;
   78|  3.87k|    frames[i].duration = 0;
   79|  3.87k|    frames[i].is_key_frame = 0;
   80|  3.87k|  }
   81|  3.87k|  image->raw_mem = mem;
   82|  3.87k|  return 1;
   83|  3.87k|}
anim_util.c:CleanupTransparentPixels:
  198|    737|                                     uint32_t height) {
  199|    737|  const uint32_t* const rgba_end = rgba + width * height;
  200|  2.37G|  while (rgba < rgba_end) {
  ------------------
  |  Branch (200:10): [True: 2.37G, False: 737]
  ------------------
  201|  2.37G|    const uint8_t alpha = (*rgba >> 24) & 0xff;
  202|  2.37G|    if (alpha == 0) {
  ------------------
  |  Branch (202:9): [True: 605M, False: 1.76G]
  ------------------
  203|   605M|      *rgba = 0;
  204|   605M|    }
  205|  2.37G|    ++rgba;
  206|  2.37G|  }
  207|    737|}
anim_util.c:IsGIF:
  376|    472|static int IsGIF(const WebPData* const data) {
  377|    472|  return data->size > GIF_STAMP_LEN &&
  ------------------
  |  Branch (377:10): [True: 441, False: 31]
  ------------------
  378|    441|         (!memcmp(GIF_STAMP, data->bytes, GIF_STAMP_LEN) ||
  ------------------
  |  Branch (378:11): [True: 0, False: 441]
  ------------------
  379|    441|          !memcmp(GIF87_STAMP, data->bytes, GIF_STAMP_LEN) ||
  ------------------
  |  Branch (379:11): [True: 56, False: 385]
  ------------------
  380|    385|          !memcmp(GIF89_STAMP, data->bytes, GIF_STAMP_LEN));
  ------------------
  |  Branch (380:11): [True: 2, False: 383]
  ------------------
  381|    472|}
anim_util.c:ReadAnimatedGIF:
  605|     58|                           const char dump_folder[]) {
  606|     58|  uint32_t frame_count;
  607|     58|  uint32_t canvas_width, canvas_height;
  608|     58|  uint32_t i;
  609|     58|  int gif_error;
  610|     58|  GifFileType* gif;
  611|     58|  GifBufferContext ctx;
  612|       |
  613|     58|  ctx.data = gif_data->bytes;
  614|     58|  ctx.size = gif_data->size;
  615|     58|  ctx.offset = 0;
  616|     58|  gif = DGifOpen(&ctx, MemoryReadGIF, &gif_error);
  617|     58|  if (gif == NULL) {
  ------------------
  |  Branch (617:7): [True: 12, False: 46]
  ------------------
  618|     12|    WFPRINTF(stderr, "Could not read GIF from memory: %s.\n",
  ------------------
  |  |  102|     12|#define WFPRINTF(STREAM, STR, ...) fprintf(STREAM, STR, __VA_ARGS__)
  ------------------
  619|     12|             (const W_CHAR*)filename);
  620|     12|    return 0;
  621|     12|  }
  622|       |
  623|     46|  gif_error = DGifSlurp(gif);
  624|     46|  if (gif_error != GIF_OK) {
  ------------------
  |  Branch (624:7): [True: 46, False: 0]
  ------------------
  625|     46|    WFPRINTF(stderr, "Could not parse image: %s.\n", (const W_CHAR*)filename);
  ------------------
  |  |  102|     46|#define WFPRINTF(STREAM, STR, ...) fprintf(STREAM, STR, __VA_ARGS__)
  ------------------
  626|     46|    GIFDisplayError(gif, gif_error);
  627|     46|    DGifCloseFile(gif, NULL);
  628|     46|    return 0;
  629|     46|  }
  630|       |
  631|       |  // Animation properties.
  632|      0|  image->canvas_width = (uint32_t)gif->SWidth;
  633|      0|  image->canvas_height = (uint32_t)gif->SHeight;
  634|      0|  if (image->canvas_width > MAX_CANVAS_SIZE ||
  ------------------
  |  |   81|      0|#define MAX_CANVAS_SIZE (1 << 24)      // 24-bit max for VP8X width/height.
  ------------------
  |  Branch (634:7): [True: 0, False: 0]
  ------------------
  635|      0|      image->canvas_height > MAX_CANVAS_SIZE) {
  ------------------
  |  |   81|      0|#define MAX_CANVAS_SIZE (1 << 24)      // 24-bit max for VP8X width/height.
  ------------------
  |  Branch (635:7): [True: 0, False: 0]
  ------------------
  636|      0|    fprintf(stderr, "Invalid canvas dimension: %d x %d\n", image->canvas_width,
  637|      0|            image->canvas_height);
  638|      0|    DGifCloseFile(gif, NULL);
  639|      0|    return 0;
  640|      0|  }
  641|      0|  image->loop_count = GetLoopCountGIF(gif);
  642|      0|  image->bgcolor = GetBackgroundColorGIF(gif);
  643|       |
  644|      0|  frame_count = (uint32_t)gif->ImageCount;
  645|      0|  if (frame_count == 0) {
  ------------------
  |  Branch (645:7): [True: 0, False: 0]
  ------------------
  646|      0|    DGifCloseFile(gif, NULL);
  647|      0|    return 0;
  648|      0|  }
  649|       |
  650|      0|  if (image->canvas_width == 0 || image->canvas_height == 0) {
  ------------------
  |  Branch (650:7): [True: 0, False: 0]
  |  Branch (650:35): [True: 0, False: 0]
  ------------------
  651|      0|    image->canvas_width = gif->SavedImages[0].ImageDesc.Width;
  652|      0|    image->canvas_height = gif->SavedImages[0].ImageDesc.Height;
  653|      0|    gif->SavedImages[0].ImageDesc.Left = 0;
  654|      0|    gif->SavedImages[0].ImageDesc.Top = 0;
  655|      0|    if (image->canvas_width == 0 || image->canvas_height == 0) {
  ------------------
  |  Branch (655:9): [True: 0, False: 0]
  |  Branch (655:37): [True: 0, False: 0]
  ------------------
  656|      0|      fprintf(stderr, "Invalid canvas size in GIF.\n");
  657|      0|      DGifCloseFile(gif, NULL);
  658|      0|      return 0;
  659|      0|    }
  660|      0|  }
  661|       |  // Allocate frames.
  662|      0|  if (!AllocateFrames(image, frame_count)) {
  ------------------
  |  Branch (662:7): [True: 0, False: 0]
  ------------------
  663|      0|    DGifCloseFile(gif, NULL);
  664|      0|    return 0;
  665|      0|  }
  666|       |
  667|      0|  canvas_width = image->canvas_width;
  668|      0|  canvas_height = image->canvas_height;
  669|       |
  670|       |  // Decode and reconstruct frames.
  671|      0|  for (i = 0; i < frame_count; ++i) {
  ------------------
  |  Branch (671:15): [True: 0, False: 0]
  ------------------
  672|      0|    const uint32_t canvas_width_in_bytes = canvas_width * kNumChannels;
  673|      0|    const SavedImage* const curr_gif_image = &gif->SavedImages[i];
  674|      0|    GraphicsControlBlock curr_gcb;
  675|      0|    DecodedFrame* curr_frame;
  676|      0|    uint8_t* curr_rgba;
  677|      0|    const int left = curr_gif_image->ImageDesc.Left;
  678|      0|    const int top = curr_gif_image->ImageDesc.Top;
  679|      0|    const int width = curr_gif_image->ImageDesc.Width;
  680|      0|    const int height = curr_gif_image->ImageDesc.Height;
  681|       |
  682|      0|    if (left < 0 || top < 0 || width <= 0 || height <= 0 ||
  ------------------
  |  Branch (682:9): [True: 0, False: 0]
  |  Branch (682:21): [True: 0, False: 0]
  |  Branch (682:32): [True: 0, False: 0]
  |  Branch (682:46): [True: 0, False: 0]
  ------------------
  683|      0|        (uint32_t)(left + width) > canvas_width ||
  ------------------
  |  Branch (683:9): [True: 0, False: 0]
  ------------------
  684|      0|        (uint32_t)(top + height) > canvas_height) {
  ------------------
  |  Branch (684:9): [True: 0, False: 0]
  ------------------
  685|      0|      DGifCloseFile(gif, NULL);
  686|      0|      return 0;
  687|      0|    }
  688|      0|    assert((uint32_t)width <= kGifDimMax && (uint32_t)height <= kGifDimMax);
  689|       |
  690|      0|    memset(&curr_gcb, 0, sizeof(curr_gcb));
  691|      0|    DGifSavedExtensionToGCB(gif, i, &curr_gcb);
  692|       |
  693|      0|    curr_frame = &image->frames[i];
  694|      0|    curr_rgba = curr_frame->rgba;
  695|      0|    curr_frame->duration = GetFrameDurationGIF(gif, i);
  696|       |    // Force frames with a small or no duration to 100ms to be consistent
  697|       |    // with web browsers and other transcoding tools (like gif2webp itself).
  698|      0|    if (curr_frame->duration <= 10) curr_frame->duration = 100;
  ------------------
  |  Branch (698:9): [True: 0, False: 0]
  ------------------
  699|       |
  700|      0|    if (i == 0) {  // Initialize as transparent.
  ------------------
  |  Branch (700:9): [True: 0, False: 0]
  ------------------
  701|      0|      curr_frame->is_key_frame = 1;
  702|      0|      if (!ZeroFillCanvas(curr_rgba, canvas_width, canvas_height)) {
  ------------------
  |  Branch (702:11): [True: 0, False: 0]
  ------------------
  703|      0|        DGifCloseFile(gif, NULL);
  704|      0|        return 0;
  705|      0|      }
  706|      0|    } else {
  707|      0|      DecodedFrame* const prev_frame = &image->frames[i - 1];
  708|      0|      const GifImageDesc* const prev_desc = &gif->SavedImages[i - 1].ImageDesc;
  709|      0|      GraphicsControlBlock prev_gcb;
  710|      0|      memset(&prev_gcb, 0, sizeof(prev_gcb));
  711|      0|      DGifSavedExtensionToGCB(gif, i - 1, &prev_gcb);
  712|       |
  713|      0|      curr_frame->is_key_frame =
  714|      0|          IsKeyFrameGIF(prev_desc, prev_gcb.DisposalMode, prev_frame,
  715|      0|                        canvas_width, canvas_height);
  716|       |
  717|      0|      if (curr_frame->is_key_frame) {  // Initialize as transparent.
  ------------------
  |  Branch (717:11): [True: 0, False: 0]
  ------------------
  718|      0|        if (!ZeroFillCanvas(curr_rgba, canvas_width, canvas_height)) {
  ------------------
  |  Branch (718:13): [True: 0, False: 0]
  ------------------
  719|      0|          DGifCloseFile(gif, NULL);
  720|      0|          return 0;
  721|      0|        }
  722|      0|      } else {
  723|      0|        int prev_frame_disposed, curr_frame_opaque;
  724|      0|        int prev_frame_completely_covered;
  725|       |        // Initialize with previous canvas.
  726|      0|        uint8_t* const prev_rgba = image->frames[i - 1].rgba;
  727|      0|        if (!CopyCanvas(prev_rgba, curr_rgba, canvas_width, canvas_height)) {
  ------------------
  |  Branch (727:13): [True: 0, False: 0]
  ------------------
  728|      0|          DGifCloseFile(gif, NULL);
  729|      0|          return 0;
  730|      0|        }
  731|       |
  732|       |        // Dispose previous frame rectangle.
  733|      0|        prev_frame_disposed = (prev_gcb.DisposalMode == DISPOSE_BACKGROUND ||
  ------------------
  |  Branch (733:32): [True: 0, False: 0]
  ------------------
  734|      0|                               prev_gcb.DisposalMode == DISPOSE_PREVIOUS);
  ------------------
  |  Branch (734:32): [True: 0, False: 0]
  ------------------
  735|      0|        curr_frame_opaque = (curr_gcb.TransparentColor == NO_TRANSPARENT_COLOR);
  736|      0|        prev_frame_completely_covered =
  737|      0|            curr_frame_opaque &&
  ------------------
  |  Branch (737:13): [True: 0, False: 0]
  ------------------
  738|      0|            CoversFrameGIF(&curr_gif_image->ImageDesc, prev_desc);
  ------------------
  |  Branch (738:13): [True: 0, False: 0]
  ------------------
  739|       |
  740|      0|        if (prev_frame_disposed && !prev_frame_completely_covered) {
  ------------------
  |  Branch (740:13): [True: 0, False: 0]
  |  Branch (740:36): [True: 0, False: 0]
  ------------------
  741|      0|          switch (prev_gcb.DisposalMode) {
  742|      0|            case DISPOSE_BACKGROUND: {
  ------------------
  |  Branch (742:13): [True: 0, False: 0]
  ------------------
  743|      0|              if (!ZeroFillFrameRect(curr_rgba, canvas_width_in_bytes,
  ------------------
  |  Branch (743:19): [True: 0, False: 0]
  ------------------
  744|      0|                                     prev_desc->Left, prev_desc->Top,
  745|      0|                                     prev_desc->Width, prev_desc->Height)) {
  746|      0|                DGifCloseFile(gif, NULL);
  747|      0|                return 0;
  748|      0|              }
  749|      0|              break;
  750|      0|            }
  751|      0|            case DISPOSE_PREVIOUS: {
  ------------------
  |  Branch (751:13): [True: 0, False: 0]
  ------------------
  752|      0|              int src_frame_num = i - 2;
  753|      0|              while (src_frame_num >= 0) {
  ------------------
  |  Branch (753:22): [True: 0, False: 0]
  ------------------
  754|      0|                GraphicsControlBlock src_frame_gcb;
  755|      0|                memset(&src_frame_gcb, 0, sizeof(src_frame_gcb));
  756|      0|                DGifSavedExtensionToGCB(gif, src_frame_num, &src_frame_gcb);
  757|      0|                if (src_frame_gcb.DisposalMode != DISPOSE_PREVIOUS) break;
  ------------------
  |  Branch (757:21): [True: 0, False: 0]
  ------------------
  758|      0|                --src_frame_num;
  759|      0|              }
  760|      0|              if (src_frame_num >= 0) {
  ------------------
  |  Branch (760:19): [True: 0, False: 0]
  ------------------
  761|       |                // Restore pixels inside previous frame rectangle to
  762|       |                // corresponding pixels in source canvas.
  763|      0|                uint8_t* const src_frame_rgba =
  764|      0|                    image->frames[src_frame_num].rgba;
  765|      0|                if (!CopyFrameRectangle(src_frame_rgba, curr_rgba,
  ------------------
  |  Branch (765:21): [True: 0, False: 0]
  ------------------
  766|      0|                                        canvas_width_in_bytes, prev_desc->Left,
  767|      0|                                        prev_desc->Top, prev_desc->Width,
  768|      0|                                        prev_desc->Height)) {
  769|      0|                  DGifCloseFile(gif, NULL);
  770|      0|                  return 0;
  771|      0|                }
  772|      0|              } else {
  773|       |                // Source canvas doesn't exist. So clear previous frame
  774|       |                // rectangle to background.
  775|      0|                if (!ZeroFillFrameRect(curr_rgba, canvas_width_in_bytes,
  ------------------
  |  Branch (775:21): [True: 0, False: 0]
  ------------------
  776|      0|                                       prev_desc->Left, prev_desc->Top,
  777|      0|                                       prev_desc->Width, prev_desc->Height)) {
  778|      0|                  DGifCloseFile(gif, NULL);
  779|      0|                  return 0;
  780|      0|                }
  781|      0|              }
  782|      0|              break;
  783|      0|            }
  784|      0|            default:
  ------------------
  |  Branch (784:13): [True: 0, False: 0]
  ------------------
  785|      0|              break;  // Nothing to do.
  786|      0|          }
  787|      0|        }
  788|      0|      }
  789|      0|    }
  790|       |
  791|       |    // Decode current frame.
  792|      0|    if (!ReadFrameGIF(curr_gif_image, gif->SColorMap, curr_gcb.TransparentColor,
  ------------------
  |  Branch (792:9): [True: 0, False: 0]
  ------------------
  793|      0|                      canvas_width_in_bytes, curr_rgba)) {
  794|      0|      DGifCloseFile(gif, NULL);
  795|      0|      return 0;
  796|      0|    }
  797|       |
  798|      0|    if (dump_frames) {
  ------------------
  |  Branch (798:9): [True: 0, False: 0]
  ------------------
  799|      0|      if (!DumpFrame(filename, dump_folder, i, curr_rgba, canvas_width,
  ------------------
  |  Branch (799:11): [True: 0, False: 0]
  ------------------
  800|      0|                     canvas_height)) {
  801|      0|        DGifCloseFile(gif, NULL);
  802|      0|        return 0;
  803|      0|      }
  804|      0|    }
  805|      0|  }
  806|      0|  image->format = ANIM_GIF;
  807|       |  DGifCloseFile(gif, NULL);
  808|      0|  return 1;
  809|      0|}
anim_util.c:MemoryReadGIF:
  363|  10.9k|static int MemoryReadGIF(GifFileType* gif, GifByteType* dest, int len) {
  364|  10.9k|  GifBufferContext* const ctx = (GifBufferContext*)gif->UserData;
  365|  10.9k|  if (ctx->offset + len > ctx->size) {
  ------------------
  |  Branch (365:7): [True: 57, False: 10.9k]
  ------------------
  366|     57|    len = (int)(ctx->size - ctx->offset);
  367|     57|  }
  368|  10.9k|  if (len > 0) {
  ------------------
  |  Branch (368:7): [True: 10.9k, False: 33]
  ------------------
  369|  10.9k|    memcpy(dest, ctx->data + ctx->offset, len);
  370|  10.9k|    ctx->offset += len;
  371|  10.9k|  }
  372|  10.9k|  return len;
  373|  10.9k|}

GIFDisplayError:
  292|     46|void GIFDisplayError(const GifFileType* const gif, int gif_error) {
  293|       |  // libgif 4.2.0 has retired PrintGifError() and added GifErrorString().
  294|     46|#if LOCAL_GIF_PREREQ(4, 2)
  295|     46|#if LOCAL_GIF_PREREQ(5, 0)
  296|       |  // Static string actually, hence the const char* cast.
  297|     46|  const char* error_str =
  298|     46|      (const char*)GifErrorString((gif == NULL) ? gif_error : gif->Error);
  ------------------
  |  Branch (298:35): [True: 0, False: 46]
  ------------------
  299|       |#else
  300|       |  const char* error_str = (const char*)GifErrorString();
  301|       |  (void)gif;
  302|       |#endif
  303|     46|  if (error_str == NULL) error_str = "Unknown error";
  ------------------
  |  Branch (303:7): [True: 2, False: 44]
  ------------------
  304|     46|  fprintf(stderr, "GIFLib Error %d: %s\n", gif_error, error_str);
  305|       |#else
  306|       |  (void)gif;
  307|       |  fprintf(stderr, "GIFLib Error %d: ", gif_error);
  308|       |  PrintGifError();
  309|       |  fprintf(stderr, "\n");
  310|       |#endif
  311|     46|}

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

IsValidColorspace:
   37|  5.64k|int IsValidColorspace(int webp_csp_mode) {
   38|  5.64k|  return (webp_csp_mode >= MODE_RGB && webp_csp_mode < MODE_LAST);
  ------------------
  |  Branch (38:11): [True: 5.64k, False: 0]
  |  Branch (38:40): [True: 5.64k, False: 0]
  ------------------
   39|  5.64k|}
WebPAllocateDecBuffer:
  184|  2.82k|                                    WebPDecBuffer* const buffer) {
  185|  2.82k|  VP8StatusCode status;
  186|  2.82k|  if (buffer == NULL || width <= 0 || height <= 0) {
  ------------------
  |  Branch (186:7): [True: 0, False: 2.82k]
  |  Branch (186:25): [True: 0, False: 2.82k]
  |  Branch (186:39): [True: 0, False: 2.82k]
  ------------------
  187|      0|    return VP8_STATUS_INVALID_PARAM;
  188|      0|  }
  189|  2.82k|  if (options != NULL) {  // First, apply options if there is any.
  ------------------
  |  Branch (189:7): [True: 2.82k, False: 0]
  ------------------
  190|  2.82k|    if (options->use_cropping) {
  ------------------
  |  Branch (190:9): [True: 0, False: 2.82k]
  ------------------
  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|  2.82k|    if (options->use_scaling) {
  ------------------
  |  Branch (202:9): [True: 0, False: 2.82k]
  ------------------
  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|  2.82k|  }
  217|  2.82k|  buffer->width = width;
  218|  2.82k|  buffer->height = height;
  219|       |
  220|       |  // Then, allocate buffer for real.
  221|  2.82k|  status = AllocateBuffer(buffer);
  222|  2.82k|  if (status != VP8_STATUS_OK) return status;
  ------------------
  |  Branch (222:7): [True: 0, False: 2.82k]
  ------------------
  223|       |
  224|       |  // Use the stride trick if vertical flip is needed.
  225|  2.82k|  if (options != NULL && options->flip) {
  ------------------
  |  Branch (225:7): [True: 2.82k, False: 0]
  |  Branch (225:26): [True: 0, False: 2.82k]
  ------------------
  226|      0|    status = WebPFlipBuffer(buffer);
  227|      0|  }
  228|  2.82k|  return status;
  229|  2.82k|}
WebPInitDecBufferInternal:
  234|  3.90k|int WebPInitDecBufferInternal(WebPDecBuffer* buffer, int version) {
  235|  3.90k|  if (WEBP_ABI_IS_INCOMPATIBLE(version, WEBP_DECODER_ABI_VERSION)) {
  ------------------
  |  |   84|  3.90k|#define WEBP_ABI_IS_INCOMPATIBLE(a, b) (((a) >> 8) != ((b) >> 8))
  |  |  ------------------
  |  |  |  Branch (84:40): [True: 0, False: 3.90k]
  |  |  ------------------
  ------------------
  236|      0|    return 0;  // version mismatch
  237|      0|  }
  238|  3.90k|  if (buffer == NULL) return 0;
  ------------------
  |  Branch (238:7): [True: 0, False: 3.90k]
  ------------------
  239|  3.90k|  WEBP_UNSAFE_MEMSET(buffer, 0, sizeof(*buffer));
  ------------------
  |  |  175|  3.90k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  240|  3.90k|  return 1;
  241|  3.90k|}
WebPFreeDecBuffer:
  243|  3.11k|void WebPFreeDecBuffer(WebPDecBuffer* buffer) {
  244|  3.11k|  if (buffer != NULL) {
  ------------------
  |  Branch (244:7): [True: 3.11k, False: 0]
  ------------------
  245|  3.11k|    if (buffer->is_external_memory <= 0) {
  ------------------
  |  Branch (245:9): [True: 0, False: 3.11k]
  ------------------
  246|      0|      WebPSafeFree(buffer->private_memory);
  247|      0|    }
  248|       |    buffer->private_memory = NULL;
  249|  3.11k|  }
  250|  3.11k|}
WebPAvoidSlowMemory:
  308|  3.87k|                        const WebPBitstreamFeatures* const features) {
  309|  3.87k|  assert(output != NULL);
  310|  3.87k|  return (output->is_external_memory >= 2) &&
  ------------------
  |  Branch (310:10): [True: 0, False: 3.87k]
  ------------------
  311|      0|         WebPIsPremultipliedMode(output->colorspace) &&
  ------------------
  |  Branch (311:10): [True: 0, False: 0]
  ------------------
  312|      0|         (features != NULL && features->has_alpha);
  ------------------
  |  Branch (312:11): [True: 0, False: 0]
  |  Branch (312:31): [True: 0, False: 0]
  ------------------
  313|  3.87k|}
buffer_dec.c:AllocateBuffer:
   92|  2.82k|static VP8StatusCode AllocateBuffer(WebPDecBuffer* const buffer) {
   93|  2.82k|  const int w = buffer->width;
   94|  2.82k|  const int h = buffer->height;
   95|  2.82k|  const WEBP_CSP_MODE mode = buffer->colorspace;
   96|       |
   97|  2.82k|  if (w <= 0 || h <= 0 || !IsValidColorspace(mode)) {
  ------------------
  |  Branch (97:7): [True: 0, False: 2.82k]
  |  Branch (97:17): [True: 0, False: 2.82k]
  |  Branch (97:27): [True: 0, False: 2.82k]
  ------------------
   98|      0|    return VP8_STATUS_INVALID_PARAM;
   99|      0|  }
  100|       |
  101|  2.82k|  if (buffer->is_external_memory <= 0 && buffer->private_memory == NULL) {
  ------------------
  |  Branch (101:7): [True: 0, False: 2.82k]
  |  Branch (101:42): [True: 0, False: 0]
  ------------------
  102|      0|    uint8_t* output;
  103|      0|    int uv_stride = 0, a_stride = 0;
  104|      0|    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|      0|    int stride;
  108|      0|    uint64_t size;
  109|       |
  110|      0|    if ((uint64_t)w * kModeBpp[mode] >= (1ull << 31)) {
  ------------------
  |  Branch (110:9): [True: 0, False: 0]
  ------------------
  111|      0|      return VP8_STATUS_INVALID_PARAM;
  112|      0|    }
  113|      0|    stride = w * kModeBpp[mode];
  114|      0|    size = (uint64_t)stride * h;
  115|      0|    if (!WebPIsRGBMode(mode)) {
  ------------------
  |  Branch (115:9): [True: 0, False: 0]
  ------------------
  116|      0|      uv_stride = (w + 1) / 2;
  117|      0|      uv_size = (uint64_t)uv_stride * ((h + 1) / 2);
  118|      0|      if (mode == MODE_YUVA) {
  ------------------
  |  Branch (118:11): [True: 0, False: 0]
  ------------------
  119|      0|        a_stride = w;
  120|      0|        a_size = (uint64_t)a_stride * h;
  121|      0|      }
  122|      0|    }
  123|      0|    total_size = size + 2 * uv_size + a_size;
  124|       |
  125|      0|    output = (uint8_t*)WebPSafeMalloc(total_size, sizeof(*output));
  126|      0|    if (output == NULL) {
  ------------------
  |  Branch (126:9): [True: 0, False: 0]
  ------------------
  127|      0|      return VP8_STATUS_OUT_OF_MEMORY;
  128|      0|    }
  129|      0|    buffer->private_memory = output;
  130|       |
  131|      0|    if (!WebPIsRGBMode(mode)) {  // YUVA initialization
  ------------------
  |  Branch (131:9): [True: 0, False: 0]
  ------------------
  132|      0|      WebPYUVABuffer* const buf = &buffer->u.YUVA;
  133|      0|      buf->y = output;
  134|      0|      buf->y_stride = stride;
  135|      0|      buf->y_size = (size_t)size;
  136|      0|      buf->u = output + size;
  137|      0|      buf->u_stride = uv_stride;
  138|      0|      buf->u_size = (size_t)uv_size;
  139|      0|      buf->v = output + size + uv_size;
  140|      0|      buf->v_stride = uv_stride;
  141|      0|      buf->v_size = (size_t)uv_size;
  142|      0|      if (mode == MODE_YUVA) {
  ------------------
  |  Branch (142:11): [True: 0, False: 0]
  ------------------
  143|      0|        buf->a = output + size + 2 * uv_size;
  144|      0|      }
  145|      0|      buf->a_size = (size_t)a_size;
  146|      0|      buf->a_stride = a_stride;
  147|      0|    } else {  // RGBA initialization
  148|      0|      WebPRGBABuffer* const buf = &buffer->u.RGBA;
  149|      0|      buf->rgba = output;
  150|      0|      buf->stride = stride;
  151|      0|      buf->size = (size_t)size;
  152|      0|    }
  153|      0|  }
  154|  2.82k|  return CheckDecBuffer(buffer);
  155|  2.82k|}
buffer_dec.c:CheckDecBuffer:
   46|  2.82k|static VP8StatusCode CheckDecBuffer(const WebPDecBuffer* const buffer) {
   47|  2.82k|  int ok = 1;
   48|  2.82k|  const WEBP_CSP_MODE mode = buffer->colorspace;
   49|  2.82k|  const int width = buffer->width;
   50|  2.82k|  const int height = buffer->height;
   51|  2.82k|  if (!IsValidColorspace(mode)) {
  ------------------
  |  Branch (51:7): [True: 0, False: 2.82k]
  ------------------
   52|      0|    ok = 0;
   53|  2.82k|  } else if (!WebPIsRGBMode(mode)) {  // YUV checks
  ------------------
  |  Branch (53:14): [True: 0, False: 2.82k]
  ------------------
   54|      0|    const WebPYUVABuffer* const buf = &buffer->u.YUVA;
   55|      0|    const int uv_width = (width + 1) / 2;
   56|      0|    const int uv_height = (height + 1) / 2;
   57|      0|    const int y_stride = abs(buf->y_stride);
   58|      0|    const int u_stride = abs(buf->u_stride);
   59|      0|    const int v_stride = abs(buf->v_stride);
   60|      0|    const int a_stride = abs(buf->a_stride);
   61|      0|    const uint64_t y_size = MIN_BUFFER_SIZE(width, height, y_stride);
  ------------------
  |  |   44|      0|  ((uint64_t)(STRIDE) * ((HEIGHT) - 1) + (WIDTH))
  ------------------
   62|      0|    const uint64_t u_size = MIN_BUFFER_SIZE(uv_width, uv_height, u_stride);
  ------------------
  |  |   44|      0|  ((uint64_t)(STRIDE) * ((HEIGHT) - 1) + (WIDTH))
  ------------------
   63|      0|    const uint64_t v_size = MIN_BUFFER_SIZE(uv_width, uv_height, v_stride);
  ------------------
  |  |   44|      0|  ((uint64_t)(STRIDE) * ((HEIGHT) - 1) + (WIDTH))
  ------------------
   64|      0|    const uint64_t a_size = MIN_BUFFER_SIZE(width, height, a_stride);
  ------------------
  |  |   44|      0|  ((uint64_t)(STRIDE) * ((HEIGHT) - 1) + (WIDTH))
  ------------------
   65|      0|    ok &= (y_size <= buf->y_size);
   66|      0|    ok &= (u_size <= buf->u_size);
   67|      0|    ok &= (v_size <= buf->v_size);
   68|      0|    ok &= (y_stride >= width);
   69|      0|    ok &= (u_stride >= uv_width);
   70|      0|    ok &= (v_stride >= uv_width);
   71|      0|    ok &= (buf->y != NULL);
   72|      0|    ok &= (buf->u != NULL);
   73|      0|    ok &= (buf->v != NULL);
   74|      0|    if (mode == MODE_YUVA) {
  ------------------
  |  Branch (74:9): [True: 0, False: 0]
  ------------------
   75|      0|      ok &= (a_stride >= width);
   76|      0|      ok &= (a_size <= buf->a_size);
   77|      0|      ok &= (buf->a != NULL);
   78|      0|    }
   79|  2.82k|  } else {  // RGB checks
   80|  2.82k|    const WebPRGBABuffer* const buf = &buffer->u.RGBA;
   81|  2.82k|    const int stride = abs(buf->stride);
   82|  2.82k|    const uint64_t size =
   83|  2.82k|        MIN_BUFFER_SIZE((uint64_t)width * kModeBpp[mode], height, stride);
  ------------------
  |  |   44|  2.82k|  ((uint64_t)(STRIDE) * ((HEIGHT) - 1) + (WIDTH))
  ------------------
   84|  2.82k|    ok &= (size <= buf->size);
   85|  2.82k|    ok &= (stride >= width * kModeBpp[mode]);
   86|  2.82k|    ok &= (buf->rgba != NULL);
   87|  2.82k|  }
   88|  2.82k|  return ok ? VP8_STATUS_OK : VP8_STATUS_INVALID_PARAM;
  ------------------
  |  Branch (88:10): [True: 2.82k, False: 0]
  ------------------
   89|  2.82k|}

VP8InitDithering:
  343|  2.03k|                      VP8Decoder* const dec) {
  344|  2.03k|  assert(dec != NULL);
  345|  2.03k|  if (options != NULL) {
  ------------------
  |  Branch (345:7): [True: 2.03k, False: 0]
  ------------------
  346|  2.03k|    const int d = options->dithering_strength;
  347|  2.03k|    const int max_amp = (1 << VP8_RANDOM_DITHER_FIX) - 1;
  ------------------
  |  |   29|  2.03k|#define VP8_RANDOM_DITHER_FIX 8  // fixed-point precision for dithering
  ------------------
  348|  2.03k|    const int f = (d < 0) ? 0 : (d > 100) ? max_amp : (d * max_amp / 100);
  ------------------
  |  Branch (348:19): [True: 0, False: 2.03k]
  |  Branch (348:33): [True: 0, False: 2.03k]
  ------------------
  349|  2.03k|    if (f > 0) {
  ------------------
  |  Branch (349:9): [True: 0, False: 2.03k]
  ------------------
  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|  2.03k|    dec->alpha_dithering = options->alpha_dithering_strength;
  367|  2.03k|    if (dec->alpha_dithering > 100) {
  ------------------
  |  Branch (367:9): [True: 0, False: 2.03k]
  ------------------
  368|      0|      dec->alpha_dithering = 100;
  369|  2.03k|    } else if (dec->alpha_dithering < 0) {
  ------------------
  |  Branch (369:16): [True: 0, False: 2.03k]
  ------------------
  370|      0|      dec->alpha_dithering = 0;
  371|      0|    }
  372|  2.03k|  }
  373|  2.03k|}
VP8ProcessRow:
  518|  30.5k|int VP8ProcessRow(VP8Decoder* const dec, VP8Io* const io) {
  519|  30.5k|  int ok = 1;
  520|  30.5k|  VP8ThreadContext* const ctx = &dec->thread_ctx;
  521|  30.5k|  const int filter_row = (dec->filter_type > 0) &&
  ------------------
  |  Branch (521:26): [True: 29.3k, False: 1.22k]
  ------------------
  522|  29.3k|                         (dec->mb_y >= dec->tl_mb_y) &&
  ------------------
  |  Branch (522:26): [True: 29.3k, False: 0]
  ------------------
  523|  29.3k|                         (dec->mb_y <= dec->br_mb_y);
  ------------------
  |  Branch (523:26): [True: 29.3k, False: 0]
  ------------------
  524|  30.5k|  if (dec->mt_method == 0) {
  ------------------
  |  Branch (524:7): [True: 30.5k, False: 0]
  ------------------
  525|       |    // ctx->id and ctx->f_info are already set
  526|  30.5k|    ctx->mb_y = dec->mb_y;
  527|  30.5k|    ctx->filter_row = filter_row;
  528|  30.5k|    ReconstructRow(dec, ctx);
  529|  30.5k|    ok = FinishRow(dec, io);
  530|  30.5k|  } 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|  30.5k|  return ok;
  561|  30.5k|}
VP8EnterCritical:
  566|  2.03k|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.03k|  if (io->setup != NULL && !io->setup(io)) {
  ------------------
  |  Branch (569:7): [True: 2.03k, False: 0]
  |  Branch (569:28): [True: 0, False: 2.03k]
  ------------------
  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.03k|  if (io->bypass_filtering) {
  ------------------
  |  Branch (575:7): [True: 0, False: 2.03k]
  ------------------
  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.03k|  {
  589|  2.03k|    const int extra_pixels = kFilterExtraRows[dec->filter_type];
  590|  2.03k|    if (dec->filter_type == 2) {
  ------------------
  |  Branch (590:9): [True: 1.03k, False: 995]
  ------------------
  591|       |      // For complex filter, we need to preserve the dependency chain.
  592|  1.03k|      dec->tl_mb_x = 0;
  593|  1.03k|      dec->tl_mb_y = 0;
  594|  1.03k|    } 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|    995|      dec->tl_mb_x = (io->crop_left - extra_pixels) >> 4;
  600|    995|      dec->tl_mb_y = (io->crop_top - extra_pixels) >> 4;
  601|    995|      if (dec->tl_mb_x < 0) dec->tl_mb_x = 0;
  ------------------
  |  Branch (601:11): [True: 780, False: 215]
  ------------------
  602|    995|      if (dec->tl_mb_y < 0) dec->tl_mb_y = 0;
  ------------------
  |  Branch (602:11): [True: 780, False: 215]
  ------------------
  603|    995|    }
  604|       |    // We need some 'extra' pixels on the right/bottom.
  605|  2.03k|    dec->br_mb_y = (io->crop_bottom + 15 + extra_pixels) >> 4;
  606|  2.03k|    dec->br_mb_x = (io->crop_right + 15 + extra_pixels) >> 4;
  607|  2.03k|    if (dec->br_mb_x > dec->mb_w) {
  ------------------
  |  Branch (607:9): [True: 380, False: 1.65k]
  ------------------
  608|    380|      dec->br_mb_x = dec->mb_w;
  609|    380|    }
  610|  2.03k|    if (dec->br_mb_y > dec->mb_h) {
  ------------------
  |  Branch (610:9): [True: 485, False: 1.54k]
  ------------------
  611|    485|      dec->br_mb_y = dec->mb_h;
  612|    485|    }
  613|  2.03k|  }
  614|  2.03k|  PrecomputeFilterStrengths(dec);
  615|  2.03k|  return VP8_STATUS_OK;
  616|  2.03k|}
VP8ExitCritical:
  618|  2.03k|int VP8ExitCritical(VP8Decoder* const dec, VP8Io* const io) {
  619|  2.03k|  int ok = 1;
  620|  2.03k|  if (dec->mt_method > 0) {
  ------------------
  |  Branch (620:7): [True: 0, False: 2.03k]
  ------------------
  621|      0|    ok = WebPGetWorkerInterface()->Sync(&dec->worker);
  622|      0|  }
  623|       |
  624|  2.03k|  if (io->teardown != NULL) {
  ------------------
  |  Branch (624:7): [True: 2.03k, False: 0]
  ------------------
  625|  2.03k|    io->teardown(io);
  626|  2.03k|  }
  627|  2.03k|  return ok;
  628|  2.03k|}
VP8GetThreadMethod:
  679|  2.03k|                       int height) {
  680|  2.03k|  if (options == NULL || options->use_threads == 0) {
  ------------------
  |  Branch (680:7): [True: 0, False: 2.03k]
  |  Branch (680:26): [True: 2.03k, False: 0]
  ------------------
  681|  2.03k|    return 0;
  682|  2.03k|  }
  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.03k|int VP8InitFrame(VP8Decoder* const dec, VP8Io* const io) {
  814|  2.03k|  if (!InitThreadContext(dec)) return 0;  // call first. Sets dec->num_caches.
  ------------------
  |  Branch (814:7): [True: 0, False: 2.03k]
  ------------------
  815|  2.03k|  if (!AllocateMemory(dec)) return 0;
  ------------------
  |  Branch (815:7): [True: 0, False: 2.03k]
  ------------------
  816|  2.03k|  InitIo(dec, io);
  817|  2.03k|  VP8DspInit();  // Init critical function pointers and look-up tables.
  818|  2.03k|  return 1;
  819|  2.03k|}
frame_dec.c:ReconstructRow:
   84|  30.5k|                           const VP8ThreadContext* ctx) {
   85|  30.5k|  int j;
   86|  30.5k|  int mb_x;
   87|  30.5k|  const int mb_y = ctx->mb_y;
   88|  30.5k|  const int cache_id = ctx->id;
   89|  30.5k|  uint8_t* const y_dst = dec->yuv_b + Y_OFF;
  ------------------
  |  |   67|  30.5k|#define Y_OFF (BPS * 1 + 8)
  |  |  ------------------
  |  |  |  |   33|  30.5k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
   90|  30.5k|  uint8_t* const u_dst = dec->yuv_b + U_OFF;
  ------------------
  |  |   68|  30.5k|#define U_OFF (Y_OFF + BPS * 16 + BPS)
  |  |  ------------------
  |  |  |  |   67|  30.5k|#define Y_OFF (BPS * 1 + 8)
  |  |  |  |  ------------------
  |  |  |  |  |  |   33|  30.5k|#define BPS 32  // this is the common stride for enc/dec
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define U_OFF (Y_OFF + BPS * 16 + BPS)
  |  |  ------------------
  |  |  |  |   33|  30.5k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  |  |               #define U_OFF (Y_OFF + BPS * 16 + BPS)
  |  |  ------------------
  |  |  |  |   33|  30.5k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
   91|  30.5k|  uint8_t* const v_dst = dec->yuv_b + V_OFF;
  ------------------
  |  |   69|  30.5k|#define V_OFF (U_OFF + 16)
  |  |  ------------------
  |  |  |  |   68|  30.5k|#define U_OFF (Y_OFF + BPS * 16 + BPS)
  |  |  |  |  ------------------
  |  |  |  |  |  |   67|  30.5k|#define Y_OFF (BPS * 1 + 8)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   33|  30.5k|#define BPS 32  // this is the common stride for enc/dec
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               #define U_OFF (Y_OFF + BPS * 16 + BPS)
  |  |  |  |  ------------------
  |  |  |  |  |  |   33|  30.5k|#define BPS 32  // this is the common stride for enc/dec
  |  |  |  |  ------------------
  |  |  |  |               #define U_OFF (Y_OFF + BPS * 16 + BPS)
  |  |  |  |  ------------------
  |  |  |  |  |  |   33|  30.5k|#define BPS 32  // this is the common stride for enc/dec
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   92|       |
   93|       |  // Initialize left-most block.
   94|   519k|  for (j = 0; j < 16; ++j) {
  ------------------
  |  Branch (94:15): [True: 488k, False: 30.5k]
  ------------------
   95|   488k|    y_dst[j * BPS - 1] = 129;
  ------------------
  |  |   33|   488k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
   96|   488k|  }
   97|   274k|  for (j = 0; j < 8; ++j) {
  ------------------
  |  Branch (97:15): [True: 244k, False: 30.5k]
  ------------------
   98|   244k|    u_dst[j * BPS - 1] = 129;
  ------------------
  |  |   33|   244k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
   99|   244k|    v_dst[j * BPS - 1] = 129;
  ------------------
  |  |   33|   244k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  100|   244k|  }
  101|       |
  102|       |  // Init top-left sample on left column too.
  103|  30.5k|  if (mb_y > 0) {
  ------------------
  |  Branch (103:7): [True: 29.2k, False: 1.31k]
  ------------------
  104|  29.2k|    y_dst[-1 - BPS] = u_dst[-1 - BPS] = v_dst[-1 - BPS] = 129;
  ------------------
  |  |   33|  29.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|  29.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|  29.2k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  105|  29.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.31k|    WEBP_UNSAFE_MEMSET(y_dst - BPS - 1, 127, 16 + 4 + 1);
  ------------------
  |  |  175|  1.31k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  109|  1.31k|    WEBP_UNSAFE_MEMSET(u_dst - BPS - 1, 127, 8 + 1);
  ------------------
  |  |  175|  1.31k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  110|  1.31k|    WEBP_UNSAFE_MEMSET(v_dst - BPS - 1, 127, 8 + 1);
  ------------------
  |  |  175|  1.31k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  111|  1.31k|  }
  112|       |
  113|       |  // Reconstruct one row.
  114|  75.0k|  for (mb_x = 0; mb_x < dec->mb_w; ++mb_x) {
  ------------------
  |  Branch (114:18): [True: 44.5k, False: 30.5k]
  ------------------
  115|  44.5k|    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|  44.5k|    if (mb_x > 0) {
  ------------------
  |  Branch (119:9): [True: 13.9k, False: 30.5k]
  ------------------
  120|   251k|      for (j = -1; j < 16; ++j) {
  ------------------
  |  Branch (120:20): [True: 237k, False: 13.9k]
  ------------------
  121|   237k|        Copy32b(&y_dst[j * BPS - 4], &y_dst[j * BPS + 12]);
  ------------------
  |  |   33|   237k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
                      Copy32b(&y_dst[j * BPS - 4], &y_dst[j * BPS + 12]);
  ------------------
  |  |   33|   237k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  122|   237k|      }
  123|   139k|      for (j = -1; j < 8; ++j) {
  ------------------
  |  Branch (123:20): [True: 125k, False: 13.9k]
  ------------------
  124|   125k|        Copy32b(&u_dst[j * BPS - 4], &u_dst[j * BPS + 4]);
  ------------------
  |  |   33|   125k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
                      Copy32b(&u_dst[j * BPS - 4], &u_dst[j * BPS + 4]);
  ------------------
  |  |   33|   125k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  125|   125k|        Copy32b(&v_dst[j * BPS - 4], &v_dst[j * BPS + 4]);
  ------------------
  |  |   33|   125k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
                      Copy32b(&v_dst[j * BPS - 4], &v_dst[j * BPS + 4]);
  ------------------
  |  |   33|   125k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  126|   125k|      }
  127|  13.9k|    }
  128|  44.5k|    {
  129|       |      // bring top samples into the cache
  130|  44.5k|      VP8TopSamples* const top_yuv = dec->yuv_t + mb_x;
  131|  44.5k|      const int16_t* const coeffs = block->coeffs;
  132|  44.5k|      uint32_t bits = block->non_zero_y;
  133|  44.5k|      int n;
  134|       |
  135|  44.5k|      if (mb_y > 0) {
  ------------------
  |  Branch (135:11): [True: 35.1k, False: 9.33k]
  ------------------
  136|  35.1k|        WEBP_UNSAFE_MEMCPY(y_dst - BPS, top_yuv[0].y, 16);
  ------------------
  |  |  174|  35.1k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
  137|  35.1k|        WEBP_UNSAFE_MEMCPY(u_dst - BPS, top_yuv[0].u, 8);
  ------------------
  |  |  174|  35.1k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
  138|  35.1k|        WEBP_UNSAFE_MEMCPY(v_dst - BPS, top_yuv[0].v, 8);
  ------------------
  |  |  174|  35.1k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
  139|  35.1k|      }
  140|       |
  141|       |      // predict and add residuals
  142|  44.5k|      if (block->is_i4x4) {  // 4x4
  ------------------
  |  Branch (142:11): [True: 17.8k, False: 26.6k]
  ------------------
  143|  17.8k|        uint32_t* const top_right = (uint32_t*)(y_dst - BPS + 16);
  ------------------
  |  |   33|  17.8k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  144|       |
  145|  17.8k|        if (mb_y > 0) {
  ------------------
  |  Branch (145:13): [True: 13.2k, False: 4.56k]
  ------------------
  146|  13.2k|          if (mb_x >= dec->mb_w - 1) {  // on rightmost border
  ------------------
  |  Branch (146:15): [True: 11.7k, False: 1.49k]
  ------------------
  147|  11.7k|            WEBP_UNSAFE_MEMSET(top_right, top_yuv[0].y[15], sizeof(*top_right));
  ------------------
  |  |  175|  11.7k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  148|  11.7k|          } else {
  149|  1.49k|            WEBP_UNSAFE_MEMCPY(top_right, top_yuv[1].y, sizeof(*top_right));
  ------------------
  |  |  174|  1.49k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
  150|  1.49k|          }
  151|  13.2k|        }
  152|       |        // replicate the top-right pixels below
  153|  17.8k|        top_right[BPS] = top_right[2 * BPS] = top_right[3 * BPS] = top_right[0];
  ------------------
  |  |   33|  17.8k|#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.8k|#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.8k|#define BPS 32  // this is the common stride for enc/dec
  ------------------
  154|       |
  155|       |        // predict and add residuals for all 4x4 blocks in turn.
  156|   303k|        for (n = 0; n < 16; ++n, bits <<= 2) {
  ------------------
  |  Branch (156:21): [True: 285k, False: 17.8k]
  ------------------
  157|   285k|          uint8_t* const dst = y_dst + kScan[n];
  158|   285k|          VP8PredLuma4[block->imodes[n]](dst);
  159|   285k|          DoTransform(bits, coeffs + n * 16, dst);
  160|   285k|        }
  161|  26.6k|      } else {  // 16x16
  162|  26.6k|        const int pred_func = CheckMode(mb_x, mb_y, block->imodes[0]);
  163|  26.6k|        VP8PredLuma16[pred_func](y_dst);
  164|  26.6k|        if (bits != 0) {
  ------------------
  |  Branch (164:13): [True: 6.33k, False: 20.3k]
  ------------------
  165|   107k|          for (n = 0; n < 16; ++n, bits <<= 2) {
  ------------------
  |  Branch (165:23): [True: 101k, False: 6.33k]
  ------------------
  166|   101k|            DoTransform(bits, coeffs + n * 16, y_dst + kScan[n]);
  167|   101k|          }
  168|  6.33k|        }
  169|  26.6k|      }
  170|  44.5k|      {
  171|       |        // Chroma
  172|  44.5k|        const uint32_t bits_uv = block->non_zero_uv;
  173|  44.5k|        const int pred_func = CheckMode(mb_x, mb_y, block->uvmode);
  174|  44.5k|        VP8PredChroma8[pred_func](u_dst);
  175|  44.5k|        VP8PredChroma8[pred_func](v_dst);
  176|  44.5k|        DoUVTransform(bits_uv >> 0, coeffs + 16 * 16, u_dst);
  177|  44.5k|        DoUVTransform(bits_uv >> 8, coeffs + 20 * 16, v_dst);
  178|  44.5k|      }
  179|       |
  180|       |      // stash away top samples for next block
  181|  44.5k|      if (mb_y < dec->mb_h - 1) {
  ------------------
  |  Branch (181:11): [True: 39.6k, False: 4.87k]
  ------------------
  182|  39.6k|        WEBP_UNSAFE_MEMCPY(top_yuv[0].y, y_dst + 15 * BPS, 16);
  ------------------
  |  |  174|  39.6k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
  183|  39.6k|        WEBP_UNSAFE_MEMCPY(top_yuv[0].u, u_dst + 7 * BPS, 8);
  ------------------
  |  |  174|  39.6k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
  184|  39.6k|        WEBP_UNSAFE_MEMCPY(top_yuv[0].v, v_dst + 7 * BPS, 8);
  ------------------
  |  |  174|  39.6k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
  185|  39.6k|      }
  186|  44.5k|    }
  187|       |    // Transfer reconstructed samples from yuv_b cache to final destination.
  188|  44.5k|    {
  189|  44.5k|      const int y_offset = cache_id * 16 * dec->cache_y_stride;
  190|  44.5k|      const int uv_offset = cache_id * 8 * dec->cache_uv_stride;
  191|  44.5k|      uint8_t* const y_out = dec->cache_y + mb_x * 16 + y_offset;
  192|  44.5k|      uint8_t* const u_out = dec->cache_u + mb_x * 8 + uv_offset;
  193|  44.5k|      uint8_t* const v_out = dec->cache_v + mb_x * 8 + uv_offset;
  194|   756k|      for (j = 0; j < 16; ++j) {
  ------------------
  |  Branch (194:19): [True: 712k, False: 44.5k]
  ------------------
  195|   712k|        WEBP_UNSAFE_MEMCPY(y_out + j * dec->cache_y_stride, y_dst + j * BPS,
  ------------------
  |  |  174|   712k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
  196|   712k|                           16);
  197|   712k|      }
  198|   400k|      for (j = 0; j < 8; ++j) {
  ------------------
  |  Branch (198:19): [True: 356k, False: 44.5k]
  ------------------
  199|   356k|        WEBP_UNSAFE_MEMCPY(u_out + j * dec->cache_uv_stride, u_dst + j * BPS,
  ------------------
  |  |  174|   356k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
  200|   356k|                           8);
  201|   356k|        WEBP_UNSAFE_MEMCPY(v_out + j * dec->cache_uv_stride, v_dst + j * BPS,
  ------------------
  |  |  174|   356k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
  202|   356k|                           8);
  203|   356k|      }
  204|  44.5k|    }
  205|  44.5k|  }
  206|  30.5k|}
frame_dec.c:Copy32b:
   51|   489k|static void Copy32b(uint8_t* const dst, const uint8_t* const src) {
   52|   489k|  WEBP_UNSAFE_MEMCPY(dst, src, 4);
  ------------------
  |  |  174|   489k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
   53|   489k|}
frame_dec.c:DoTransform:
   56|   386k|                                    uint8_t* const dst) {
   57|   386k|  switch (bits >> 30) {
   58|  19.3k|    case 3:
  ------------------
  |  Branch (58:5): [True: 19.3k, False: 367k]
  ------------------
   59|  19.3k|      VP8Transform(src, dst, 0);
   60|  19.3k|      break;
   61|  23.9k|    case 2:
  ------------------
  |  Branch (61:5): [True: 23.9k, False: 362k]
  ------------------
   62|  23.9k|      VP8TransformAC3(src, dst);
   63|  23.9k|      break;
   64|  65.8k|    case 1:
  ------------------
  |  Branch (64:5): [True: 65.8k, False: 321k]
  ------------------
   65|  65.8k|      VP8TransformDC(src, dst);
   66|  65.8k|      break;
   67|   277k|    default:
  ------------------
  |  Branch (67:5): [True: 277k, False: 109k]
  ------------------
   68|   277k|      break;
   69|   386k|  }
   70|   386k|}
frame_dec.c:CheckMode:
   40|  71.1k|static int CheckMode(int mb_x, int mb_y, int mode) {
   41|  71.1k|  if (mode == B_DC_PRED) {
  ------------------
  |  Branch (41:7): [True: 32.6k, False: 38.5k]
  ------------------
   42|  32.6k|    if (mb_x == 0) {
  ------------------
  |  Branch (42:9): [True: 21.0k, False: 11.5k]
  ------------------
   43|  21.0k|      return (mb_y == 0) ? B_DC_PRED_NOTOPLEFT : B_DC_PRED_NOLEFT;
  ------------------
  |  Branch (43:14): [True: 997, False: 20.0k]
  ------------------
   44|  21.0k|    } else {
   45|  11.5k|      return (mb_y == 0) ? B_DC_PRED_NOTOP : B_DC_PRED;
  ------------------
  |  Branch (45:14): [True: 5.80k, False: 5.76k]
  ------------------
   46|  11.5k|    }
   47|  32.6k|  }
   48|  38.5k|  return mode;
   49|  71.1k|}
frame_dec.c:DoUVTransform:
   73|  89.0k|                          uint8_t* const dst) {
   74|  89.0k|  if (bits & 0xff) {             // any non-zero coeff at all?
  ------------------
  |  Branch (74:7): [True: 20.0k, False: 69.0k]
  ------------------
   75|  20.0k|    if (bits & 0xaa) {           // any non-zero AC coefficient?
  ------------------
  |  Branch (75:9): [True: 12.9k, False: 7.02k]
  ------------------
   76|  12.9k|      VP8TransformUV(src, dst);  // note we don't use the AC3 variant for U/V
   77|  12.9k|    } else {
   78|  7.02k|      VP8TransformDCUV(src, dst);
   79|  7.02k|    }
   80|  20.0k|  }
   81|  89.0k|}
frame_dec.c:FinishRow:
  416|  30.5k|static int FinishRow(void* arg1, void* arg2) {
  417|  30.5k|  VP8Decoder* const dec = (VP8Decoder*)arg1;
  418|  30.5k|  VP8Io* const io = (VP8Io*)arg2;
  419|  30.5k|  int ok = 1;
  420|  30.5k|  const VP8ThreadContext* const ctx = &dec->thread_ctx;
  421|  30.5k|  const int cache_id = ctx->id;
  422|  30.5k|  const int extra_y_rows = kFilterExtraRows[dec->filter_type];
  423|  30.5k|  const int ysize = extra_y_rows * dec->cache_y_stride;
  424|  30.5k|  const int uvsize = (extra_y_rows / 2) * dec->cache_uv_stride;
  425|  30.5k|  const int y_offset = cache_id * 16 * dec->cache_y_stride;
  426|  30.5k|  const int uv_offset = cache_id * 8 * dec->cache_uv_stride;
  427|  30.5k|  uint8_t* const ydst = dec->cache_y - ysize + y_offset;
  428|  30.5k|  uint8_t* const udst = dec->cache_u - uvsize + uv_offset;
  429|  30.5k|  uint8_t* const vdst = dec->cache_v - uvsize + uv_offset;
  430|  30.5k|  const int mb_y = ctx->mb_y;
  431|  30.5k|  const int is_first_row = (mb_y == 0);
  432|  30.5k|  const int is_last_row = (mb_y >= dec->br_mb_y - 1);
  433|       |
  434|  30.5k|  if (dec->mt_method == 2) {
  ------------------
  |  Branch (434:7): [True: 0, False: 30.5k]
  ------------------
  435|      0|    ReconstructRow(dec, ctx);
  436|      0|  }
  437|       |
  438|  30.5k|  if (ctx->filter_row) {
  ------------------
  |  Branch (438:7): [True: 29.3k, False: 1.22k]
  ------------------
  439|  29.3k|    FilterRow(dec);
  440|  29.3k|  }
  441|       |
  442|  30.5k|  if (dec->dither) {
  ------------------
  |  Branch (442:7): [True: 0, False: 30.5k]
  ------------------
  443|      0|    DitherRow(dec);
  444|      0|  }
  445|       |
  446|  30.5k|  if (io->put != NULL) {
  ------------------
  |  Branch (446:7): [True: 30.5k, False: 0]
  ------------------
  447|  30.5k|    int y_start = MACROBLOCK_VPOS(mb_y);
  ------------------
  |  |  413|  30.5k|#define MACROBLOCK_VPOS(mb_y) ((mb_y) * 16)  // vertical position of a MB
  ------------------
  448|  30.5k|    int y_end = MACROBLOCK_VPOS(mb_y + 1);
  ------------------
  |  |  413|  30.5k|#define MACROBLOCK_VPOS(mb_y) ((mb_y) * 16)  // vertical position of a MB
  ------------------
  449|  30.5k|    if (!is_first_row) {
  ------------------
  |  Branch (449:9): [True: 29.2k, False: 1.31k]
  ------------------
  450|  29.2k|      y_start -= extra_y_rows;
  451|  29.2k|      io->y = ydst;
  452|  29.2k|      io->u = udst;
  453|  29.2k|      io->v = vdst;
  454|  29.2k|    } else {
  455|  1.31k|      io->y = dec->cache_y + y_offset;
  456|  1.31k|      io->u = dec->cache_u + uv_offset;
  457|  1.31k|      io->v = dec->cache_v + uv_offset;
  458|  1.31k|    }
  459|       |
  460|  30.5k|    if (!is_last_row) {
  ------------------
  |  Branch (460:9): [True: 30.4k, False: 112]
  ------------------
  461|  30.4k|      y_end -= extra_y_rows;
  462|  30.4k|    }
  463|  30.5k|    if (y_end > io->crop_bottom) {
  ------------------
  |  Branch (463:9): [True: 110, False: 30.4k]
  ------------------
  464|    110|      y_end = io->crop_bottom;  // make sure we don't overflow on last row.
  465|    110|    }
  466|       |    // If dec->alpha_data is not NULL, we have some alpha plane present.
  467|  30.5k|    io->a = NULL;
  468|  30.5k|    if (dec->alpha_data != NULL && y_start < y_end) {
  ------------------
  |  Branch (468:9): [True: 0, False: 30.5k]
  |  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|  30.5k|    if (y_start < io->crop_top) {
  ------------------
  |  Branch (475:9): [True: 0, False: 30.5k]
  ------------------
  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|  30.5k|    if (y_start < y_end) {
  ------------------
  |  Branch (486:9): [True: 30.5k, False: 0]
  ------------------
  487|  30.5k|      io->y += io->crop_left;
  488|  30.5k|      io->u += io->crop_left >> 1;
  489|  30.5k|      io->v += io->crop_left >> 1;
  490|  30.5k|      if (io->a != NULL) {
  ------------------
  |  Branch (490:11): [True: 0, False: 30.5k]
  ------------------
  491|      0|        io->a += io->crop_left;
  492|      0|      }
  493|  30.5k|      io->mb_y = y_start - io->crop_top;
  494|  30.5k|      io->mb_w = io->crop_right - io->crop_left;
  495|  30.5k|      io->mb_h = y_end - y_start;
  496|  30.5k|      ok = io->put(io);
  497|  30.5k|    }
  498|  30.5k|  }
  499|       |  // rotate top samples if needed
  500|  30.5k|  if (cache_id + 1 == dec->num_caches) {
  ------------------
  |  Branch (500:7): [True: 30.5k, False: 0]
  ------------------
  501|  30.5k|    if (!is_last_row) {
  ------------------
  |  Branch (501:9): [True: 30.4k, False: 112]
  ------------------
  502|  30.4k|      WEBP_UNSAFE_MEMCPY(dec->cache_y - ysize, ydst + 16 * dec->cache_y_stride,
  ------------------
  |  |  174|  30.4k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
  503|  30.4k|                         ysize);
  504|  30.4k|      WEBP_UNSAFE_MEMCPY(dec->cache_u - uvsize, udst + 8 * dec->cache_uv_stride,
  ------------------
  |  |  174|  30.4k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
  505|  30.4k|                         uvsize);
  506|  30.4k|      WEBP_UNSAFE_MEMCPY(dec->cache_v - uvsize, vdst + 8 * dec->cache_uv_stride,
  ------------------
  |  |  174|  30.4k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
  507|  30.4k|                         uvsize);
  508|  30.4k|    }
  509|  30.5k|  }
  510|       |
  511|  30.5k|  return ok;
  512|  30.5k|}
frame_dec.c:FilterRow:
  268|  29.3k|static void FilterRow(const VP8Decoder* const dec) {
  269|  29.3k|  int mb_x;
  270|  29.3k|  const int mb_y = dec->thread_ctx.mb_y;
  271|  29.3k|  assert(dec->thread_ctx.filter_row);
  272|  72.2k|  for (mb_x = dec->tl_mb_x; mb_x < dec->br_mb_x; ++mb_x) {
  ------------------
  |  Branch (272:29): [True: 42.9k, False: 29.3k]
  ------------------
  273|  42.9k|    DoFilter(dec, mb_x, mb_y);
  274|  42.9k|  }
  275|  29.3k|}
frame_dec.c:DoFilter:
  218|  42.9k|static void DoFilter(const VP8Decoder* const dec, int mb_x, int mb_y) {
  219|  42.9k|  const VP8ThreadContext* const ctx = &dec->thread_ctx;
  220|  42.9k|  const int cache_id = ctx->id;
  221|  42.9k|  const int y_bps = dec->cache_y_stride;
  222|  42.9k|  const VP8FInfo* const f_info = ctx->f_info + mb_x;
  223|  42.9k|  uint8_t* const y_dst = dec->cache_y + cache_id * 16 * y_bps + mb_x * 16;
  224|  42.9k|  const int ilevel = f_info->f_ilevel;
  225|  42.9k|  const int limit = f_info->f_limit;
  226|  42.9k|  if (limit == 0) {
  ------------------
  |  Branch (226:7): [True: 12.8k, False: 30.1k]
  ------------------
  227|  12.8k|    return;
  228|  12.8k|  }
  229|  42.9k|  assert(limit >= 3);
  230|  30.1k|  if (dec->filter_type == 1) {  // simple
  ------------------
  |  Branch (230:7): [True: 13.8k, False: 16.3k]
  ------------------
  231|  13.8k|    if (mb_x > 0) {
  ------------------
  |  Branch (231:9): [True: 4.44k, False: 9.35k]
  ------------------
  232|  4.44k|      VP8SimpleHFilter16(y_dst, y_bps, limit + 4);
  233|  4.44k|    }
  234|  13.8k|    if (f_info->f_inner) {
  ------------------
  |  Branch (234:9): [True: 9.84k, False: 3.95k]
  ------------------
  235|  9.84k|      VP8SimpleHFilter16i(y_dst, y_bps, limit);
  236|  9.84k|    }
  237|  13.8k|    if (mb_y > 0) {
  ------------------
  |  Branch (237:9): [True: 9.43k, False: 4.36k]
  ------------------
  238|  9.43k|      VP8SimpleVFilter16(y_dst, y_bps, limit + 4);
  239|  9.43k|    }
  240|  13.8k|    if (f_info->f_inner) {
  ------------------
  |  Branch (240:9): [True: 9.84k, False: 3.95k]
  ------------------
  241|  9.84k|      VP8SimpleVFilter16i(y_dst, y_bps, limit);
  242|  9.84k|    }
  243|  16.3k|  } else {  // complex
  244|  16.3k|    const int uv_bps = dec->cache_uv_stride;
  245|  16.3k|    uint8_t* const u_dst = dec->cache_u + cache_id * 8 * uv_bps + mb_x * 8;
  246|  16.3k|    uint8_t* const v_dst = dec->cache_v + cache_id * 8 * uv_bps + mb_x * 8;
  247|  16.3k|    const int hev_thresh = f_info->hev_thresh;
  248|  16.3k|    if (mb_x > 0) {
  ------------------
  |  Branch (248:9): [True: 5.75k, False: 10.5k]
  ------------------
  249|  5.75k|      VP8HFilter16(y_dst, y_bps, limit + 4, ilevel, hev_thresh);
  250|  5.75k|      VP8HFilter8(u_dst, v_dst, uv_bps, limit + 4, ilevel, hev_thresh);
  251|  5.75k|    }
  252|  16.3k|    if (f_info->f_inner) {
  ------------------
  |  Branch (252:9): [True: 10.6k, False: 5.65k]
  ------------------
  253|  10.6k|      VP8HFilter16i(y_dst, y_bps, limit, ilevel, hev_thresh);
  254|  10.6k|      VP8HFilter8i(u_dst, v_dst, uv_bps, limit, ilevel, hev_thresh);
  255|  10.6k|    }
  256|  16.3k|    if (mb_y > 0) {
  ------------------
  |  Branch (256:9): [True: 13.0k, False: 3.21k]
  ------------------
  257|  13.0k|      VP8VFilter16(y_dst, y_bps, limit + 4, ilevel, hev_thresh);
  258|  13.0k|      VP8VFilter8(u_dst, v_dst, uv_bps, limit + 4, ilevel, hev_thresh);
  259|  13.0k|    }
  260|  16.3k|    if (f_info->f_inner) {
  ------------------
  |  Branch (260:9): [True: 10.6k, False: 5.65k]
  ------------------
  261|  10.6k|      VP8VFilter16i(y_dst, y_bps, limit, ilevel, hev_thresh);
  262|  10.6k|      VP8VFilter8i(u_dst, v_dst, uv_bps, limit, ilevel, hev_thresh);
  263|  10.6k|    }
  264|  16.3k|  }
  265|  30.1k|}
frame_dec.c:PrecomputeFilterStrengths:
  280|  2.03k|static void PrecomputeFilterStrengths(VP8Decoder* const dec) {
  281|  2.03k|  if (dec->filter_type > 0) {
  ------------------
  |  Branch (281:7): [True: 1.81k, False: 215]
  ------------------
  282|  1.81k|    int s;
  283|  1.81k|    const VP8FilterHeader* const hdr = &dec->filter_hdr;
  284|  9.09k|    for (s = 0; s < NUM_MB_SEGMENTS; ++s) {
  ------------------
  |  Branch (284:17): [True: 7.27k, False: 1.81k]
  ------------------
  285|  7.27k|      int i4x4;
  286|       |      // First, compute the initial level
  287|  7.27k|      int base_level;
  288|  7.27k|      if (dec->segment_hdr.use_segment) {
  ------------------
  |  Branch (288:11): [True: 1.85k, False: 5.42k]
  ------------------
  289|  1.85k|        base_level = dec->segment_hdr.filter_strength[s];
  290|  1.85k|        if (!dec->segment_hdr.absolute_delta) {
  ------------------
  |  Branch (290:13): [True: 628, False: 1.22k]
  ------------------
  291|    628|          base_level += hdr->level;
  292|    628|        }
  293|  5.42k|      } else {
  294|  5.42k|        base_level = hdr->level;
  295|  5.42k|      }
  296|  21.8k|      for (i4x4 = 0; i4x4 <= 1; ++i4x4) {
  ------------------
  |  Branch (296:22): [True: 14.5k, False: 7.27k]
  ------------------
  297|  14.5k|        VP8FInfo* const info = &dec->fstrengths[s][i4x4];
  298|  14.5k|        int level = base_level;
  299|  14.5k|        if (hdr->use_lf_delta) {
  ------------------
  |  Branch (299:13): [True: 4.77k, False: 9.76k]
  ------------------
  300|  4.77k|          level += hdr->ref_lf_delta[0];
  301|  4.77k|          if (i4x4) {
  ------------------
  |  Branch (301:15): [True: 2.38k, False: 2.38k]
  ------------------
  302|  2.38k|            level += hdr->mode_lf_delta[0];
  303|  2.38k|          }
  304|  4.77k|        }
  305|  14.5k|        level = (level < 0) ? 0 : (level > 63) ? 63 : level;
  ------------------
  |  Branch (305:17): [True: 1.24k, False: 13.3k]
  |  Branch (305:35): [True: 226, False: 13.0k]
  ------------------
  306|  14.5k|        if (level > 0) {
  ------------------
  |  Branch (306:13): [True: 12.0k, False: 2.50k]
  ------------------
  307|  12.0k|          int ilevel = level;
  308|  12.0k|          if (hdr->sharpness > 0) {
  ------------------
  |  Branch (308:15): [True: 9.34k, False: 2.70k]
  ------------------
  309|  9.34k|            if (hdr->sharpness > 4) {
  ------------------
  |  Branch (309:17): [True: 3.95k, False: 5.38k]
  ------------------
  310|  3.95k|              ilevel >>= 2;
  311|  5.38k|            } else {
  312|  5.38k|              ilevel >>= 1;
  313|  5.38k|            }
  314|  9.34k|            if (ilevel > 9 - hdr->sharpness) {
  ------------------
  |  Branch (314:17): [True: 8.08k, False: 1.25k]
  ------------------
  315|  8.08k|              ilevel = 9 - hdr->sharpness;
  316|  8.08k|            }
  317|  9.34k|          }
  318|  12.0k|          if (ilevel < 1) ilevel = 1;
  ------------------
  |  Branch (318:15): [True: 328, False: 11.7k]
  ------------------
  319|  12.0k|          info->f_ilevel = ilevel;
  320|  12.0k|          info->f_limit = 2 * level + ilevel;
  321|  12.0k|          info->hev_thresh = (level >= 40) ? 2 : (level >= 15) ? 1 : 0;
  ------------------
  |  Branch (321:30): [True: 2.49k, False: 9.54k]
  |  Branch (321:50): [True: 7.23k, False: 2.31k]
  ------------------
  322|  12.0k|        } else {
  323|  2.50k|          info->f_limit = 0;  // no filtering
  324|  2.50k|        }
  325|  14.5k|        info->f_inner = i4x4;
  326|  14.5k|      }
  327|  7.27k|    }
  328|  1.81k|  }
  329|  2.03k|}
frame_dec.c:InitThreadContext:
  658|  2.03k|static int InitThreadContext(VP8Decoder* const dec) {
  659|  2.03k|  dec->cache_id = 0;
  660|  2.03k|  if (dec->mt_method > 0) {
  ------------------
  |  Branch (660:7): [True: 0, False: 2.03k]
  ------------------
  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.03k|  } else {
  672|  2.03k|    dec->num_caches = ST_CACHE_LINES;
  ------------------
  |  |  655|  2.03k|#define ST_CACHE_LINES 1  // 1 cache row only for single-threaded case
  ------------------
  673|  2.03k|  }
  674|  2.03k|  return 1;
  675|  2.03k|}
frame_dec.c:AllocateMemory:
  699|  2.03k|static int AllocateMemory(VP8Decoder* const dec) {
  700|  2.03k|  const int num_caches = dec->num_caches;
  701|  2.03k|  const int mb_w = dec->mb_w;
  702|       |  // Note: we use 'size_t' when there's no overflow risk, uint64_t otherwise.
  703|  2.03k|  const size_t intra_pred_mode_size = 4 * mb_w * sizeof(uint8_t);
  704|  2.03k|  const size_t top_size = sizeof(VP8TopSamples) * mb_w;
  705|  2.03k|  const size_t mb_info_size = (mb_w + 1) * sizeof(VP8MB);
  706|  2.03k|  const size_t f_info_size =
  707|  2.03k|      (dec->filter_type > 0)
  ------------------
  |  Branch (707:7): [True: 1.81k, False: 215]
  ------------------
  708|  2.03k|          ? mb_w * (dec->mt_method > 0 ? 2 : 1) * sizeof(VP8FInfo)
  ------------------
  |  Branch (708:21): [True: 0, False: 1.81k]
  ------------------
  709|  2.03k|          : 0;
  710|  2.03k|  const size_t yuv_size = YUV_SIZE * sizeof(*dec->yuv_b);
  ------------------
  |  |   66|  2.03k|#define YUV_SIZE (BPS * 17 + BPS * 9)
  |  |  ------------------
  |  |  |  |   33|  2.03k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  |  |               #define YUV_SIZE (BPS * 17 + BPS * 9)
  |  |  ------------------
  |  |  |  |   33|  2.03k|#define BPS 32  // this is the common stride for enc/dec
  |  |  ------------------
  ------------------
  711|  2.03k|  const size_t mb_data_size =
  712|  2.03k|      (dec->mt_method == 2 ? 2 : 1) * mb_w * sizeof(*dec->mb_data);
  ------------------
  |  Branch (712:8): [True: 0, False: 2.03k]
  ------------------
  713|  2.03k|  const size_t cache_height =
  714|  2.03k|      (16 * num_caches + kFilterExtraRows[dec->filter_type]) * 3 / 2;
  715|  2.03k|  const size_t cache_size = top_size * cache_height;
  716|       |  // alpha_size is the only one that scales as width x height.
  717|  2.03k|  const uint64_t alpha_size =
  718|  2.03k|      (dec->alpha_data != NULL)
  ------------------
  |  Branch (718:7): [True: 0, False: 2.03k]
  ------------------
  719|  2.03k|          ? (uint64_t)dec->pic_hdr.width * dec->pic_hdr.height
  720|  2.03k|          : 0ULL;
  721|  2.03k|  const uint64_t needed = (uint64_t)intra_pred_mode_size + top_size +
  722|  2.03k|                          mb_info_size + f_info_size + yuv_size + mb_data_size +
  723|  2.03k|                          cache_size + alpha_size + WEBP_ALIGN_CST;
  ------------------
  |  |   70|  2.03k|#define WEBP_ALIGN_CST 31
  ------------------
  724|  2.03k|  uint8_t* mem;
  725|       |
  726|  2.03k|  if (!CheckSizeOverflow(needed)) return 0;  // check for overflow
  ------------------
  |  Branch (726:7): [True: 0, False: 2.03k]
  ------------------
  727|  2.03k|  if (needed > dec->mem_size) {
  ------------------
  |  Branch (727:7): [True: 2.03k, False: 0]
  ------------------
  728|  2.03k|    WebPSafeFree(dec->mem);
  729|  2.03k|    dec->mem_size = 0;
  730|  2.03k|    dec->mem = WebPSafeMalloc(needed, sizeof(uint8_t));
  731|  2.03k|    if (dec->mem == NULL) {
  ------------------
  |  Branch (731:9): [True: 0, False: 2.03k]
  ------------------
  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.03k|    dec->mem_size = (size_t)needed;
  737|  2.03k|  }
  738|       |
  739|  2.03k|  mem = (uint8_t*)dec->mem;
  740|  2.03k|  dec->intra_t = mem;
  741|  2.03k|  mem += intra_pred_mode_size;
  742|       |
  743|  2.03k|  dec->yuv_t = (VP8TopSamples*)mem;
  744|  2.03k|  mem += top_size;
  745|       |
  746|  2.03k|  dec->mb_info = ((VP8MB*)mem) + 1;
  747|  2.03k|  mem += mb_info_size;
  748|       |
  749|  2.03k|  dec->f_info = f_info_size ? (VP8FInfo*)mem : NULL;
  ------------------
  |  Branch (749:17): [True: 1.81k, False: 215]
  ------------------
  750|  2.03k|  mem += f_info_size;
  751|  2.03k|  dec->thread_ctx.id = 0;
  752|  2.03k|  dec->thread_ctx.f_info = dec->f_info;
  753|  2.03k|  if (dec->filter_type > 0 && dec->mt_method > 0) {
  ------------------
  |  Branch (753:7): [True: 1.81k, False: 215]
  |  Branch (753:31): [True: 0, False: 1.81k]
  ------------------
  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.03k|  mem = (uint8_t*)WEBP_ALIGN(mem);
  ------------------
  |  |   72|  2.03k|  (((uintptr_t)(PTR) + WEBP_ALIGN_CST) & ~(uintptr_t)WEBP_ALIGN_CST)
  |  |  ------------------
  |  |  |  |   70|  2.03k|#define WEBP_ALIGN_CST 31
  |  |  ------------------
  |  |                 (((uintptr_t)(PTR) + WEBP_ALIGN_CST) & ~(uintptr_t)WEBP_ALIGN_CST)
  |  |  ------------------
  |  |  |  |   70|  2.03k|#define WEBP_ALIGN_CST 31
  |  |  ------------------
  ------------------
  761|  2.03k|  assert((yuv_size & WEBP_ALIGN_CST) == 0);
  762|  2.03k|  dec->yuv_b = mem;
  763|  2.03k|  mem += yuv_size;
  764|       |
  765|  2.03k|  dec->mb_data = (VP8MBData*)mem;
  766|  2.03k|  dec->thread_ctx.mb_data = (VP8MBData*)mem;
  767|  2.03k|  if (dec->mt_method == 2) {
  ------------------
  |  Branch (767:7): [True: 0, False: 2.03k]
  ------------------
  768|      0|    dec->thread_ctx.mb_data += mb_w;
  769|      0|  }
  770|  2.03k|  mem += mb_data_size;
  771|       |
  772|  2.03k|  dec->cache_y_stride = 16 * mb_w;
  773|  2.03k|  dec->cache_uv_stride = 8 * mb_w;
  774|  2.03k|  {
  775|  2.03k|    const int extra_rows = kFilterExtraRows[dec->filter_type];
  776|  2.03k|    const int extra_y = extra_rows * dec->cache_y_stride;
  777|  2.03k|    const int extra_uv = (extra_rows / 2) * dec->cache_uv_stride;
  778|  2.03k|    dec->cache_y = mem + extra_y;
  779|  2.03k|    dec->cache_u =
  780|  2.03k|        dec->cache_y + 16 * num_caches * dec->cache_y_stride + extra_uv;
  781|  2.03k|    dec->cache_v =
  782|  2.03k|        dec->cache_u + 8 * num_caches * dec->cache_uv_stride + extra_uv;
  783|  2.03k|    dec->cache_id = 0;
  784|  2.03k|  }
  785|  2.03k|  mem += cache_size;
  786|       |
  787|       |  // alpha plane
  788|  2.03k|  dec->alpha_plane = alpha_size ? mem : NULL;
  ------------------
  |  Branch (788:22): [True: 0, False: 2.03k]
  ------------------
  789|  2.03k|  mem += alpha_size;
  790|  2.03k|  assert(mem <= (uint8_t*)dec->mem + dec->mem_size);
  791|       |
  792|       |  // note: left/top-info is initialized once for all.
  793|  2.03k|  WEBP_UNSAFE_MEMSET(dec->mb_info - 1, 0, mb_info_size);
  ------------------
  |  |  175|  2.03k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  794|  2.03k|  VP8InitScanline(dec);  // initialize left too.
  795|       |
  796|       |  // initialize top
  797|  2.03k|  WEBP_UNSAFE_MEMSET(dec->intra_t, B_DC_PRED, intra_pred_mode_size);
  ------------------
  |  |  175|  2.03k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  798|       |
  799|  2.03k|  return 1;
  800|  2.03k|}
frame_dec.c:InitIo:
  802|  2.03k|static void InitIo(VP8Decoder* const dec, VP8Io* io) {
  803|       |  // prepare 'io'
  804|  2.03k|  io->mb_y = 0;
  805|  2.03k|  io->y = dec->cache_y;
  806|  2.03k|  io->u = dec->cache_u;
  807|  2.03k|  io->v = dec->cache_v;
  808|  2.03k|  io->y_stride = dec->cache_y_stride;
  809|  2.03k|  io->uv_stride = dec->cache_uv_stride;
  810|       |  io->a = NULL;
  811|  2.03k|}

WebPInitCustomIo:
  662|  3.85k|void WebPInitCustomIo(WebPDecParams* const params, VP8Io* const io) {
  663|  3.85k|  io->put = CustomPut;
  664|  3.85k|  io->setup = CustomSetup;
  665|  3.85k|  io->teardown = CustomTeardown;
  666|  3.85k|  io->opaque = params;
  667|  3.85k|}
io_dec.c:CustomPut:
  633|  30.5k|static int CustomPut(const VP8Io* io) {
  634|  30.5k|  WebPDecParams* const p = (WebPDecParams*)io->opaque;
  635|  30.5k|  const int mb_w = io->mb_w;
  636|  30.5k|  const int mb_h = io->mb_h;
  637|  30.5k|  int num_lines_out;
  638|  30.5k|  assert(!(io->mb_y & 1));
  639|       |
  640|  30.5k|  if (mb_w <= 0 || mb_h <= 0) {
  ------------------
  |  Branch (640:7): [True: 0, False: 30.5k]
  |  Branch (640:20): [True: 0, False: 30.5k]
  ------------------
  641|      0|    return 0;
  642|      0|  }
  643|  30.5k|  num_lines_out = p->emit(io, p);
  644|  30.5k|  if (p->emit_alpha != NULL) {
  ------------------
  |  Branch (644:7): [True: 30.5k, False: 0]
  ------------------
  645|  30.5k|    p->emit_alpha(io, p, num_lines_out);
  646|  30.5k|  }
  647|  30.5k|  p->last_y += num_lines_out;
  648|  30.5k|  return 1;
  649|  30.5k|}
io_dec.c:CustomSetup:
  568|  2.03k|static int CustomSetup(VP8Io* io) {
  569|  2.03k|  WebPDecParams* const p = (WebPDecParams*)io->opaque;
  570|  2.03k|  const WEBP_CSP_MODE colorspace = p->output->colorspace;
  571|  2.03k|  const int is_rgb = WebPIsRGBMode(colorspace);
  572|  2.03k|  const int is_alpha = WebPIsAlphaMode(colorspace);
  573|       |
  574|  2.03k|  p->memory = NULL;
  575|  2.03k|  p->emit = NULL;
  576|  2.03k|  p->emit_alpha = NULL;
  577|  2.03k|  p->emit_alpha_row = NULL;
  578|       |  // Note: WebPIoInitFromOptions() does not distinguish between MODE_YUV and
  579|       |  // MODE_YUVA, only RGB vs YUV.
  580|  2.03k|  if (!WebPIoInitFromOptions(p->options, io, /*src_colorspace=*/MODE_YUV)) {
  ------------------
  |  Branch (580:7): [True: 0, False: 2.03k]
  ------------------
  581|      0|    return 0;
  582|      0|  }
  583|  2.03k|  if (is_alpha && WebPIsPremultipliedMode(colorspace)) {
  ------------------
  |  Branch (583:7): [True: 2.03k, False: 0]
  |  Branch (583:19): [True: 0, False: 2.03k]
  ------------------
  584|      0|    WebPInitUpsamplers();
  585|      0|  }
  586|  2.03k|  if (io->use_scaling) {
  ------------------
  |  Branch (586:7): [True: 0, False: 2.03k]
  ------------------
  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.03k|  } else {
  596|  2.03k|    if (is_rgb) {
  ------------------
  |  Branch (596:9): [True: 2.03k, False: 0]
  ------------------
  597|  2.03k|      WebPInitSamplers();
  598|  2.03k|      p->emit = EmitSampledRGB;  // default
  599|  2.03k|      if (io->fancy_upsampling) {
  ------------------
  |  Branch (599:11): [True: 2.03k, False: 0]
  ------------------
  600|  2.03k|#ifdef FANCY_UPSAMPLING
  601|  2.03k|        const int uv_width = (io->mb_w + 1) >> 1;
  602|  2.03k|        p->memory = WebPSafeMalloc(1ULL, (size_t)(io->mb_w + 2 * uv_width));
  603|  2.03k|        if (p->memory == NULL) {
  ------------------
  |  Branch (603:13): [True: 0, False: 2.03k]
  ------------------
  604|      0|          return 0;  // memory error.
  605|      0|        }
  606|  2.03k|        p->tmp_y = (uint8_t*)p->memory;
  607|  2.03k|        p->tmp_u = p->tmp_y + io->mb_w;
  608|  2.03k|        p->tmp_v = p->tmp_u + uv_width;
  609|  2.03k|        p->emit = EmitFancyRGB;
  610|  2.03k|        WebPInitUpsamplers();
  611|  2.03k|#endif
  612|  2.03k|      }
  613|  2.03k|    } else {
  614|      0|      p->emit = EmitYUV;
  615|      0|    }
  616|  2.03k|    if (is_alpha) {  // need transparency output
  ------------------
  |  Branch (616:9): [True: 2.03k, False: 0]
  ------------------
  617|  2.03k|      p->emit_alpha =
  618|  2.03k|          (colorspace == MODE_RGBA_4444 || colorspace == MODE_rgbA_4444)
  ------------------
  |  Branch (618:12): [True: 0, False: 2.03k]
  |  Branch (618:44): [True: 0, False: 2.03k]
  ------------------
  619|  2.03k|              ? EmitAlphaRGBA4444
  620|  2.03k|          : is_rgb ? EmitAlphaRGB
  ------------------
  |  Branch (620:13): [True: 2.03k, False: 0]
  ------------------
  621|  2.03k|                   : EmitAlphaYUV;
  622|  2.03k|      if (is_rgb) {
  ------------------
  |  Branch (622:11): [True: 2.03k, False: 0]
  ------------------
  623|  2.03k|        WebPInitAlphaProcessing();
  624|  2.03k|      }
  625|  2.03k|    }
  626|  2.03k|  }
  627|       |
  628|  2.03k|  return 1;
  629|  2.03k|}
io_dec.c:EmitFancyRGB:
   66|  30.5k|static int EmitFancyRGB(const VP8Io* const io, WebPDecParams* const p) {
   67|  30.5k|  int num_lines_out = io->mb_h;  // a priori guess
   68|  30.5k|  const WebPRGBABuffer* const buf = &p->output->u.RGBA;
   69|  30.5k|  uint8_t* dst = buf->rgba + (ptrdiff_t)io->mb_y * buf->stride;
   70|  30.5k|  WebPUpsampleLinePairFunc upsample = WebPUpsamplers[p->output->colorspace];
   71|  30.5k|  const uint8_t* cur_y = io->y;
   72|  30.5k|  const uint8_t* cur_u = io->u;
   73|  30.5k|  const uint8_t* cur_v = io->v;
   74|  30.5k|  const uint8_t* top_u = p->tmp_u;
   75|  30.5k|  const uint8_t* top_v = p->tmp_v;
   76|  30.5k|  int y = io->mb_y;
   77|  30.5k|  const int y_end = io->mb_y + io->mb_h;
   78|  30.5k|  const int mb_w = io->mb_w;
   79|  30.5k|  const int uv_w = (mb_w + 1) / 2;
   80|       |
   81|  30.5k|  if (y == 0) {
  ------------------
  |  Branch (81:7): [True: 1.31k, False: 29.2k]
  ------------------
   82|       |    // First line is special cased. We mirror the u/v samples at boundary.
   83|  1.31k|    upsample(cur_y, NULL, cur_u, cur_v, cur_u, cur_v, dst, NULL, mb_w);
   84|  29.2k|  } else {
   85|       |    // We can finish the left-over line from previous call.
   86|  29.2k|    upsample(p->tmp_y, cur_y, top_u, top_v, cur_u, cur_v, dst - buf->stride,
   87|  29.2k|             dst, mb_w);
   88|  29.2k|    ++num_lines_out;
   89|  29.2k|  }
   90|       |  // Loop over each output pairs of row.
   91|   240k|  for (; y + 2 < y_end; y += 2) {
  ------------------
  |  Branch (91:10): [True: 210k, False: 30.5k]
  ------------------
   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.5k|  cur_y += io->y_stride;
  103|  30.5k|  if (io->crop_top + y_end < io->crop_bottom) {
  ------------------
  |  Branch (103:7): [True: 30.4k, False: 112]
  ------------------
  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|    112|    if (!(y_end & 1)) {
  ------------------
  |  Branch (113:9): [True: 55, False: 57]
  ------------------
  114|     55|      upsample(cur_y, NULL, cur_u, cur_v, cur_u, cur_v, dst + buf->stride, NULL,
  115|     55|               mb_w);
  116|     55|    }
  117|    112|  }
  118|  30.5k|  return num_lines_out;
  119|  30.5k|}
io_dec.c:EmitAlphaRGB:
  183|  30.5k|                        int expected_num_lines_out) {
  184|  30.5k|  const uint8_t* alpha = io->a;
  185|  30.5k|  if (alpha != NULL) {
  ------------------
  |  Branch (185:7): [True: 0, False: 30.5k]
  ------------------
  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|  30.5k|  return 0;
  206|  30.5k|}
io_dec.c:CustomTeardown:
  653|  2.03k|static void CustomTeardown(const VP8Io* io) {
  654|  2.03k|  WebPDecParams* const p = (WebPDecParams*)io->opaque;
  655|  2.03k|  WebPSafeFree(p->memory);
  656|       |  p->memory = NULL;
  657|  2.03k|}

VP8ParseQuant:
   50|  2.03k|void VP8ParseQuant(VP8Decoder* const dec) {
   51|  2.03k|  VP8BitReader* const br = &dec->br;
   52|  2.03k|  const int base_q0 = VP8GetValue(br, 7, "global-header");
  ------------------
  |  |   43|  2.03k|#define VP8GetValue(BR, N, L) VP8GetValue(BR, N)
  ------------------
   53|  2.03k|  const int dqy1_dc = VP8Get(br, "global-header")
  ------------------
  |  |   44|  2.03k|#define VP8Get(BR, L) VP8GetValue(BR, 1, L)
  |  |  ------------------
  |  |  |  |   43|  2.03k|#define VP8GetValue(BR, N, L) VP8GetValue(BR, N)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (43:31): [True: 713, False: 1.32k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   54|  2.03k|                          ? VP8GetSignedValue(br, 4, "global-header")
  ------------------
  |  |   45|    713|#define VP8GetSignedValue(BR, N, L) VP8GetSignedValue(BR, N)
  ------------------
   55|  2.03k|                          : 0;
   56|  2.03k|  const int dqy2_dc = VP8Get(br, "global-header")
  ------------------
  |  |   44|  2.03k|#define VP8Get(BR, L) VP8GetValue(BR, 1, L)
  |  |  ------------------
  |  |  |  |   43|  2.03k|#define VP8GetValue(BR, N, L) VP8GetValue(BR, N)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (43:31): [True: 760, False: 1.27k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   57|  2.03k|                          ? VP8GetSignedValue(br, 4, "global-header")
  ------------------
  |  |   45|    760|#define VP8GetSignedValue(BR, N, L) VP8GetSignedValue(BR, N)
  ------------------
   58|  2.03k|                          : 0;
   59|  2.03k|  const int dqy2_ac = VP8Get(br, "global-header")
  ------------------
  |  |   44|  2.03k|#define VP8Get(BR, L) VP8GetValue(BR, 1, L)
  |  |  ------------------
  |  |  |  |   43|  2.03k|#define VP8GetValue(BR, N, L) VP8GetValue(BR, N)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (43:31): [True: 864, False: 1.16k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   60|  2.03k|                          ? VP8GetSignedValue(br, 4, "global-header")
  ------------------
  |  |   45|    864|#define VP8GetSignedValue(BR, N, L) VP8GetSignedValue(BR, N)
  ------------------
   61|  2.03k|                          : 0;
   62|  2.03k|  const int dquv_dc = VP8Get(br, "global-header")
  ------------------
  |  |   44|  2.03k|#define VP8Get(BR, L) VP8GetValue(BR, 1, L)
  |  |  ------------------
  |  |  |  |   43|  2.03k|#define VP8GetValue(BR, N, L) VP8GetValue(BR, N)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (43:31): [True: 624, False: 1.40k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   63|  2.03k|                          ? VP8GetSignedValue(br, 4, "global-header")
  ------------------
  |  |   45|    624|#define VP8GetSignedValue(BR, N, L) VP8GetSignedValue(BR, N)
  ------------------
   64|  2.03k|                          : 0;
   65|  2.03k|  const int dquv_ac = VP8Get(br, "global-header")
  ------------------
  |  |   44|  2.03k|#define VP8Get(BR, L) VP8GetValue(BR, 1, L)
  |  |  ------------------
  |  |  |  |   43|  2.03k|#define VP8GetValue(BR, N, L) VP8GetValue(BR, N)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (43:31): [True: 641, False: 1.39k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   66|  2.03k|                          ? VP8GetSignedValue(br, 4, "global-header")
  ------------------
  |  |   45|    641|#define VP8GetSignedValue(BR, N, L) VP8GetSignedValue(BR, N)
  ------------------
   67|  2.03k|                          : 0;
   68|       |
   69|  2.03k|  const VP8SegmentHeader* const hdr = &dec->segment_hdr;
   70|  2.03k|  int i;
   71|       |
   72|  10.1k|  for (i = 0; i < NUM_MB_SEGMENTS; ++i) {
  ------------------
  |  Branch (72:15): [True: 8.13k, False: 2.03k]
  ------------------
   73|  8.13k|    int q;
   74|  8.13k|    if (hdr->use_segment) {
  ------------------
  |  Branch (74:9): [True: 1.98k, False: 6.14k]
  ------------------
   75|  1.98k|      q = hdr->quantizer[i];
   76|  1.98k|      if (!hdr->absolute_delta) {
  ------------------
  |  Branch (76:11): [True: 692, False: 1.29k]
  ------------------
   77|    692|        q += base_q0;
   78|    692|      }
   79|  6.14k|    } else {
   80|  6.14k|      if (i > 0) {
  ------------------
  |  Branch (80:11): [True: 4.60k, False: 1.53k]
  ------------------
   81|  4.60k|        dec->dqm[i] = dec->dqm[0];
   82|  4.60k|        continue;
   83|  4.60k|      } else {
   84|  1.53k|        q = base_q0;
   85|  1.53k|      }
   86|  6.14k|    }
   87|  3.52k|    {
   88|  3.52k|      VP8QuantMatrix* const m = &dec->dqm[i];
   89|  3.52k|      m->y1_mat[0] = kDcTable[clip(q + dqy1_dc, 127)];
   90|  3.52k|      m->y1_mat[1] = kAcTable[clip(q + 0, 127)];
   91|       |
   92|  3.52k|      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.52k|      m->y2_mat[1] = (kAcTable[clip(q + dqy2_ac, 127)] * 101581) >> 16;
   97|  3.52k|      if (m->y2_mat[1] < 8) m->y2_mat[1] = 8;
  ------------------
  |  Branch (97:11): [True: 1.47k, False: 2.05k]
  ------------------
   98|       |
   99|  3.52k|      m->uv_mat[0] = kDcTable[clip(q + dquv_dc, 117)];
  100|  3.52k|      m->uv_mat[1] = kAcTable[clip(q + dquv_ac, 127)];
  101|       |
  102|  3.52k|      m->uv_quant = q + dquv_ac;  // for dithering strength evaluation
  103|  3.52k|    }
  104|  3.52k|  }
  105|  2.03k|}
quant_dec.c:clip:
   22|  21.1k|static WEBP_INLINE int clip(int v, int M) { return v < 0 ? 0 : v > M ? M : v; }
  ------------------
  |  Branch (22:52): [True: 4.13k, False: 17.0k]
  |  Branch (22:64): [True: 1.22k, False: 15.7k]
  ------------------

VP8ResetProba:
  251|  2.13k|void VP8ResetProba(VP8Proba* const proba) {
  252|  2.13k|  WEBP_UNSAFE_MEMSET(proba->segments, 255u, sizeof(proba->segments));
  ------------------
  |  |  175|  2.13k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  253|       |  // proba->bands[][] is initialized later
  254|  2.13k|}
VP8ParseIntraModeRow:
  333|  32.4k|int VP8ParseIntraModeRow(VP8BitReader* const br, VP8Decoder* const dec) {
  334|  32.4k|  int mb_x;
  335|   117k|  for (mb_x = 0; mb_x < dec->mb_w; ++mb_x) {
  ------------------
  |  Branch (335:18): [True: 84.9k, False: 32.4k]
  ------------------
  336|  84.9k|    ParseIntraMode(br, dec, mb_x);
  337|  84.9k|  }
  338|  32.4k|  return !dec->br.eof;
  339|  32.4k|}
VP8ParseProba:
  450|  2.03k|void VP8ParseProba(VP8BitReader* const br, VP8Decoder* const dec) {
  451|  2.03k|  VP8Proba* const proba = &dec->proba;
  452|  2.03k|  int t, b, c, p;
  453|  10.1k|  for (t = 0; t < NUM_TYPES; ++t) {
  ------------------
  |  Branch (453:15): [True: 8.13k, False: 2.03k]
  ------------------
  454|  73.1k|    for (b = 0; b < NUM_BANDS; ++b) {
  ------------------
  |  Branch (454:17): [True: 65.0k, False: 8.13k]
  ------------------
  455|   260k|      for (c = 0; c < NUM_CTX; ++c) {
  ------------------
  |  Branch (455:19): [True: 195k, False: 65.0k]
  ------------------
  456|  2.34M|        for (p = 0; p < NUM_PROBAS; ++p) {
  ------------------
  |  Branch (456:21): [True: 2.14M, False: 195k]
  ------------------
  457|  2.14M|          const int v =
  458|  2.14M|              VP8GetBit(br, CoeffsUpdateProba[t][b][c][p], "global-header")
  ------------------
  |  |   46|  2.14M|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  |  |  ------------------
  |  |  |  Branch (46:29): [True: 64.1k, False: 2.08M]
  |  |  ------------------
  ------------------
  459|  2.14M|                  ? VP8GetValue(br, 8, "global-header")
  ------------------
  |  |   43|  64.1k|#define VP8GetValue(BR, N, L) VP8GetValue(BR, N)
  ------------------
  460|  2.14M|                  : CoeffsProba0[t][b][c][p];
  461|  2.14M|          proba->bands[t][b].probas[c][p] = v;
  462|  2.14M|        }
  463|   195k|      }
  464|  65.0k|    }
  465|   146k|    for (b = 0; b < 16 + 1; ++b) {
  ------------------
  |  Branch (465:17): [True: 138k, False: 8.13k]
  ------------------
  466|   138k|      proba->bands_ptr[t][b] = &proba->bands[t][kBands[b]];
  467|   138k|    }
  468|  8.13k|  }
  469|  2.03k|  dec->use_skip_proba = VP8Get(br, "global-header");
  ------------------
  |  |   44|  2.03k|#define VP8Get(BR, L) VP8GetValue(BR, 1, L)
  |  |  ------------------
  |  |  |  |   43|  2.03k|#define VP8GetValue(BR, N, L) VP8GetValue(BR, N)
  |  |  ------------------
  ------------------
  470|  2.03k|  if (dec->use_skip_proba) {
  ------------------
  |  Branch (470:7): [True: 739, False: 1.29k]
  ------------------
  471|    739|    dec->skip_p = VP8GetValue(br, 8, "global-header");
  ------------------
  |  |   43|    739|#define VP8GetValue(BR, N, L) VP8GetValue(BR, N)
  ------------------
  472|    739|  }
  473|  2.03k|}
tree_dec.c:ParseIntraMode:
  257|  84.9k|                           int mb_x) {
  258|  84.9k|  uint8_t* const top = dec->intra_t + 4 * mb_x;
  259|  84.9k|  uint8_t* const left = dec->intra_l;
  260|  84.9k|  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|  84.9k|  if (dec->segment_hdr.update_map) {
  ------------------
  |  Branch (264:7): [True: 27.0k, False: 57.8k]
  ------------------
  265|       |    // Hardcoded tree parsing
  266|  27.0k|    block->segment =
  267|  27.0k|        !VP8GetBit(br, dec->proba.segments[0], "segments")
  ------------------
  |  |   46|  27.0k|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  ------------------
  |  Branch (267:9): [True: 18.6k, False: 8.42k]
  ------------------
  268|  27.0k|            ? VP8GetBit(br, dec->proba.segments[1], "segments")
  ------------------
  |  |   46|  18.6k|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  ------------------
  269|  27.0k|            : VP8GetBit(br, dec->proba.segments[2], "segments") + 2;
  ------------------
  |  |   46|  8.42k|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  ------------------
  270|  57.8k|  } else {
  271|  57.8k|    block->segment = 0;  // default for intra
  272|  57.8k|  }
  273|  84.9k|  if (dec->use_skip_proba) block->skip = VP8GetBit(br, dec->skip_p, "skip");
  ------------------
  |  |   46|  41.6k|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  ------------------
  |  Branch (273:7): [True: 41.6k, False: 43.2k]
  ------------------
  274|       |
  275|  84.9k|  block->is_i4x4 = !VP8GetBit(br, 145, "block-size");
  ------------------
  |  |   46|  84.9k|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  ------------------
  276|  84.9k|  if (!block->is_i4x4) {
  ------------------
  |  Branch (276:7): [True: 30.6k, False: 54.3k]
  ------------------
  277|       |    // Hardcoded 16x16 intra-mode decision tree.
  278|  30.6k|    const int ymode =
  279|  30.6k|        VP8GetBit(br, 156, "pred-modes")
  ------------------
  |  |   46|  30.6k|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  |  |  ------------------
  |  |  |  Branch (46:29): [True: 16.8k, False: 13.7k]
  |  |  ------------------
  ------------------
  280|  30.6k|            ? (VP8GetBit(br, 128, "pred-modes") ? TM_PRED : H_PRED)
  ------------------
  |  |   46|  16.8k|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  |  |  ------------------
  |  |  |  Branch (46:29): [True: 11.8k, False: 4.96k]
  |  |  ------------------
  ------------------
  281|  30.6k|            : (VP8GetBit(br, 163, "pred-modes") ? V_PRED : DC_PRED);
  ------------------
  |  |   46|  13.7k|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  |  |  ------------------
  |  |  |  Branch (46:29): [True: 3.73k, False: 10.0k]
  |  |  ------------------
  ------------------
  282|  30.6k|    block->imodes[0] = ymode;
  283|  30.6k|    WEBP_UNSAFE_MEMSET(top, ymode, 4 * sizeof(*top));
  ------------------
  |  |  175|  30.6k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  284|  30.6k|    WEBP_UNSAFE_MEMSET(left, ymode, 4 * sizeof(*left));
  ------------------
  |  |  175|  30.6k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  285|  54.3k|  } else {
  286|  54.3k|    uint8_t* modes = block->imodes;
  287|  54.3k|    int y;
  288|   271k|    for (y = 0; y < 4; ++y) {
  ------------------
  |  Branch (288:17): [True: 217k, False: 54.3k]
  ------------------
  289|   217k|      int ymode = left[y];
  290|   217k|      int x;
  291|  1.08M|      for (x = 0; x < 4; ++x) {
  ------------------
  |  Branch (291:19): [True: 869k, False: 217k]
  ------------------
  292|   869k|        const uint8_t* const prob = kBModesProba[top[x]][ymode];
  293|   869k|#if (USE_GENERIC_TREE == 1)
  294|       |        // Generic tree-parsing
  295|   869k|        int i = kYModesIntra4[VP8GetBit(br, prob[0], "pred-modes")];
  ------------------
  |  |   46|   869k|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  ------------------
  296|  1.10M|        while (i > 0) {
  ------------------
  |  Branch (296:16): [True: 236k, False: 869k]
  ------------------
  297|   236k|          i = kYModesIntra4[2 * i + VP8GetBit(br, prob[i], "pred-modes")];
  ------------------
  |  |   46|   236k|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  ------------------
  298|   236k|        }
  299|   869k|        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|   869k|        top[x] = ymode;
  320|   869k|      }
  321|   217k|      WEBP_UNSAFE_MEMCPY(modes, top, 4 * sizeof(*top));
  ------------------
  |  |  174|   217k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
  322|   217k|      modes += 4;
  323|   217k|      left[y] = ymode;
  324|   217k|    }
  325|  54.3k|  }
  326|       |  // Hardcoded UVMode decision tree
  327|  84.9k|  block->uvmode = !VP8GetBit(br, 142, "pred-modes-uv")   ? DC_PRED
  ------------------
  |  |   46|  84.9k|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  ------------------
  |  Branch (327:19): [True: 60.3k, False: 24.5k]
  ------------------
  328|  84.9k|                  : !VP8GetBit(br, 114, "pred-modes-uv") ? V_PRED
  ------------------
  |  |   46|  24.5k|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  ------------------
  |  Branch (328:21): [True: 7.35k, False: 17.2k]
  ------------------
  329|  24.5k|                  : VP8GetBit(br, 183, "pred-modes-uv")  ? TM_PRED
  ------------------
  |  |   46|  17.2k|#define VP8GetBit(BR, P, L) VP8GetBit(BR, P)
  |  |  ------------------
  |  |  |  Branch (46:29): [True: 10.4k, False: 6.75k]
  |  |  ------------------
  ------------------
  330|  17.2k|                                                         : H_PRED;
  331|  84.9k|}

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

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

VP8LCheckSignature:
  109|  33.9k|                       size_t size) {
  110|  33.9k|  return (size >= VP8L_FRAME_HEADER_SIZE && data[0] == VP8L_MAGIC_BYTE &&
  ------------------
  |  |   33|  67.8k|#define VP8L_FRAME_HEADER_SIZE 5  // Size of the VP8L frame header.
  ------------------
                return (size >= VP8L_FRAME_HEADER_SIZE && data[0] == VP8L_MAGIC_BYTE &&
  ------------------
  |  |   28|  67.8k|#define VP8L_MAGIC_BYTE 0x2f   // VP8L signature byte.
  ------------------
  |  Branch (110:11): [True: 33.9k, False: 0]
  |  Branch (110:45): [True: 20.8k, False: 13.1k]
  ------------------
  111|  20.8k|          (data[4] >> 5) == 0);  // version
  ------------------
  |  Branch (111:11): [True: 20.7k, False: 29]
  ------------------
  112|  33.9k|}
VP8LGetInfo:
  126|  10.4k|                int* const has_alpha) {
  127|  10.4k|  if (data == NULL || data_size < VP8L_FRAME_HEADER_SIZE) {
  ------------------
  |  |   33|  10.4k|#define VP8L_FRAME_HEADER_SIZE 5  // Size of the VP8L frame header.
  ------------------
  |  Branch (127:7): [True: 0, False: 10.4k]
  |  Branch (127:23): [True: 0, False: 10.4k]
  ------------------
  128|      0|    return 0;  // not enough data
  129|  10.4k|  } else if (!VP8LCheckSignature(data, data_size)) {
  ------------------
  |  Branch (129:14): [True: 32, False: 10.4k]
  ------------------
  130|     32|    return 0;  // bad signature
  131|  10.4k|  } else {
  132|  10.4k|    int w, h, a;
  133|  10.4k|    VP8LBitReader br;
  134|  10.4k|    VP8LInitBitReader(&br, data, data_size);
  135|  10.4k|    if (!ReadImageInfo(&br, &w, &h, &a)) {
  ------------------
  |  Branch (135:9): [True: 0, False: 10.4k]
  ------------------
  136|      0|      return 0;
  137|      0|    }
  138|  10.4k|    if (width != NULL) *width = w;
  ------------------
  |  Branch (138:9): [True: 10.4k, False: 0]
  ------------------
  139|  10.4k|    if (height != NULL) *height = h;
  ------------------
  |  Branch (139:9): [True: 10.4k, False: 0]
  ------------------
  140|  10.4k|    if (has_alpha != NULL) *has_alpha = a;
  ------------------
  |  Branch (140:9): [True: 8.73k, False: 1.72k]
  ------------------
  141|  10.4k|    return 1;
  142|  10.4k|  }
  143|  10.4k|}
ReadHuffmanCodesHelper:
  454|  3.03k|                           HTreeGroup** const htree_groups) {
  455|  3.03k|  int i, j, ok = 0;
  456|  3.03k|  const int max_alphabet_size =
  457|  3.03k|      kAlphabetSize[0] + ((color_cache_bits > 0) ? 1 << color_cache_bits : 0);
  ------------------
  |  Branch (457:27): [True: 1.50k, False: 1.53k]
  ------------------
  458|  3.03k|  const int table_size = kTableSize[color_cache_bits];
  459|  3.03k|  int* code_lengths = NULL;
  460|  3.03k|  int total_huffman_table_size;
  461|       |
  462|  3.03k|  if ((mapping == NULL && num_htree_groups != num_htree_groups_max) ||
  ------------------
  |  Branch (462:8): [True: 2.87k, False: 155]
  |  Branch (462:27): [True: 0, False: 2.87k]
  ------------------
  463|  3.03k|      num_htree_groups > num_htree_groups_max) {
  ------------------
  |  Branch (463:7): [True: 0, False: 3.03k]
  ------------------
  464|      0|    goto Error;
  465|      0|  }
  466|       |
  467|  3.03k|  code_lengths =
  468|  3.03k|      (int*)WebPSafeCalloc((uint64_t)max_alphabet_size, sizeof(*code_lengths));
  469|  3.03k|  *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.03k|  total_huffman_table_size =
  474|  3.03k|      (num_htree_groups_max > MAX_HUFF_IMAGE_SIZE ? MAX_HUFF_IMAGE_SIZE
  ------------------
  |  |   64|  3.03k|#define MAX_HUFF_IMAGE_SIZE 2600
  ------------------
                    (num_htree_groups_max > MAX_HUFF_IMAGE_SIZE ? MAX_HUFF_IMAGE_SIZE
  ------------------
  |  |   64|    120|#define MAX_HUFF_IMAGE_SIZE 2600
  ------------------
  |  Branch (474:8): [True: 120, False: 2.91k]
  ------------------
  475|  3.03k|                                                  : num_htree_groups) *
  476|  3.03k|      table_size;
  477|  3.03k|  if (*htree_groups == NULL || code_lengths == NULL ||
  ------------------
  |  Branch (477:7): [True: 0, False: 3.03k]
  |  Branch (477:32): [True: 0, False: 3.03k]
  ------------------
  478|  3.03k|      !VP8LHuffmanTablesAllocate(total_huffman_table_size, huffman_tables)) {
  ------------------
  |  Branch (478:7): [True: 0, False: 3.03k]
  ------------------
  479|      0|    VP8LSetError(dec, VP8_STATUS_OUT_OF_MEMORY);
  480|      0|    goto Error;
  481|      0|  }
  482|       |
  483|  38.8k|  for (i = 0; i < num_htree_groups_max; ++i) {
  ------------------
  |  Branch (483:15): [True: 36.5k, False: 2.34k]
  ------------------
  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|  36.5k|    if (mapping != NULL && mapping[i] == -1) {
  ------------------
  |  Branch (486:9): [True: 17.8k, False: 18.6k]
  |  Branch (486:28): [True: 17.6k, False: 265]
  ------------------
  487|   105k|      for (j = 0; j < HUFFMAN_CODES_PER_META_CODE; ++j) {
  ------------------
  |  |   37|   105k|#define HUFFMAN_CODES_PER_META_CODE 5
  ------------------
  |  Branch (487:19): [True: 87.6k, False: 17.4k]
  ------------------
  488|  87.6k|        int alphabet_size = kAlphabetSize[j];
  489|  87.6k|        if (j == 0 && color_cache_bits > 0) {
  ------------------
  |  Branch (489:13): [True: 17.6k, False: 70.0k]
  |  Branch (489:23): [True: 16.1k, False: 1.41k]
  ------------------
  490|  16.1k|          alphabet_size += (1 << color_cache_bits);
  491|  16.1k|        }
  492|       |        // Passing in NULL so that nothing gets filled.
  493|  87.6k|        if (!ReadHuffmanCode(alphabet_size, dec, code_lengths, NULL)) {
  ------------------
  |  Branch (493:13): [True: 125, False: 87.5k]
  ------------------
  494|    125|          goto Error;
  495|    125|        }
  496|  87.6k|      }
  497|  18.9k|    } else {
  498|  18.9k|      HTreeGroup* const htree_group =
  499|  18.9k|          &(*htree_groups)[(mapping == NULL) ? i : mapping[i]];
  ------------------
  |  Branch (499:28): [True: 18.6k, False: 265]
  ------------------
  500|  18.9k|      HuffmanCode** const htrees = htree_group->htrees;
  501|  18.9k|      int size;
  502|  18.9k|      int total_size = 0;
  503|  18.9k|      int is_trivial_literal = 1;
  504|  18.9k|      int max_bits = 0;
  505|   111k|      for (j = 0; j < HUFFMAN_CODES_PER_META_CODE; ++j) {
  ------------------
  |  |   37|   111k|#define HUFFMAN_CODES_PER_META_CODE 5
  ------------------
  |  Branch (505:19): [True: 93.1k, False: 18.3k]
  ------------------
  506|  93.1k|        int alphabet_size = kAlphabetSize[j];
  507|  93.1k|        if (j == 0 && color_cache_bits > 0) {
  ------------------
  |  Branch (507:13): [True: 18.9k, False: 74.2k]
  |  Branch (507:23): [True: 12.4k, False: 6.49k]
  ------------------
  508|  12.4k|          alphabet_size += (1 << color_cache_bits);
  509|  12.4k|        }
  510|  93.1k|        size =
  511|  93.1k|            ReadHuffmanCode(alphabet_size, dec, code_lengths, huffman_tables);
  512|  93.1k|        htrees[j] = huffman_tables->curr_segment->curr_table;
  513|  93.1k|        if (size == 0) {
  ------------------
  |  Branch (513:13): [True: 564, False: 92.5k]
  ------------------
  514|    564|          goto Error;
  515|    564|        }
  516|  92.5k|        if (is_trivial_literal && kLiteralMap[j] == 1) {
  ------------------
  |  Branch (516:13): [True: 87.3k, False: 5.28k]
  |  Branch (516:35): [True: 52.3k, False: 35.0k]
  ------------------
  517|  52.3k|          is_trivial_literal = (htrees[j]->bits == 0);
  518|  52.3k|        }
  519|  92.5k|        total_size += htrees[j]->bits;
  520|  92.5k|        huffman_tables->curr_segment->curr_table += size;
  521|  92.5k|        if (j <= ALPHA) {
  ------------------
  |  Branch (521:13): [True: 74.2k, False: 18.3k]
  ------------------
  522|  74.2k|          int local_max_bits = code_lengths[0];
  523|  74.2k|          int k;
  524|  21.4M|          for (k = 1; k < alphabet_size; ++k) {
  ------------------
  |  Branch (524:23): [True: 21.4M, False: 74.2k]
  ------------------
  525|  21.4M|            if (code_lengths[k] > local_max_bits) {
  ------------------
  |  Branch (525:17): [True: 46.4k, False: 21.3M]
  ------------------
  526|  46.4k|              local_max_bits = code_lengths[k];
  527|  46.4k|            }
  528|  21.4M|          }
  529|  74.2k|          max_bits += local_max_bits;
  530|  74.2k|        }
  531|  92.5k|      }
  532|  18.3k|      htree_group->is_trivial_literal = is_trivial_literal;
  533|  18.3k|      htree_group->is_trivial_code = 0;
  534|  18.3k|      if (is_trivial_literal) {
  ------------------
  |  Branch (534:11): [True: 16.3k, False: 2.04k]
  ------------------
  535|  16.3k|        const int red = htrees[RED][0].value;
  536|  16.3k|        const int blue = htrees[BLUE][0].value;
  537|  16.3k|        const int alpha = htrees[ALPHA][0].value;
  538|  16.3k|        htree_group->literal_arb = ((uint32_t)alpha << 24) | (red << 16) | blue;
  539|  16.3k|        if (total_size == 0 && htrees[GREEN][0].value < NUM_LITERAL_CODES) {
  ------------------
  |  |   43|  15.5k|#define NUM_LITERAL_CODES 256
  ------------------
  |  Branch (539:13): [True: 15.5k, False: 741]
  |  Branch (539:32): [True: 15.5k, False: 9]
  ------------------
  540|  15.5k|          htree_group->is_trivial_code = 1;
  541|  15.5k|          htree_group->literal_arb |= htrees[GREEN][0].value << 8;
  542|  15.5k|        }
  543|  16.3k|      }
  544|  18.3k|      htree_group->use_packed_table =
  545|  18.3k|          !htree_group->is_trivial_code && (max_bits < HUFFMAN_PACKED_BITS);
  ------------------
  |  |   73|  2.79k|#define HUFFMAN_PACKED_BITS 6
  ------------------
  |  Branch (545:11): [True: 2.79k, False: 15.5k]
  |  Branch (545:44): [True: 2.61k, False: 183]
  ------------------
  546|  18.3k|      if (htree_group->use_packed_table) BuildPackedTable(htree_group);
  ------------------
  |  Branch (546:11): [True: 2.61k, False: 15.7k]
  ------------------
  547|  18.3k|    }
  548|  36.5k|  }
  549|  2.34k|  ok = 1;
  550|       |
  551|  3.03k|Error:
  552|  3.03k|  WebPSafeFree(code_lengths);
  553|  3.03k|  if (!ok) {
  ------------------
  |  Branch (553:7): [True: 689, False: 2.34k]
  ------------------
  554|    689|    VP8LHuffmanTablesDeallocate(huffman_tables);
  555|    689|    VP8LHtreeGroupsFree(*htree_groups);
  556|       |    *htree_groups = NULL;
  557|    689|  }
  558|  3.03k|  return ok;
  559|  2.34k|}
VP8LNew:
 1492|  1.72k|VP8LDecoder* VP8LNew(void) {
 1493|  1.72k|  VP8LDecoder* const dec = (VP8LDecoder*)WebPSafeCalloc(1ULL, sizeof(*dec));
 1494|  1.72k|  if (dec == NULL) return NULL;
  ------------------
  |  Branch (1494:7): [True: 0, False: 1.72k]
  ------------------
 1495|  1.72k|  dec->status = VP8_STATUS_OK;
 1496|  1.72k|  dec->state = READ_DIM;
 1497|       |
 1498|  1.72k|  VP8LDspInit();  // Init critical function pointers.
 1499|       |
 1500|  1.72k|  return dec;
 1501|  1.72k|}
VP8LDelete:
 1524|  1.72k|void VP8LDelete(VP8LDecoder* const dec) {
 1525|  1.72k|  if (dec != NULL) {
  ------------------
  |  Branch (1525:7): [True: 1.72k, False: 0]
  ------------------
 1526|  1.72k|    VP8LClear(dec);
 1527|  1.72k|    WebPSafeFree(dec);
 1528|  1.72k|  }
 1529|  1.72k|}
VP8LDecodeHeader:
 1778|  1.72k|int VP8LDecodeHeader(VP8LDecoder* const dec, VP8Io* const io) {
 1779|  1.72k|  int width, height, has_alpha;
 1780|       |
 1781|  1.72k|  if (dec == NULL) return 0;
  ------------------
  |  Branch (1781:7): [True: 0, False: 1.72k]
  ------------------
 1782|  1.72k|  if (io == NULL) {
  ------------------
  |  Branch (1782:7): [True: 0, False: 1.72k]
  ------------------
 1783|      0|    return VP8LSetError(dec, VP8_STATUS_INVALID_PARAM);
 1784|      0|  }
 1785|       |
 1786|  1.72k|  dec->io = io;
 1787|  1.72k|  dec->status = VP8_STATUS_OK;
 1788|  1.72k|  {
 1789|  1.72k|    const uint8_t* WEBP_BIDI_INDEXABLE const bounded_data =
 1790|  1.72k|        WEBP_UNSAFE_FORGE_BIDI_INDEXABLE(const uint8_t*, io->data,
  ------------------
  |  |  180|  1.72k|#define WEBP_UNSAFE_FORGE_BIDI_INDEXABLE(typ, ptr, size) ((typ)(ptr))
  ------------------
 1791|  1.72k|                                         io->data_size);
 1792|  1.72k|    VP8LInitBitReader(&dec->br, bounded_data, io->data_size);
 1793|  1.72k|  }
 1794|  1.72k|  if (!ReadImageInfo(&dec->br, &width, &height, &has_alpha)) {
  ------------------
  |  Branch (1794:7): [True: 0, False: 1.72k]
  ------------------
 1795|      0|    VP8LSetError(dec, VP8_STATUS_BITSTREAM_ERROR);
 1796|      0|    goto Error;
 1797|      0|  }
 1798|  1.72k|  dec->state = READ_DIM;
 1799|  1.72k|  io->width = width;
 1800|  1.72k|  io->height = height;
 1801|       |
 1802|  1.72k|  if (!DecodeImageStream(width, height, /*is_level0=*/1, dec,
  ------------------
  |  Branch (1802:7): [True: 933, False: 787]
  ------------------
 1803|  1.72k|                         /*decoded_data=*/NULL)) {
 1804|    933|    goto Error;
 1805|    933|  }
 1806|    787|  return 1;
 1807|       |
 1808|    933|Error:
 1809|    933|  VP8LClear(dec);
 1810|       |  assert(dec->status != VP8_STATUS_OK);
 1811|    933|  return 0;
 1812|  1.72k|}
VP8LDecodeImage:
 1814|    787|int VP8LDecodeImage(VP8LDecoder* const dec) {
 1815|    787|  VP8Io* io = NULL;
 1816|    787|  WebPDecParams* params = NULL;
 1817|       |
 1818|    787|  if (dec == NULL) return 0;
  ------------------
  |  Branch (1818:7): [True: 0, False: 787]
  ------------------
 1819|       |
 1820|    787|  assert(dec->hdr.huffman_tables.root.start != NULL);
 1821|    787|  assert(dec->hdr.htree_groups != NULL);
 1822|    787|  assert(dec->hdr.num_htree_groups > 0);
 1823|       |
 1824|    787|  io = dec->io;
 1825|    787|  assert(io != NULL);
 1826|    787|  params = (WebPDecParams*)io->opaque;
 1827|    787|  assert(params != NULL);
 1828|       |
 1829|       |  // Initialization.
 1830|    787|  if (dec->state != READ_DATA) {
  ------------------
  |  Branch (1830:7): [True: 787, False: 0]
  ------------------
 1831|    787|    dec->output = params->output;
 1832|    787|    assert(dec->output != NULL);
 1833|       |
 1834|    787|    if (!WebPIoInitFromOptions(params->options, io, MODE_BGRA)) {
  ------------------
  |  Branch (1834:9): [True: 0, False: 787]
  ------------------
 1835|      0|      VP8LSetError(dec, VP8_STATUS_INVALID_PARAM);
 1836|      0|      goto Err;
 1837|      0|    }
 1838|       |
 1839|    787|    if (!AllocateInternalBuffers32b(dec, io->width)) goto Err;
  ------------------
  |  Branch (1839:9): [True: 0, False: 787]
  ------------------
 1840|       |
 1841|    787|#if !defined(WEBP_REDUCE_SIZE)
 1842|    787|    if (io->use_scaling && !AllocateAndInitRescaler(dec, io)) goto Err;
  ------------------
  |  Branch (1842:9): [True: 0, False: 787]
  |  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|    787|    if (io->use_scaling || WebPIsPremultipliedMode(dec->output->colorspace)) {
  ------------------
  |  Branch (1849:9): [True: 0, False: 787]
  |  Branch (1849:28): [True: 0, False: 787]
  ------------------
 1850|       |      // need the alpha-multiply functions for premultiplied output or rescaling
 1851|      0|      WebPInitAlphaProcessing();
 1852|      0|    }
 1853|       |
 1854|    787|    if (!WebPIsRGBMode(dec->output->colorspace)) {
  ------------------
  |  Branch (1854:9): [True: 0, False: 787]
  ------------------
 1855|      0|      WebPInitConvertARGBToYUV();
 1856|      0|      if (dec->output->u.YUVA.a != NULL) WebPInitAlphaProcessing();
  ------------------
  |  Branch (1856:11): [True: 0, False: 0]
  ------------------
 1857|      0|    }
 1858|    787|    if (dec->incremental) {
  ------------------
  |  Branch (1858:9): [True: 0, False: 787]
  ------------------
 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|    787|    dec->state = READ_DATA;
 1869|    787|  }
 1870|       |
 1871|       |  // Decode.
 1872|    787|  if (!DecodeImageData(dec, dec->pixels, dec->width, dec->height,
  ------------------
  |  Branch (1872:7): [True: 162, False: 625]
  ------------------
 1873|    787|                       io->crop_bottom, ProcessRows)) {
 1874|    162|    goto Err;
 1875|    162|  }
 1876|       |
 1877|    625|  params->last_y = dec->last_out_row;
 1878|    625|  return 1;
 1879|       |
 1880|    162|Err:
 1881|    162|  VP8LClear(dec);
 1882|       |  assert(dec->status != VP8_STATUS_OK);
 1883|    162|  return 0;
 1884|    787|}
vp8l_dec.c:ReadImageInfo:
  115|  12.1k|                         int* const height, int* const has_alpha) {
  116|  12.1k|  if (VP8LReadBits(br, 8) != VP8L_MAGIC_BYTE) return 0;
  ------------------
  |  |   28|  12.1k|#define VP8L_MAGIC_BYTE 0x2f   // VP8L signature byte.
  ------------------
  |  Branch (116:7): [True: 0, False: 12.1k]
  ------------------
  117|  12.1k|  *width = VP8LReadBits(br, VP8L_IMAGE_SIZE_BITS) + 1;
  ------------------
  |  |   30|  12.1k|  14                         // Number of bits used to store width and height.
  ------------------
  118|  12.1k|  *height = VP8LReadBits(br, VP8L_IMAGE_SIZE_BITS) + 1;
  ------------------
  |  |   30|  12.1k|  14                         // Number of bits used to store width and height.
  ------------------
  119|  12.1k|  *has_alpha = VP8LReadBits(br, 1);
  120|  12.1k|  if (VP8LReadBits(br, VP8L_VERSION_BITS) != 0) return 0;
  ------------------
  |  |   31|  12.1k|#define VP8L_VERSION_BITS 3  // 3 bits reserved for version.
  ------------------
  |  Branch (120:7): [True: 0, False: 12.1k]
  ------------------
  121|  12.1k|  return !br->eos;
  122|  12.1k|}
vp8l_dec.c:VP8LSetError:
   94|  2.53k|static int VP8LSetError(VP8LDecoder* const dec, VP8StatusCode error) {
   95|       |  // The oldest error reported takes precedence over the new one.
   96|  2.53k|  if (dec->status == VP8_STATUS_OK || dec->status == VP8_STATUS_SUSPENDED) {
  ------------------
  |  Branch (96:7): [True: 1.09k, False: 1.43k]
  |  Branch (96:39): [True: 0, False: 1.43k]
  ------------------
   97|  1.09k|    dec->status = error;
   98|  1.09k|  }
   99|  2.53k|  return 0;
  100|  2.53k|}
vp8l_dec.c:ReadHuffmanCode:
  313|   180k|                           HuffmanTables* const table) {
  314|   180k|  int ok = 0;
  315|   180k|  int size = 0;
  316|   180k|  VP8LBitReader* const br = &dec->br;
  317|   180k|  const int simple_code = VP8LReadBits(br, 1);
  318|       |
  319|   180k|  WEBP_UNSAFE_MEMSET(code_lengths, 0, alphabet_size * sizeof(*code_lengths));
  ------------------
  |  |  175|   180k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  320|       |
  321|   180k|  if (simple_code) {  // Read symbols, codes & code lengths directly.
  ------------------
  |  Branch (321:7): [True: 179k, False: 1.06k]
  ------------------
  322|   179k|    const int num_symbols = VP8LReadBits(br, 1) + 1;
  323|   179k|    const int first_symbol_len_code = VP8LReadBits(br, 1);
  324|       |    // The first code is either 1 bit or 8 bit code.
  325|   179k|    int symbol = VP8LReadBits(br, (first_symbol_len_code == 0) ? 1 : 8);
  ------------------
  |  Branch (325:35): [True: 177k, False: 2.66k]
  ------------------
  326|   179k|    code_lengths[symbol] = 1;
  327|       |    // The second code (if present), is always 8 bits long.
  328|   179k|    if (num_symbols == 2) {
  ------------------
  |  Branch (328:9): [True: 62.2k, False: 117k]
  ------------------
  329|  62.2k|      symbol = VP8LReadBits(br, 8);
  330|  62.2k|      code_lengths[symbol] = 1;
  331|  62.2k|    }
  332|   179k|    ok = 1;
  333|   179k|  } else {  // Decode Huffman-coded code lengths.
  334|  1.06k|    int i;
  335|  1.06k|    int code_length_code_lengths[NUM_CODE_LENGTH_CODES] = {0};
  336|  1.06k|    const int num_codes = VP8LReadBits(br, 4) + 4;
  337|  1.06k|    assert(num_codes <= NUM_CODE_LENGTH_CODES);
  338|       |
  339|  11.9k|    for (i = 0; i < num_codes; ++i) {
  ------------------
  |  Branch (339:17): [True: 10.8k, False: 1.06k]
  ------------------
  340|  10.8k|      code_length_code_lengths[kCodeLengthCodeOrder[i]] = VP8LReadBits(br, 3);
  341|  10.8k|    }
  342|  1.06k|    ok = ReadHuffmanCodeLengths(dec, code_length_code_lengths, alphabet_size,
  343|  1.06k|                                code_lengths);
  344|  1.06k|  }
  345|       |
  346|   180k|  ok = ok && !br->eos;
  ------------------
  |  Branch (346:8): [True: 180k, False: 344]
  |  Branch (346:14): [True: 180k, False: 216]
  ------------------
  347|   180k|  if (ok) {
  ------------------
  |  Branch (347:7): [True: 180k, False: 560]
  ------------------
  348|   180k|    const int* WEBP_BIDI_INDEXABLE const bounded_code_lengths =
  349|   180k|        WEBP_UNSAFE_FORGE_BIDI_INDEXABLE(const int*, code_lengths,
  ------------------
  |  |  180|   180k|#define WEBP_UNSAFE_FORGE_BIDI_INDEXABLE(typ, ptr, size) ((typ)(ptr))
  ------------------
  350|   180k|                                         alphabet_size * sizeof(int));
  351|   180k|    size = VP8LBuildHuffmanTable(table, HUFFMAN_TABLE_BITS,
  ------------------
  |  |   29|   180k|#define HUFFMAN_TABLE_BITS 8
  ------------------
  352|   180k|                                 bounded_code_lengths, alphabet_size);
  353|   180k|  }
  354|   180k|  if (!ok || size == 0) {
  ------------------
  |  Branch (354:7): [True: 560, False: 180k]
  |  Branch (354:14): [True: 129, False: 180k]
  ------------------
  355|    689|    return VP8LSetError(dec, VP8_STATUS_BITSTREAM_ERROR);
  356|    689|  }
  357|   180k|  return size;
  358|   180k|}
vp8l_dec.c:ReadHuffmanCodeLengths:
  247|  1.06k|                                  int num_symbols, int* const code_lengths) {
  248|  1.06k|  int ok = 0;
  249|  1.06k|  VP8LBitReader* const br = &dec->br;
  250|  1.06k|  int symbol;
  251|  1.06k|  int max_symbol;
  252|  1.06k|  int prev_code_len = DEFAULT_CODE_LENGTH;
  ------------------
  |  |   40|  1.06k|#define DEFAULT_CODE_LENGTH 8
  ------------------
  253|  1.06k|  HuffmanTables tables;
  254|  1.06k|  const int* WEBP_BIDI_INDEXABLE const bounded_code_lengths =
  255|  1.06k|      WEBP_UNSAFE_FORGE_BIDI_INDEXABLE(
  ------------------
  |  |  180|  1.06k|#define WEBP_UNSAFE_FORGE_BIDI_INDEXABLE(typ, ptr, size) ((typ)(ptr))
  ------------------
  256|  1.06k|          const int*, code_length_code_lengths,
  257|  1.06k|          NUM_CODE_LENGTH_CODES * sizeof(*code_length_code_lengths));
  258|       |
  259|  1.06k|  if (!VP8LHuffmanTablesAllocate(1 << LENGTHS_TABLE_BITS, &tables) ||
  ------------------
  |  |   32|  1.06k|#define LENGTHS_TABLE_BITS 7
  ------------------
  |  Branch (259:7): [True: 0, False: 1.06k]
  ------------------
  260|  1.06k|      !VP8LBuildHuffmanTable(&tables, LENGTHS_TABLE_BITS, bounded_code_lengths,
  ------------------
  |  |   32|  1.06k|#define LENGTHS_TABLE_BITS 7
  ------------------
  |  Branch (260:7): [True: 278, False: 788]
  ------------------
  261|  1.06k|                             NUM_CODE_LENGTH_CODES)) {
  ------------------
  |  |   62|  1.06k|#define NUM_CODE_LENGTH_CODES 19
  ------------------
  262|    278|    goto End;
  263|    278|  }
  264|       |
  265|    788|  if (VP8LReadBits(br, 1)) {  // use length
  ------------------
  |  Branch (265:7): [True: 648, False: 140]
  ------------------
  266|    648|    const int length_nbits = 2 + 2 * VP8LReadBits(br, 3);
  267|    648|    max_symbol = 2 + VP8LReadBits(br, length_nbits);
  268|    648|    if (max_symbol > num_symbols) {
  ------------------
  |  Branch (268:9): [True: 11, False: 637]
  ------------------
  269|     11|      goto End;
  270|     11|    }
  271|    648|  } else {
  272|    140|    max_symbol = num_symbols;
  273|    140|  }
  274|       |
  275|    777|  symbol = 0;
  276|   114k|  while (symbol < num_symbols) {
  ------------------
  |  Branch (276:10): [True: 114k, False: 107]
  ------------------
  277|   114k|    const HuffmanCode* p;
  278|   114k|    int code_len;
  279|   114k|    if (max_symbol-- == 0) break;
  ------------------
  |  Branch (279:9): [True: 615, False: 113k]
  ------------------
  280|   113k|    VP8LFillBitWindow(br);
  281|   113k|    p = &tables.curr_segment->start[VP8LPrefetchBits(br) & LENGTHS_TABLE_MASK];
  ------------------
  |  |   33|   113k|#define LENGTHS_TABLE_MASK ((1 << LENGTHS_TABLE_BITS) - 1)
  |  |  ------------------
  |  |  |  |   32|   113k|#define LENGTHS_TABLE_BITS 7
  |  |  ------------------
  ------------------
  282|   113k|    VP8LSetBitPos(br, br->bit_pos + p->bits);
  283|   113k|    code_len = p->value;
  284|   113k|    if (code_len < kCodeLengthLiterals) {
  ------------------
  |  Branch (284:9): [True: 96.8k, False: 16.8k]
  ------------------
  285|  96.8k|      code_lengths[symbol++] = code_len;
  286|  96.8k|      if (code_len != 0) prev_code_len = code_len;
  ------------------
  |  Branch (286:11): [True: 91.3k, False: 5.51k]
  ------------------
  287|  96.8k|    } else {
  288|  16.8k|      const int use_prev = (code_len == kCodeLengthRepeatCode);
  289|  16.8k|      const int slot = code_len - kCodeLengthLiterals;
  290|  16.8k|      const int extra_bits = kCodeLengthExtraBits[slot];
  291|  16.8k|      const int repeat_offset = kCodeLengthRepeatOffsets[slot];
  292|  16.8k|      int repeat = VP8LReadBits(br, extra_bits) + repeat_offset;
  293|  16.8k|      if (symbol + repeat > num_symbols) {
  ------------------
  |  Branch (293:11): [True: 55, False: 16.7k]
  ------------------
  294|     55|        goto End;
  295|  16.7k|      } else {
  296|  16.7k|        const int length = use_prev ? prev_code_len : 0;
  ------------------
  |  Branch (296:28): [True: 7.07k, False: 9.67k]
  ------------------
  297|   207k|        while (repeat-- > 0) code_lengths[symbol++] = length;
  ------------------
  |  Branch (297:16): [True: 190k, False: 16.7k]
  ------------------
  298|  16.7k|      }
  299|  16.8k|    }
  300|   113k|  }
  301|    722|  ok = 1;
  302|       |
  303|  1.06k|End:
  304|  1.06k|  VP8LHuffmanTablesDeallocate(&tables);
  305|  1.06k|  if (!ok) return VP8LSetError(dec, VP8_STATUS_BITSTREAM_ERROR);
  ------------------
  |  Branch (305:7): [True: 344, False: 722]
  ------------------
  306|    722|  return ok;
  307|  1.06k|}
vp8l_dec.c:BuildPackedTable:
  224|  2.61k|static void BuildPackedTable(HTreeGroup* const htree_group) {
  225|  2.61k|  uint32_t code;
  226|   169k|  for (code = 0; code < HUFFMAN_PACKED_TABLE_SIZE; ++code) {
  ------------------
  |  |   74|   169k|#define HUFFMAN_PACKED_TABLE_SIZE (1u << HUFFMAN_PACKED_BITS)
  |  |  ------------------
  |  |  |  |   73|   169k|#define HUFFMAN_PACKED_BITS 6
  |  |  ------------------
  ------------------
  |  Branch (226:18): [True: 167k, False: 2.61k]
  ------------------
  227|   167k|    uint32_t bits = code;
  228|   167k|    HuffmanCode32* const huff = &htree_group->packed_table[bits];
  229|   167k|    HuffmanCode hcode = htree_group->htrees[GREEN][bits];
  230|   167k|    if (hcode.value >= NUM_LITERAL_CODES) {
  ------------------
  |  |   43|   167k|#define NUM_LITERAL_CODES 256
  ------------------
  |  Branch (230:9): [True: 14.6k, False: 152k]
  ------------------
  231|  14.6k|      huff->bits = hcode.bits + BITS_SPECIAL_MARKER;
  ------------------
  |  |  197|  14.6k|#define BITS_SPECIAL_MARKER 0x100  // something large enough (and a bit-mask)
  ------------------
  232|  14.6k|      huff->value = hcode.value;
  233|   152k|    } else {
  234|   152k|      huff->bits = 0;
  235|   152k|      huff->value = 0;
  236|   152k|      bits >>= AccumulateHCode(hcode, 8, huff);
  237|   152k|      bits >>= AccumulateHCode(htree_group->htrees[RED][bits], 16, huff);
  238|   152k|      bits >>= AccumulateHCode(htree_group->htrees[BLUE][bits], 0, huff);
  239|   152k|      bits >>= AccumulateHCode(htree_group->htrees[ALPHA][bits], 24, huff);
  240|   152k|      (void)bits;
  241|   152k|    }
  242|   167k|  }
  243|  2.61k|}
vp8l_dec.c:AccumulateHCode:
  217|   609k|                           HuffmanCode32* const huff) {
  218|   609k|  huff->bits += hcode.bits;
  219|   609k|  huff->value |= (uint32_t)hcode.value << shift;
  220|       |  assert(huff->bits <= HUFFMAN_TABLE_BITS);
  221|   609k|  return hcode.bits;
  222|   609k|}
vp8l_dec.c:VP8LClear:
 1505|  2.81k|static void VP8LClear(VP8LDecoder* const dec) {
 1506|  2.81k|  int i;
 1507|  2.81k|  if (dec == NULL) return;
  ------------------
  |  Branch (1507:7): [True: 0, False: 2.81k]
  ------------------
 1508|  2.81k|  ClearMetadata(&dec->hdr);
 1509|       |
 1510|  2.81k|  WebPSafeFree(dec->pixels);
 1511|  2.81k|  dec->pixels = NULL;
 1512|  4.67k|  for (i = 0; i < dec->next_transform; ++i) {
  ------------------
  |  Branch (1512:15): [True: 1.85k, False: 2.81k]
  ------------------
 1513|  1.85k|    ClearTransform(&dec->transforms[i]);
 1514|  1.85k|  }
 1515|  2.81k|  dec->next_transform = 0;
 1516|  2.81k|  dec->transforms_seen = 0;
 1517|       |
 1518|  2.81k|  WebPSafeFree(dec->rescaler_memory);
 1519|  2.81k|  dec->rescaler_memory = NULL;
 1520|       |
 1521|       |  dec->output = NULL;  // leave no trace behind
 1522|  2.81k|}
vp8l_dec.c:ClearMetadata:
 1478|  5.48k|static void ClearMetadata(VP8LMetadata* const hdr) {
 1479|  5.48k|  assert(hdr != NULL);
 1480|       |
 1481|  5.48k|  WebPSafeFree(hdr->huffman_image);
 1482|  5.48k|  VP8LHuffmanTablesDeallocate(&hdr->huffman_tables);
 1483|  5.48k|  VP8LHtreeGroupsFree(hdr->htree_groups);
 1484|  5.48k|  VP8LColorCacheClear(&hdr->color_cache);
 1485|  5.48k|  VP8LColorCacheClear(&hdr->saved_color_cache);
 1486|  5.48k|  InitMetadata(hdr);
 1487|  5.48k|}
vp8l_dec.c:InitMetadata:
 1473|  5.48k|static void InitMetadata(VP8LMetadata* const hdr) {
 1474|  5.48k|  assert(hdr != NULL);
 1475|  5.48k|  WEBP_UNSAFE_MEMSET(hdr, 0, sizeof(*hdr));
  ------------------
  |  |  175|  5.48k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
 1476|  5.48k|}
vp8l_dec.c:ClearTransform:
 1383|  1.85k|static void ClearTransform(VP8LTransform* const transform) {
 1384|  1.85k|  WebPSafeFree(transform->data);
 1385|       |  transform->data = NULL;
 1386|  1.85k|}
vp8l_dec.c:DecodeImageStream:
 1543|  3.45k|                             uint32_t** const decoded_data) {
 1544|  3.45k|  int ok = 1;
 1545|  3.45k|  int transform_xsize = xsize;
 1546|  3.45k|  int transform_ysize = ysize;
 1547|  3.45k|  VP8LBitReader* const br = &dec->br;
 1548|  3.45k|  VP8LMetadata* const hdr = &dec->hdr;
 1549|  3.45k|  uint32_t* data = NULL;
 1550|  3.45k|  int color_cache_bits = 0;
 1551|       |
 1552|       |  // Read the transforms (may recurse).
 1553|  3.45k|  if (is_level0) {
  ------------------
  |  Branch (1553:7): [True: 1.72k, False: 1.73k]
  ------------------
 1554|  3.58k|    while (ok && VP8LReadBits(br, 1)) {
  ------------------
  |  Branch (1554:12): [True: 3.24k, False: 332]
  |  Branch (1554:18): [True: 1.86k, False: 1.38k]
  ------------------
 1555|  1.86k|      ok = ReadTransform(&transform_xsize, &transform_ysize, dec);
 1556|  1.86k|    }
 1557|  1.72k|  }
 1558|       |
 1559|       |  // Color cache
 1560|  3.45k|  if (ok && VP8LReadBits(br, 1)) {
  ------------------
  |  Branch (1560:7): [True: 3.12k, False: 332]
  |  Branch (1560:13): [True: 1.52k, False: 1.59k]
  ------------------
 1561|  1.52k|    color_cache_bits = VP8LReadBits(br, 4);
 1562|  1.52k|    ok = (color_cache_bits >= 1 && color_cache_bits <= MAX_CACHE_BITS);
  ------------------
  |  |   36|  1.52k|#define MAX_CACHE_BITS 11
  ------------------
  |  Branch (1562:11): [True: 1.52k, False: 1]
  |  Branch (1562:36): [True: 1.51k, False: 4]
  ------------------
 1563|  1.52k|    if (!ok) {
  ------------------
  |  Branch (1563:9): [True: 5, False: 1.51k]
  ------------------
 1564|      5|      VP8LSetError(dec, VP8_STATUS_BITSTREAM_ERROR);
 1565|      5|      goto End;
 1566|      5|    }
 1567|  1.52k|  }
 1568|       |
 1569|       |  // Read the Huffman codes (may recurse).
 1570|  3.44k|  ok = ok && ReadHuffmanCodes(dec, transform_xsize, transform_ysize,
  ------------------
  |  Branch (1570:8): [True: 3.11k, False: 332]
  |  Branch (1570:14): [True: 2.34k, False: 771]
  ------------------
 1571|  3.11k|                              color_cache_bits, is_level0);
 1572|  3.44k|  if (!ok) {
  ------------------
  |  Branch (1572:7): [True: 1.10k, False: 2.34k]
  ------------------
 1573|  1.10k|    VP8LSetError(dec, VP8_STATUS_BITSTREAM_ERROR);
 1574|  1.10k|    goto End;
 1575|  1.10k|  }
 1576|       |
 1577|       |  // Finish setting up the color-cache
 1578|  2.34k|  if (color_cache_bits > 0) {
  ------------------
  |  Branch (1578:7): [True: 1.19k, False: 1.15k]
  ------------------
 1579|  1.19k|    hdr->color_cache_size = 1 << color_cache_bits;
 1580|  1.19k|    if (!VP8LColorCacheInit(&hdr->color_cache, color_cache_bits)) {
  ------------------
  |  Branch (1580:9): [True: 0, False: 1.19k]
  ------------------
 1581|      0|      ok = VP8LSetError(dec, VP8_STATUS_OUT_OF_MEMORY);
 1582|      0|      goto End;
 1583|      0|    }
 1584|  1.19k|  } else {
 1585|  1.15k|    hdr->color_cache_size = 0;
 1586|  1.15k|  }
 1587|  2.34k|  UpdateDecoder(dec, transform_xsize, transform_ysize);
 1588|       |
 1589|  2.34k|  if (is_level0) {  // level 0 complete
  ------------------
  |  Branch (1589:7): [True: 787, False: 1.55k]
  ------------------
 1590|    787|    dec->state = READ_HDR;
 1591|    787|    goto End;
 1592|    787|  }
 1593|       |
 1594|  1.55k|  {
 1595|  1.55k|    const uint64_t total_size = (uint64_t)transform_xsize * transform_ysize;
 1596|  1.55k|    data = (uint32_t*)WebPSafeMalloc(total_size, sizeof(*data));
 1597|  1.55k|    if (data == NULL) {
  ------------------
  |  Branch (1597:9): [True: 0, False: 1.55k]
  ------------------
 1598|      0|      ok = VP8LSetError(dec, VP8_STATUS_OUT_OF_MEMORY);
 1599|      0|      goto End;
 1600|      0|    }
 1601|  1.55k|  }
 1602|       |
 1603|       |  // Use the Huffman trees to decode the LZ77 encoded data.
 1604|  1.55k|  ok = DecodeImageData(dec, data, transform_xsize, transform_ysize,
 1605|  1.55k|                       transform_ysize, NULL);
 1606|  1.55k|  ok = ok && !br->eos;
  ------------------
  |  Branch (1606:8): [True: 1.32k, False: 230]
  |  Branch (1606:14): [True: 1.32k, False: 0]
  ------------------
 1607|       |
 1608|  3.45k|End:
 1609|  3.45k|  if (!ok) {
  ------------------
  |  Branch (1609:7): [True: 1.33k, False: 2.11k]
  ------------------
 1610|  1.33k|    WebPSafeFree(data);
 1611|  1.33k|    ClearMetadata(hdr);
 1612|  2.11k|  } else {
 1613|  2.11k|    if (decoded_data != NULL) {
  ------------------
  |  Branch (1613:9): [True: 1.32k, False: 787]
  ------------------
 1614|  1.32k|      *decoded_data = data;
 1615|  1.32k|    } 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|    787|      assert(data == NULL);
 1619|    787|      assert(is_level0);
 1620|    787|    }
 1621|  2.11k|    dec->last_pixel = 0;  // Reset for future DECODE_DATA_FUNC() calls.
 1622|  2.11k|    if (!is_level0) ClearMetadata(hdr);  // Clean up temporary data behind.
  ------------------
  |  Branch (1622:9): [True: 1.32k, False: 787]
  ------------------
 1623|  2.11k|  }
 1624|  3.45k|  return ok;
 1625|  1.55k|}
vp8l_dec.c:ReadTransform:
 1415|  1.86k|                         VP8LDecoder* const dec) {
 1416|  1.86k|  int ok = 1;
 1417|  1.86k|  VP8LBitReader* const br = &dec->br;
 1418|  1.86k|  VP8LTransform* transform = &dec->transforms[dec->next_transform];
 1419|  1.86k|  const VP8LImageTransformType type =
 1420|  1.86k|      (VP8LImageTransformType)VP8LReadBits(br, 2);
 1421|       |
 1422|       |  // Each transform type can only be present once in the stream.
 1423|  1.86k|  if (dec->transforms_seen & (1U << type)) {
  ------------------
  |  Branch (1423:7): [True: 3, False: 1.85k]
  ------------------
 1424|      3|    return 0;  // Already there, let's not accept the second same transform.
 1425|      3|  }
 1426|  1.85k|  dec->transforms_seen |= (1U << type);
 1427|       |
 1428|  1.85k|  transform->type = type;
 1429|  1.85k|  transform->xsize = *xsize;
 1430|  1.85k|  transform->ysize = *ysize;
 1431|  1.85k|  transform->data = NULL;
 1432|  1.85k|  ++dec->next_transform;
 1433|  1.85k|  assert(dec->next_transform <= NUM_TRANSFORMS);
 1434|       |
 1435|  1.85k|  switch (type) {
 1436|    559|    case PREDICTOR_TRANSFORM:
  ------------------
  |  Branch (1436:5): [True: 559, False: 1.29k]
  ------------------
 1437|    985|    case CROSS_COLOR_TRANSFORM:
  ------------------
  |  Branch (1437:5): [True: 426, False: 1.43k]
  ------------------
 1438|    985|      transform->bits =
 1439|    985|          MIN_TRANSFORM_BITS + VP8LReadBits(br, NUM_TRANSFORM_BITS);
  ------------------
  |  |   53|    985|#define MIN_TRANSFORM_BITS 2
  ------------------
                        MIN_TRANSFORM_BITS + VP8LReadBits(br, NUM_TRANSFORM_BITS);
  ------------------
  |  |   54|    985|#define NUM_TRANSFORM_BITS 3
  ------------------
 1440|    985|      ok = DecodeImageStream(
 1441|    985|          VP8LSubSampleSize(transform->xsize, transform->bits),
 1442|    985|          VP8LSubSampleSize(transform->ysize, transform->bits),
 1443|    985|          /*is_level0=*/0, dec, &transform->data);
 1444|    985|      break;
 1445|    238|    case COLOR_INDEXING_TRANSFORM: {
  ------------------
  |  Branch (1445:5): [True: 238, False: 1.62k]
  ------------------
 1446|    238|      const int num_colors = VP8LReadBits(br, 8) + 1;
 1447|    238|      const int bits = (num_colors > 16)  ? 0
  ------------------
  |  Branch (1447:24): [True: 95, False: 143]
  ------------------
 1448|    238|                       : (num_colors > 4) ? 1
  ------------------
  |  Branch (1448:26): [True: 36, False: 107]
  ------------------
 1449|    143|                       : (num_colors > 2) ? 2
  ------------------
  |  Branch (1449:26): [True: 47, False: 60]
  ------------------
 1450|    107|                                          : 3;
 1451|    238|      *xsize = VP8LSubSampleSize(transform->xsize, bits);
 1452|    238|      transform->bits = bits;
 1453|    238|      ok = DecodeImageStream(num_colors, /*ysize=*/1, /*is_level0=*/0, dec,
 1454|    238|                             &transform->data);
 1455|    238|      if (ok && !ExpandColorMap(num_colors, transform)) {
  ------------------
  |  Branch (1455:11): [True: 203, False: 35]
  |  Branch (1455:17): [True: 0, False: 203]
  ------------------
 1456|      0|        return VP8LSetError(dec, VP8_STATUS_OUT_OF_MEMORY);
 1457|      0|      }
 1458|    238|      break;
 1459|    238|    }
 1460|    635|    case SUBTRACT_GREEN_TRANSFORM:
  ------------------
  |  Branch (1460:5): [True: 635, False: 1.22k]
  ------------------
 1461|    635|      break;
 1462|      0|    default:
  ------------------
  |  Branch (1462:5): [True: 0, False: 1.85k]
  ------------------
 1463|      0|      assert(0);  // can't happen
 1464|      0|      break;
 1465|  1.85k|  }
 1466|       |
 1467|  1.85k|  return ok;
 1468|  1.85k|}
vp8l_dec.c:ExpandColorMap:
 1390|    203|static int ExpandColorMap(int num_colors, VP8LTransform* const transform) {
 1391|    203|  int i;
 1392|    203|  const int final_num_colors = 1 << (8 >> transform->bits);
 1393|    203|  uint32_t* const new_color_map = (uint32_t*)WebPSafeMalloc(
 1394|    203|      (uint64_t)final_num_colors, sizeof(*new_color_map));
 1395|    203|  if (new_color_map == NULL) {
  ------------------
  |  Branch (1395:7): [True: 0, False: 203]
  ------------------
 1396|      0|    return 0;
 1397|    203|  } else {
 1398|    203|    uint8_t* const data = (uint8_t*)transform->data;
 1399|    203|    uint8_t* const new_data = (uint8_t*)new_color_map;
 1400|    203|    new_color_map[0] = transform->data[0];
 1401|  29.9k|    for (i = 4; i < 4 * num_colors; ++i) {
  ------------------
  |  Branch (1401:17): [True: 29.7k, False: 203]
  ------------------
 1402|       |      // Equivalent to VP8LAddPixels(), on a byte-basis.
 1403|  29.7k|      new_data[i] = (data[i] + new_data[i - 4]) & 0xff;
 1404|  29.7k|    }
 1405|  35.6k|    for (; i < 4 * final_num_colors; ++i) {
  ------------------
  |  Branch (1405:12): [True: 35.4k, False: 203]
  ------------------
 1406|  35.4k|      new_data[i] = 0;  // black tail.
 1407|  35.4k|    }
 1408|    203|    WebPSafeFree(transform->data);
 1409|    203|    transform->data = new_color_map;
 1410|    203|  }
 1411|    203|  return 1;
 1412|    203|}
vp8l_dec.c:ReadHuffmanCodes:
  361|  3.11k|                            int color_cache_bits, int allow_recursion) {
  362|  3.11k|  int i;
  363|  3.11k|  VP8LBitReader* const br = &dec->br;
  364|  3.11k|  VP8LMetadata* const hdr = &dec->hdr;
  365|  3.11k|  uint32_t* huffman_image = NULL;
  366|  3.11k|  HTreeGroup* htree_groups = NULL;
  367|  3.11k|  HuffmanTables* huffman_tables = &hdr->huffman_tables;
  368|  3.11k|  int num_htree_groups = 1;
  369|  3.11k|  int num_htree_groups_max = 1;
  370|  3.11k|  int* mapping = NULL;
  371|  3.11k|  int ok = 0;
  372|       |
  373|       |  // Check the table has been 0 initialized (through InitMetadata).
  374|  3.11k|  assert(huffman_tables->root.start == NULL);
  375|  3.11k|  assert(huffman_tables->curr_segment == NULL);
  376|       |
  377|  3.11k|  if (allow_recursion && VP8LReadBits(br, 1)) {
  ------------------
  |  Branch (377:7): [True: 1.38k, False: 1.73k]
  |  Branch (377:26): [True: 510, False: 876]
  ------------------
  378|       |    // use meta Huffman codes.
  379|    510|    const int huffman_precision =
  380|    510|        MIN_HUFFMAN_BITS + VP8LReadBits(br, NUM_HUFFMAN_BITS);
  ------------------
  |  |   48|    510|#define MIN_HUFFMAN_BITS 2  // min number of Huffman bits
  ------------------
                      MIN_HUFFMAN_BITS + VP8LReadBits(br, NUM_HUFFMAN_BITS);
  ------------------
  |  |   49|    510|#define NUM_HUFFMAN_BITS 3
  ------------------
  381|    510|    const int huffman_xsize = VP8LSubSampleSize(xsize, huffman_precision);
  382|    510|    const int huffman_ysize = VP8LSubSampleSize(ysize, huffman_precision);
  383|    510|    const int huffman_pixs = huffman_xsize * huffman_ysize;
  384|    510|    if (!DecodeImageStream(huffman_xsize, huffman_ysize, /*is_level0=*/0, dec,
  ------------------
  |  Branch (384:9): [True: 76, False: 434]
  ------------------
  385|    510|                           &huffman_image)) {
  386|     76|      goto Error;
  387|     76|    }
  388|    434|    hdr->huffman_subsample_bits = huffman_precision;
  389|   157M|    for (i = 0; i < huffman_pixs; ++i) {
  ------------------
  |  Branch (389:17): [True: 157M, False: 434]
  ------------------
  390|       |      // The huffman data is stored in red and green bytes.
  391|   157M|      const int group = (huffman_image[i] >> 8) & 0xffff;
  392|   157M|      huffman_image[i] = group;
  393|   157M|      if (group >= num_htree_groups_max) {
  ------------------
  |  Branch (393:11): [True: 660, False: 157M]
  ------------------
  394|    660|        num_htree_groups_max = group + 1;
  395|    660|      }
  396|   157M|    }
  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|    434|    if (num_htree_groups_max > 1000 || num_htree_groups_max > xsize * ysize) {
  ------------------
  |  Branch (403:9): [True: 134, False: 300]
  |  Branch (403:40): [True: 21, False: 279]
  ------------------
  404|       |      // Create a mapping from the used indices to the minimal set of used
  405|       |      // values [0, num_htree_groups)
  406|    155|      mapping = (int*)WebPSafeMalloc(num_htree_groups_max, sizeof(*mapping));
  407|    155|      if (mapping == NULL) {
  ------------------
  |  Branch (407:11): [True: 0, False: 155]
  ------------------
  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|    155|      WEBP_UNSAFE_MEMSET(mapping, 0xff,
  ------------------
  |  |  175|    155|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  414|    155|                         num_htree_groups_max * sizeof(*mapping));
  415|  82.0M|      for (num_htree_groups = 0, i = 0; i < huffman_pixs; ++i) {
  ------------------
  |  Branch (415:41): [True: 82.0M, False: 155]
  ------------------
  416|       |        // Get the current mapping for the group and remap the Huffman image.
  417|  82.0M|        int* const mapped_group = &mapping[huffman_image[i]];
  418|  82.0M|        if (*mapped_group == -1) *mapped_group = num_htree_groups++;
  ------------------
  |  Branch (418:13): [True: 3.81k, False: 82.0M]
  ------------------
  419|  82.0M|        huffman_image[i] = *mapped_group;
  420|  82.0M|      }
  421|    279|    } else {
  422|    279|      num_htree_groups = num_htree_groups_max;
  423|    279|    }
  424|    434|  }
  425|       |
  426|  3.04k|  if (br->eos) goto Error;
  ------------------
  |  Branch (426:7): [True: 6, False: 3.03k]
  ------------------
  427|       |
  428|  3.03k|  if (!ReadHuffmanCodesHelper(color_cache_bits, num_htree_groups,
  ------------------
  |  Branch (428:7): [True: 689, False: 2.34k]
  ------------------
  429|  3.03k|                              num_htree_groups_max, mapping, dec,
  430|  3.03k|                              huffman_tables, &htree_groups)) {
  431|    689|    goto Error;
  432|    689|  }
  433|  2.34k|  ok = 1;
  434|       |
  435|       |  // All OK. Finalize pointers.
  436|  2.34k|  hdr->huffman_image = huffman_image;
  437|  2.34k|  hdr->num_htree_groups = num_htree_groups;
  438|  2.34k|  hdr->htree_groups = htree_groups;
  439|       |
  440|  3.11k|Error:
  441|  3.11k|  WebPSafeFree(mapping);
  442|  3.11k|  if (!ok) {
  ------------------
  |  Branch (442:7): [True: 771, False: 2.34k]
  ------------------
  443|    771|    WebPSafeFree(huffman_image);
  444|    771|    VP8LHuffmanTablesDeallocate(huffman_tables);
  445|    771|    VP8LHtreeGroupsFree(htree_groups);
  446|    771|  }
  447|  3.11k|  return ok;
  448|  2.34k|}
vp8l_dec.c:UpdateDecoder:
 1531|  2.34k|static void UpdateDecoder(VP8LDecoder* const dec, int width, int height) {
 1532|  2.34k|  VP8LMetadata* const hdr = &dec->hdr;
 1533|  2.34k|  const int num_bits = hdr->huffman_subsample_bits;
 1534|  2.34k|  dec->width = width;
 1535|  2.34k|  dec->height = height;
 1536|       |
 1537|  2.34k|  hdr->huffman_xsize = VP8LSubSampleSize(width, num_bits);
 1538|  2.34k|  hdr->huffman_mask = (num_bits == 0) ? ~0 : (1 << num_bits) - 1;
  ------------------
  |  Branch (1538:23): [True: 2.31k, False: 29]
  ------------------
 1539|  2.34k|}
vp8l_dec.c:AllocateInternalBuffers32b:
 1629|    787|static int AllocateInternalBuffers32b(VP8LDecoder* const dec, int final_width) {
 1630|    787|  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|    787|  const uint64_t cache_top_pixels = (uint16_t)final_width;
 1634|       |  // Scratch buffer for temporary BGRA storage. Not needed for paletted alpha.
 1635|    787|  const uint64_t cache_pixels = (uint64_t)final_width * NUM_ARGB_CACHE_ROWS;
  ------------------
  |  |   40|    787|#define NUM_ARGB_CACHE_ROWS 16
  ------------------
 1636|       |  // Scratch buffer to accumulate RGBA values (hence 4*)for YUV conversion.
 1637|    787|  uint64_t accumulated_rgb_pixels = 0;
 1638|    787|  uint64_t total_num_pixels;
 1639|    787|  if (dec->output != NULL && !WebPIsRGBMode(dec->output->colorspace)) {
  ------------------
  |  Branch (1639:7): [True: 787, False: 0]
  |  Branch (1639:30): [True: 0, False: 787]
  ------------------
 1640|      0|    const int uv_width = (dec->io->crop_right - dec->io->crop_left + 1) >> 1;
 1641|      0|    accumulated_rgb_pixels =
 1642|      0|        4 * uv_width * sizeof(*dec->accumulated_rgb_pixels) / sizeof(uint32_t);
 1643|      0|  }
 1644|    787|  total_num_pixels =
 1645|    787|      num_pixels + cache_top_pixels + cache_pixels + accumulated_rgb_pixels;
 1646|    787|  assert(dec->width <= final_width);
 1647|    787|  dec->pixels = (uint32_t*)WebPSafeMalloc(total_num_pixels, sizeof(uint32_t));
 1648|    787|  if (dec->pixels == NULL) {
  ------------------
  |  Branch (1648:7): [True: 0, False: 787]
  ------------------
 1649|      0|    dec->argb_cache = NULL;  // for soundness
 1650|      0|    return VP8LSetError(dec, VP8_STATUS_OUT_OF_MEMORY);
 1651|      0|  }
 1652|    787|  dec->argb_cache = dec->pixels + num_pixels + cache_top_pixels;
 1653|    787|  dec->accumulated_rgb_pixels =
 1654|    787|      accumulated_rgb_pixels == 0
  ------------------
  |  Branch (1654:7): [True: 787, False: 0]
  ------------------
 1655|    787|          ? NULL
 1656|    787|          : (uint16_t*)(dec->pixels + num_pixels + cache_top_pixels +
 1657|      0|                        cache_pixels);
 1658|       |
 1659|    787|  return 1;
 1660|    787|}
vp8l_dec.c:GetHtreeGroupForPos:
  836|   628k|                                                   int x, int y) {
  837|   628k|  const int meta_index = GetMetaIndex(hdr->huffman_image, hdr->huffman_xsize,
  838|   628k|                                      hdr->huffman_subsample_bits, x, y);
  839|       |  assert(meta_index < hdr->num_htree_groups);
  840|   628k|  return hdr->htree_groups + meta_index;
  841|   628k|}
vp8l_dec.c:GetMetaIndex:
  830|   628k|                                    int bits, int x, int y) {
  831|   628k|  if (bits == 0) return 0;
  ------------------
  |  Branch (831:7): [True: 589k, False: 39.5k]
  ------------------
  832|  39.5k|  return image[xsize * (y >> bits) + (x >> bits)];
  833|   628k|}
vp8l_dec.c:ReadSymbol:
  181|  2.16M|                                  VP8LBitReader* const br) {
  182|  2.16M|  int nbits;
  183|  2.16M|  uint32_t val = VP8LPrefetchBits(br);
  184|  2.16M|  table += val & HUFFMAN_TABLE_MASK;
  ------------------
  |  |   30|  2.16M|#define HUFFMAN_TABLE_MASK ((1 << HUFFMAN_TABLE_BITS) - 1)
  |  |  ------------------
  |  |  |  |   29|  2.16M|#define HUFFMAN_TABLE_BITS 8
  |  |  ------------------
  ------------------
  185|  2.16M|  nbits = table->bits - HUFFMAN_TABLE_BITS;
  ------------------
  |  |   29|  2.16M|#define HUFFMAN_TABLE_BITS 8
  ------------------
  186|  2.16M|  if (nbits > 0) {
  ------------------
  |  Branch (186:7): [True: 38.6k, False: 2.12M]
  ------------------
  187|  38.6k|    VP8LSetBitPos(br, br->bit_pos + HUFFMAN_TABLE_BITS);
  ------------------
  |  |   29|  38.6k|#define HUFFMAN_TABLE_BITS 8
  ------------------
  188|  38.6k|    val = VP8LPrefetchBits(br);
  189|  38.6k|    table += table->value;
  190|  38.6k|    table += val & ((1 << nbits) - 1);
  191|  38.6k|  }
  192|  2.16M|  VP8LSetBitPos(br, br->bit_pos + table->bits);
  193|  2.16M|  return table->value;
  194|  2.16M|}
vp8l_dec.c:GetCopyLength:
  159|  25.5k|                                     VP8LBitReader* const br) {
  160|       |  // Length and distance prefixes are encoded the same way.
  161|  25.5k|  return GetCopyDistance(length_symbol, br);
  162|  25.5k|}
vp8l_dec.c:GetCopyDistance:
  148|  51.1k|                                       VP8LBitReader* const br) {
  149|  51.1k|  int extra_bits, offset;
  150|  51.1k|  if (distance_symbol < 4) {
  ------------------
  |  Branch (150:7): [True: 45.0k, False: 6.11k]
  ------------------
  151|  45.0k|    return distance_symbol + 1;
  152|  45.0k|  }
  153|  6.11k|  extra_bits = (distance_symbol - 2) >> 1;
  154|  6.11k|  offset = (2 + (distance_symbol & 1)) << extra_bits;
  155|  6.11k|  return offset + VP8LReadBits(br, extra_bits) + 1;
  156|  51.1k|}
vp8l_dec.c:PlaneCodeToDistance:
  164|  25.5k|static WEBP_INLINE int PlaneCodeToDistance(int xsize, int plane_code) {
  165|  25.5k|  if (plane_code > CODE_TO_PLANE_CODES) {
  ------------------
  |  |   66|  25.5k|#define CODE_TO_PLANE_CODES 120
  ------------------
  |  Branch (165:7): [True: 1.62k, False: 23.9k]
  ------------------
  166|  1.62k|    return plane_code - CODE_TO_PLANE_CODES;
  ------------------
  |  |   66|  1.62k|#define CODE_TO_PLANE_CODES 120
  ------------------
  167|  23.9k|  } else {
  168|  23.9k|    const int dist_code = kCodeToPlane[plane_code - 1];
  169|  23.9k|    const int yoffset = dist_code >> 4;
  170|  23.9k|    const int xoffset = 8 - (dist_code & 0xf);
  171|  23.9k|    const int dist = yoffset * xsize + xoffset;
  172|  23.9k|    return (dist >= 1) ? dist : 1;  // dist<1 can happen if xsize is very small
  ------------------
  |  Branch (172:12): [True: 23.7k, False: 201]
  ------------------
  173|  23.9k|  }
  174|  25.5k|}
vp8l_dec.c:DecodeImageData:
 1223|  2.34k|                           ProcessRowsFunc process_func) {
 1224|  2.34k|  int row = dec->last_pixel / width;
 1225|  2.34k|  int col = dec->last_pixel % width;
 1226|  2.34k|  VP8LBitReader* const br = &dec->br;
 1227|  2.34k|  VP8LMetadata* const hdr = &dec->hdr;
 1228|  2.34k|  uint32_t* src = data + dec->last_pixel;
 1229|  2.34k|  uint32_t* last_cached = src;
 1230|  2.34k|  uint32_t* const src_end = data + width * height;     // End of data
 1231|  2.34k|  uint32_t* const src_last = data + width * last_row;  // Last pixel to decode
 1232|  2.34k|  const int len_code_limit = NUM_LITERAL_CODES + NUM_LENGTH_CODES;
  ------------------
  |  |   43|  2.34k|#define NUM_LITERAL_CODES 256
  ------------------
                const int len_code_limit = NUM_LITERAL_CODES + NUM_LENGTH_CODES;
  ------------------
  |  |   44|  2.34k|#define NUM_LENGTH_CODES 24
  ------------------
 1233|  2.34k|  const int color_cache_limit = len_code_limit + hdr->color_cache_size;
 1234|  2.34k|  int next_sync_row = dec->incremental ? row : 1 << 24;
  ------------------
  |  Branch (1234:23): [True: 0, False: 2.34k]
  ------------------
 1235|  2.34k|  VP8LColorCache* const color_cache =
 1236|  2.34k|      (hdr->color_cache_size > 0) ? &hdr->color_cache : NULL;
  ------------------
  |  Branch (1236:7): [True: 1.19k, False: 1.15k]
  ------------------
 1237|  2.34k|  const int mask = hdr->huffman_mask;
 1238|  2.34k|  const HTreeGroup* htree_group =
 1239|  2.34k|      (src < src_last) ? GetHtreeGroupForPos(hdr, col, row) : NULL;
  ------------------
  |  Branch (1239:7): [True: 2.34k, False: 0]
  ------------------
 1240|  2.34k|  assert(dec->last_row < last_row);
 1241|  2.34k|  assert(src_last <= src_end);
 1242|       |
 1243|  2.52G|  while (src < src_last) {
  ------------------
  |  Branch (1243:10): [True: 2.52G, False: 1.95k]
  ------------------
 1244|  2.52G|    int code;
 1245|  2.52G|    if (row >= next_sync_row) {
  ------------------
  |  Branch (1245:9): [True: 0, False: 2.52G]
  ------------------
 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|  2.52G|    if ((col & mask) == 0) {
  ------------------
  |  Branch (1252:9): [True: 602k, False: 2.52G]
  ------------------
 1253|   602k|      htree_group = GetHtreeGroupForPos(hdr, col, row);
 1254|   602k|    }
 1255|  2.52G|    assert(htree_group != NULL);
 1256|  2.52G|    if (htree_group->is_trivial_code) {
  ------------------
  |  Branch (1256:9): [True: 2.52G, False: 3.41M]
  ------------------
 1257|  2.52G|      *src = htree_group->literal_arb;
 1258|  2.52G|      goto AdvanceByOne;
 1259|  2.52G|    }
 1260|  3.41M|    VP8LFillBitWindow(br);
 1261|  3.41M|    if (htree_group->use_packed_table) {
  ------------------
  |  Branch (1261:9): [True: 2.82M, False: 596k]
  ------------------
 1262|  2.82M|      code = ReadPackedSymbols(htree_group, br, src);
 1263|  2.82M|      if (VP8LIsEndOfStream(br)) break;
  ------------------
  |  Branch (1263:11): [True: 182, False: 2.82M]
  ------------------
 1264|  2.82M|      if (code == PACKED_NON_LITERAL_CODE) goto AdvanceByOne;
  ------------------
  |  |  198|  2.82M|#define PACKED_NON_LITERAL_CODE 0  // must be < NUM_LITERAL_CODES
  ------------------
  |  Branch (1264:11): [True: 2.76M, False: 55.4k]
  ------------------
 1265|  2.82M|    } else {
 1266|   596k|      code = ReadSymbol(htree_group->htrees[GREEN], br);
 1267|   596k|    }
 1268|   652k|    if (code < NUM_LITERAL_CODES) {  // Literal
  ------------------
  |  |   43|   652k|#define NUM_LITERAL_CODES 256
  ------------------
  |  Branch (1268:9): [True: 562k, False: 89.7k]
  ------------------
 1269|   562k|      if (htree_group->is_trivial_literal) {
  ------------------
  |  Branch (1269:11): [True: 48.9k, False: 513k]
  ------------------
 1270|  48.9k|        if (VP8LIsEndOfStream(br)) break;
  ------------------
  |  Branch (1270:13): [True: 24, False: 48.9k]
  ------------------
 1271|  48.9k|        *src = htree_group->literal_arb | (code << 8);
 1272|   513k|      } else {
 1273|   513k|        int red, blue, alpha;
 1274|   513k|        red = ReadSymbol(htree_group->htrees[RED], br);
 1275|   513k|        VP8LFillBitWindow(br);
 1276|   513k|        blue = ReadSymbol(htree_group->htrees[BLUE], br);
 1277|   513k|        alpha = ReadSymbol(htree_group->htrees[ALPHA], br);
 1278|   513k|        if (VP8LIsEndOfStream(br)) break;
  ------------------
  |  Branch (1278:13): [True: 52, False: 513k]
  ------------------
 1279|   513k|        *src = ((uint32_t)alpha << 24) | (red << 16) | (code << 8) | blue;
 1280|   513k|      }
 1281|  2.52G|    AdvanceByOne:
 1282|  2.52G|      ++src;
 1283|  2.52G|      ++col;
 1284|  2.52G|      if (col >= width) {
  ------------------
  |  Branch (1284:11): [True: 567k, False: 2.52G]
  ------------------
 1285|   567k|        col = 0;
 1286|   567k|        ++row;
 1287|   567k|        if (process_func != NULL) {
  ------------------
  |  Branch (1287:13): [True: 473k, False: 93.6k]
  ------------------
 1288|   473k|          if (row <= last_row) {
  ------------------
  |  Branch (1288:15): [True: 473k, False: 0]
  ------------------
 1289|   473k|            process_func(dec, row, /*wait_for_biggest_batch=*/1);
 1290|   473k|          }
 1291|   473k|        }
 1292|   567k|        if (color_cache != NULL) {
  ------------------
  |  Branch (1292:13): [True: 94.9k, False: 472k]
  ------------------
 1293|  6.18M|          while (last_cached < src) {
  ------------------
  |  Branch (1293:18): [True: 6.09M, False: 94.9k]
  ------------------
 1294|  6.09M|            VP8LColorCacheInsert(color_cache, *last_cached++);
 1295|  6.09M|          }
 1296|  94.9k|        }
 1297|   567k|      }
 1298|  2.52G|    } else if (code < len_code_limit) {  // Backward reference
  ------------------
  |  Branch (1298:16): [True: 25.5k, False: 64.1k]
  ------------------
 1299|  25.5k|      int dist_code, dist;
 1300|  25.5k|      const int length_sym = code - NUM_LITERAL_CODES;
  ------------------
  |  |   43|  25.5k|#define NUM_LITERAL_CODES 256
  ------------------
 1301|  25.5k|      const int length = GetCopyLength(length_sym, br);
 1302|  25.5k|      const int dist_symbol = ReadSymbol(htree_group->htrees[DIST], br);
 1303|  25.5k|      VP8LFillBitWindow(br);
 1304|  25.5k|      dist_code = GetCopyDistance(dist_symbol, br);
 1305|  25.5k|      dist = PlaneCodeToDistance(width, dist_code);
 1306|       |
 1307|  25.5k|      if (VP8LIsEndOfStream(br)) break;
  ------------------
  |  Branch (1307:11): [True: 80, False: 25.4k]
  ------------------
 1308|  25.4k|      if (src - data < (ptrdiff_t)dist || src_end - src < (ptrdiff_t)length) {
  ------------------
  |  Branch (1308:11): [True: 28, False: 25.4k]
  |  Branch (1308:43): [True: 20, False: 25.4k]
  ------------------
 1309|     48|        goto Error;
 1310|  25.4k|      } else {
 1311|  25.4k|        CopyBlock32b(src, dist, length);
 1312|  25.4k|      }
 1313|  25.4k|      src += length;
 1314|  25.4k|      col += length;
 1315|  40.5k|      while (col >= width) {
  ------------------
  |  Branch (1315:14): [True: 15.1k, False: 25.4k]
  ------------------
 1316|  15.1k|        col -= width;
 1317|  15.1k|        ++row;
 1318|  15.1k|        if (process_func != NULL) {
  ------------------
  |  Branch (1318:13): [True: 5.56k, False: 9.58k]
  ------------------
 1319|  5.56k|          if (row <= last_row) {
  ------------------
  |  Branch (1319:15): [True: 5.56k, False: 0]
  ------------------
 1320|  5.56k|            process_func(dec, row, /*wait_for_biggest_batch=*/1);
 1321|  5.56k|          }
 1322|  5.56k|        }
 1323|  15.1k|      }
 1324|       |      // Because of the check done above (before 'src' was incremented by
 1325|       |      // 'length'), the following holds true.
 1326|  25.4k|      assert(src <= src_end);
 1327|  25.4k|      if (col & mask) htree_group = GetHtreeGroupForPos(hdr, col, row);
  ------------------
  |  Branch (1327:11): [True: 24.1k, False: 1.31k]
  ------------------
 1328|  25.4k|      if (color_cache != NULL) {
  ------------------
  |  Branch (1328:11): [True: 6.07k, False: 19.3k]
  ------------------
 1329|   186k|        while (last_cached < src) {
  ------------------
  |  Branch (1329:16): [True: 180k, False: 6.07k]
  ------------------
 1330|   180k|          VP8LColorCacheInsert(color_cache, *last_cached++);
 1331|   180k|        }
 1332|  6.07k|      }
 1333|  64.1k|    } else if (code < color_cache_limit) {  // Color cache
  ------------------
  |  Branch (1333:16): [True: 64.1k, False: 0]
  ------------------
 1334|  64.1k|      const int key = code - len_code_limit;
 1335|  64.1k|      assert(color_cache != NULL);
 1336|  64.1k|      if (VP8LIsEndOfStream(br)) break;
  ------------------
  |  Branch (1336:11): [True: 6, False: 64.1k]
  ------------------
 1337|   173k|      while (last_cached < src) {
  ------------------
  |  Branch (1337:14): [True: 108k, False: 64.1k]
  ------------------
 1338|   108k|        VP8LColorCacheInsert(color_cache, *last_cached++);
 1339|   108k|      }
 1340|  64.1k|      *src = VP8LColorCacheLookup(color_cache, key);
 1341|  64.1k|      goto AdvanceByOne;
 1342|  64.1k|    } else {  // Not reached
 1343|      0|      goto Error;
 1344|      0|    }
 1345|   652k|  }
 1346|       |
 1347|  2.29k|  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.29k|  assert(!dec->incremental || (br->eos && src < src_last) || src >= src_last);
 1359|  2.29k|  if (dec->incremental && br->eos && src < src_last) {
  ------------------
  |  Branch (1359:7): [True: 0, False: 2.29k]
  |  Branch (1359:27): [True: 0, False: 0]
  |  Branch (1359:38): [True: 0, False: 0]
  ------------------
 1360|      0|    RestoreState(dec);
 1361|  2.29k|  } else if ((dec->incremental && src >= src_last) || !br->eos) {
  ------------------
  |  Branch (1361:15): [True: 0, False: 2.29k]
  |  Branch (1361:35): [True: 0, False: 0]
  |  Branch (1361:55): [True: 1.95k, False: 344]
  ------------------
 1362|       |    // Process the remaining rows corresponding to last row-block.
 1363|  1.95k|    if (process_func != NULL) {
  ------------------
  |  Branch (1363:9): [True: 625, False: 1.32k]
  ------------------
 1364|    625|      process_func(dec, row > last_row ? last_row : row,
  ------------------
  |  Branch (1364:25): [True: 0, False: 625]
  ------------------
 1365|    625|                   /*wait_for_biggest_batch=*/0);
 1366|    625|    }
 1367|  1.95k|    dec->status = VP8_STATUS_OK;
 1368|  1.95k|    dec->last_pixel = (int)(src - data);  // end-of-scan marker
 1369|  1.95k|  } else {
 1370|       |    // if not incremental, and we are past the end of buffer (eos=1), then this
 1371|       |    // is a real bitstream error.
 1372|    344|    goto Error;
 1373|    344|  }
 1374|  1.95k|  return 1;
 1375|       |
 1376|    392|Error:
 1377|    392|  return VP8LSetError(dec, VP8_STATUS_BITSTREAM_ERROR);
 1378|  2.29k|}
vp8l_dec.c:ReadPackedSymbols:
  201|  2.82M|                                         uint32_t* const dst) {
  202|  2.82M|  const uint32_t val = VP8LPrefetchBits(br) & (HUFFMAN_PACKED_TABLE_SIZE - 1);
  ------------------
  |  |   74|  2.82M|#define HUFFMAN_PACKED_TABLE_SIZE (1u << HUFFMAN_PACKED_BITS)
  |  |  ------------------
  |  |  |  |   73|  2.82M|#define HUFFMAN_PACKED_BITS 6
  |  |  ------------------
  ------------------
  203|  2.82M|  const HuffmanCode32 code = group->packed_table[val];
  204|  2.82M|  assert(group->use_packed_table);
  205|  2.82M|  if (code.bits < BITS_SPECIAL_MARKER) {
  ------------------
  |  |  197|  2.82M|#define BITS_SPECIAL_MARKER 0x100  // something large enough (and a bit-mask)
  ------------------
  |  Branch (205:7): [True: 2.76M, False: 55.5k]
  ------------------
  206|  2.76M|    VP8LSetBitPos(br, br->bit_pos + code.bits);
  207|  2.76M|    *dst = code.value;
  208|  2.76M|    return PACKED_NON_LITERAL_CODE;
  ------------------
  |  |  198|  2.76M|#define PACKED_NON_LITERAL_CODE 0  // must be < NUM_LITERAL_CODES
  ------------------
  209|  2.76M|  } else {
  210|  55.5k|    VP8LSetBitPos(br, br->bit_pos + code.bits - BITS_SPECIAL_MARKER);
  ------------------
  |  |  197|  55.5k|#define BITS_SPECIAL_MARKER 0x100  // something large enough (and a bit-mask)
  ------------------
  211|       |    assert(code.value >= NUM_LITERAL_CODES);
  212|  55.5k|    return code.value;
  213|  55.5k|  }
  214|  2.82M|}
vp8l_dec.c:CopyBlock32b:
 1095|  25.4k|                                     int length) {
 1096|  25.4k|  const uint32_t* const src = dst - dist;
 1097|  25.4k|  if (dist <= 2 && length >= 4 && ((uintptr_t)dst & 3) == 0) {
  ------------------
  |  Branch (1097:7): [True: 22.4k, False: 2.97k]
  |  Branch (1097:20): [True: 17.9k, False: 4.50k]
  |  Branch (1097:35): [True: 17.9k, False: 0]
  ------------------
 1098|  17.9k|    uint64_t pattern;
 1099|  17.9k|    if (dist == 1) {
  ------------------
  |  Branch (1099:9): [True: 17.7k, False: 226]
  ------------------
 1100|  17.7k|      pattern = (uint64_t)src[0];
 1101|  17.7k|      pattern |= pattern << 32;
 1102|  17.7k|    } else {
 1103|    226|      WEBP_UNSAFE_MEMCPY(&pattern, src, sizeof(pattern));
  ------------------
  |  |  174|    226|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
 1104|    226|    }
 1105|  17.9k|    CopySmallPattern32b(src, dst, length, pattern);
 1106|  17.9k|  } else if (dist >= length) {  // no overlap
  ------------------
  |  Branch (1106:14): [True: 1.56k, False: 5.91k]
  ------------------
 1107|  1.56k|    WEBP_UNSAFE_MEMCPY(dst, src, length * sizeof(*dst));
  ------------------
  |  |  174|  1.56k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
 1108|  5.91k|  } else {
 1109|  5.91k|    int i;
 1110|   102k|    for (i = 0; i < length; ++i) dst[i] = src[i];
  ------------------
  |  Branch (1110:17): [True: 96.7k, False: 5.91k]
  ------------------
 1111|  5.91k|  }
 1112|  25.4k|}
vp8l_dec.c:CopySmallPattern32b:
 1078|  17.9k|                                            int length, uint64_t pattern) {
 1079|  17.9k|  int i;
 1080|  17.9k|  if ((uintptr_t)dst & 4) {  // Align 'dst' to 8-bytes boundary.
  ------------------
  |  Branch (1080:7): [True: 8.01k, False: 9.95k]
  ------------------
 1081|  8.01k|    *dst++ = *src++;
 1082|  8.01k|    pattern = (pattern >> 32) | (pattern << 32);
 1083|  8.01k|    --length;
 1084|  8.01k|  }
 1085|  17.9k|  assert(0 == ((uintptr_t)dst & 7));
 1086|   169k|  for (i = 0; i < (length >> 1); ++i) {
  ------------------
  |  Branch (1086:15): [True: 151k, False: 17.9k]
  ------------------
 1087|   151k|    ((uint64_t*)dst)[i] = pattern;  // Copy the pattern 8 bytes at a time.
 1088|   151k|  }
 1089|  17.9k|  if (length & 1) {  // Finish with left-over.
  ------------------
  |  Branch (1089:7): [True: 8.00k, False: 9.96k]
  ------------------
 1090|  8.00k|    dst[i << 1] = src[i << 1];
 1091|  8.00k|  }
 1092|  17.9k|}
vp8l_dec.c:ApplyInverseTransforms:
  852|  30.3k|                                   int num_rows, const uint32_t* const rows) {
  853|  30.3k|  int n = dec->next_transform;
  854|  30.3k|  const int cache_pixs = dec->width * num_rows;
  855|  30.3k|  const int end_row = start_row + num_rows;
  856|  30.3k|  const uint32_t* rows_in = rows;
  857|  30.3k|  uint32_t* const rows_out = dec->argb_cache;
  858|       |
  859|       |  // Inverse transforms.
  860|  68.9k|  while (n-- > 0) {
  ------------------
  |  Branch (860:10): [True: 38.6k, False: 30.3k]
  ------------------
  861|  38.6k|    VP8LTransform* const transform = &dec->transforms[n];
  862|  38.6k|    VP8LInverseTransform(transform, start_row, end_row, rows_in, rows_out);
  863|  38.6k|    rows_in = rows_out;
  864|  38.6k|  }
  865|  30.3k|  if (rows_in != rows_out) {
  ------------------
  |  Branch (865:7): [True: 12.1k, False: 18.2k]
  ------------------
  866|       |    // No transform called, hence just copy.
  867|  12.1k|    WEBP_UNSAFE_MEMCPY(rows_out, rows_in, cache_pixs * sizeof(*rows_out));
  ------------------
  |  |  174|  12.1k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
  868|  12.1k|  }
  869|  30.3k|}
vp8l_dec.c:ProcessRows:
  874|   479k|                        int wait_for_biggest_batch) {
  875|   479k|  const uint32_t* const rows = dec->pixels + dec->width * dec->last_row;
  876|   479k|  int num_rows;
  877|       |
  878|       |  // In case of YUV conversion and if we do not need to get to the last row.
  879|   479k|  if (wait_for_biggest_batch) {
  ------------------
  |  Branch (879:7): [True: 479k, False: 625]
  ------------------
  880|       |    // In case of YUV conversion, and if we do not use the whole cropping
  881|       |    // region.
  882|   479k|    if (!WebPIsRGBMode(dec->output->colorspace) && row >= dec->io->crop_top &&
  ------------------
  |  Branch (882:9): [True: 0, False: 479k]
  |  Branch (882:52): [True: 0, False: 0]
  ------------------
  883|      0|        row < dec->io->crop_bottom) {
  ------------------
  |  Branch (883:9): [True: 0, False: 0]
  ------------------
  884|       |      // Make sure the number of rows to process is even.
  885|      0|      if ((row - dec->io->crop_top) % 2 != 0) return;
  ------------------
  |  Branch (885:11): [True: 0, False: 0]
  ------------------
  886|       |      // Make sure the cache is as full as possible.
  887|      0|      if (row % NUM_ARGB_CACHE_ROWS != 0 &&
  ------------------
  |  |   40|      0|#define NUM_ARGB_CACHE_ROWS 16
  ------------------
  |  Branch (887:11): [True: 0, False: 0]
  ------------------
  888|      0|          (row + 1) % NUM_ARGB_CACHE_ROWS != 0) {
  ------------------
  |  |   40|      0|#define NUM_ARGB_CACHE_ROWS 16
  ------------------
  |  Branch (888:11): [True: 0, False: 0]
  ------------------
  889|      0|        return;
  890|      0|      }
  891|   479k|    } else {
  892|   479k|      if (row % NUM_ARGB_CACHE_ROWS != 0) return;
  ------------------
  |  |   40|   479k|#define NUM_ARGB_CACHE_ROWS 16
  ------------------
  |  Branch (892:11): [True: 449k, False: 29.7k]
  ------------------
  893|   479k|    }
  894|   479k|  }
  895|  30.3k|  num_rows = row - dec->last_row;
  896|  30.3k|  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|  30.3k|  assert(num_rows <= NUM_ARGB_CACHE_ROWS);
  900|  30.3k|  if (num_rows > 0) {  // Emit output.
  ------------------
  |  Branch (900:7): [True: 30.3k, False: 15]
  ------------------
  901|  30.3k|    VP8Io* const io = dec->io;
  902|  30.3k|    uint8_t* rows_data = (uint8_t*)dec->argb_cache;
  903|  30.3k|    const int in_stride = io->width * sizeof(uint32_t);  // in unit of RGBA
  904|  30.3k|    ApplyInverseTransforms(dec, dec->last_row, num_rows, rows);
  905|  30.3k|    if (!SetCropWindow(io, dec->last_row, row, &rows_data, in_stride)) {
  ------------------
  |  Branch (905:9): [True: 0, False: 30.3k]
  ------------------
  906|       |      // Nothing to output (this time).
  907|  30.3k|    } else {
  908|  30.3k|      const WebPDecBuffer* const output = dec->output;
  909|  30.3k|      if (WebPIsRGBMode(output->colorspace)) {  // convert to RGBA
  ------------------
  |  Branch (909:11): [True: 30.3k, False: 0]
  ------------------
  910|  30.3k|        const WebPRGBABuffer* const buf = &output->u.RGBA;
  911|  30.3k|        uint8_t* const rgba =
  912|  30.3k|            buf->rgba + (ptrdiff_t)dec->last_out_row * buf->stride;
  913|  30.3k|        const int num_rows_out =
  914|  30.3k|#if !defined(WEBP_REDUCE_SIZE)
  915|  30.3k|            io->use_scaling ? EmitRescaledRowsRGBA(dec, rows_data, in_stride,
  ------------------
  |  Branch (915:13): [True: 0, False: 30.3k]
  ------------------
  916|      0|                                                   io->mb_h, rgba, buf->stride)
  917|  30.3k|                            :
  918|  30.3k|#endif  // WEBP_REDUCE_SIZE
  919|  30.3k|                            EmitRows(output->colorspace, rows_data, in_stride,
  920|  30.3k|                                     io->mb_w, io->mb_h, rgba, buf->stride);
  921|       |        // Update 'last_out_row'.
  922|  30.3k|        dec->last_out_row += num_rows_out;
  923|  30.3k|      } else {  // convert to YUVA
  924|      0|        dec->last_out_row =
  925|      0|            io->use_scaling
  ------------------
  |  Branch (925:13): [True: 0, False: 0]
  ------------------
  926|      0|                ? EmitRescaledRowsYUVA(dec, rows_data, in_stride, io->mb_h)
  927|      0|                : EmitRowsYUVA(rows_data, io, in_stride,
  928|      0|                               dec->accumulated_rgb_pixels, dec);
  929|      0|      }
  930|  30.3k|      assert(dec->last_out_row <= output->height);
  931|  30.3k|    }
  932|  30.3k|  }
  933|       |
  934|       |  // Update 'last_row'.
  935|  30.3k|  dec->last_row = row;
  936|       |  assert(dec->last_row <= dec->height);
  937|  30.3k|}
vp8l_dec.c:SetCropWindow:
  806|  30.3k|                         uint8_t** const in_data, int pixel_stride) {
  807|  30.3k|  assert(y_start < y_end);
  808|  30.3k|  assert(io->crop_left < io->crop_right);
  809|  30.3k|  if (y_end > io->crop_bottom) {
  ------------------
  |  Branch (809:7): [True: 0, False: 30.3k]
  ------------------
  810|      0|    y_end = io->crop_bottom;  // make sure we don't overflow on last row.
  811|      0|  }
  812|  30.3k|  if (y_start < io->crop_top) {
  ------------------
  |  Branch (812:7): [True: 0, False: 30.3k]
  ------------------
  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|  30.3k|  if (y_start >= y_end) return 0;  // Crop window is empty.
  ------------------
  |  Branch (817:7): [True: 0, False: 30.3k]
  ------------------
  818|       |
  819|  30.3k|  *in_data += io->crop_left * sizeof(uint32_t);
  820|       |
  821|  30.3k|  io->mb_y = y_start - io->crop_top;
  822|  30.3k|  io->mb_w = io->crop_right - io->crop_left;
  823|  30.3k|  io->mb_h = y_end - y_start;
  824|  30.3k|  return 1;  // Non-empty crop window.
  825|  30.3k|}
vp8l_dec.c:EmitRows:
  654|  30.3k|                    int out_stride) {
  655|  30.3k|  int lines = mb_h;
  656|  30.3k|  uint8_t* row_out = out;
  657|   509k|  while (lines-- > 0) {
  ------------------
  |  Branch (657:10): [True: 478k, False: 30.3k]
  ------------------
  658|   478k|    VP8LConvertFromBGRA((const uint32_t*)row_in, mb_w, colorspace, row_out);
  659|   478k|    row_in += in_stride;
  660|   478k|    row_out += out_stride;
  661|   478k|  }
  662|  30.3k|  return mb_h;  // Num rows out == num rows in.
  663|  30.3k|}

WebPParseHeaders:
  435|  3.87k|VP8StatusCode WebPParseHeaders(WebPHeaderStructure* const headers) {
  436|       |  // status is marked volatile as a workaround for a clang-3.8 (aarch64) bug
  437|  3.87k|  volatile VP8StatusCode status;
  438|  3.87k|  int has_animation = 0;
  439|  3.87k|  assert(headers != NULL);
  440|       |  // fill out headers, ignore width/height/has_alpha.
  441|  3.87k|  {
  442|  3.87k|    const uint8_t* WEBP_BIDI_INDEXABLE const bounded_data =
  443|  3.87k|        WEBP_UNSAFE_FORGE_BIDI_INDEXABLE(const uint8_t*, headers->data,
  ------------------
  |  |  180|  3.87k|#define WEBP_UNSAFE_FORGE_BIDI_INDEXABLE(typ, ptr, size) ((typ)(ptr))
  ------------------
  444|  3.87k|                                         headers->data_size);
  445|  3.87k|    status = ParseHeadersInternal(bounded_data, headers->data_size, NULL, NULL,
  446|  3.87k|                                  NULL, &has_animation, NULL, headers);
  447|  3.87k|  }
  448|  3.87k|  if (status == VP8_STATUS_OK || status == VP8_STATUS_NOT_ENOUGH_DATA) {
  ------------------
  |  Branch (448:7): [True: 3.85k, False: 18]
  |  Branch (448:34): [True: 18, 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|  3.87k|    if (has_animation) {
  ------------------
  |  Branch (452:9): [True: 0, False: 3.87k]
  ------------------
  453|      0|      status = VP8_STATUS_UNSUPPORTED_FEATURE;
  454|      0|    }
  455|  3.87k|  }
  456|  3.87k|  return status;
  457|  3.87k|}
WebPResetDecParams:
  462|  3.87k|void WebPResetDecParams(WebPDecParams* const params) {
  463|  3.87k|  if (params != NULL) {
  ------------------
  |  Branch (463:7): [True: 3.87k, False: 0]
  ------------------
  464|  3.87k|    WEBP_UNSAFE_MEMSET(params, 0, sizeof(*params));
  ------------------
  |  |  175|  3.87k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  465|  3.87k|  }
  466|  3.87k|}
WebPGetInfo:
  750|  8.67k|                size_t data_size, int* width, int* height) {
  751|  8.67k|  WebPBitstreamFeatures features;
  752|       |
  753|  8.67k|  if (GetFeatures(data, data_size, &features) != VP8_STATUS_OK) {
  ------------------
  |  Branch (753:7): [True: 919, False: 7.75k]
  ------------------
  754|    919|    return 0;
  755|    919|  }
  756|       |
  757|  7.75k|  if (width != NULL) {
  ------------------
  |  Branch (757:7): [True: 3.84k, False: 3.90k]
  ------------------
  758|  3.84k|    *width = features.width;
  759|  3.84k|  }
  760|  7.75k|  if (height != NULL) {
  ------------------
  |  Branch (760:7): [True: 3.84k, False: 3.90k]
  ------------------
  761|  3.84k|    *height = features.height;
  762|  3.84k|  }
  763|       |
  764|  7.75k|  return 1;
  765|  8.67k|}
WebPInitDecoderConfigInternal:
  770|  3.90k|int WebPInitDecoderConfigInternal(WebPDecoderConfig* config, int version) {
  771|  3.90k|  if (WEBP_ABI_IS_INCOMPATIBLE(version, WEBP_DECODER_ABI_VERSION)) {
  ------------------
  |  |   84|  3.90k|#define WEBP_ABI_IS_INCOMPATIBLE(a, b) (((a) >> 8) != ((b) >> 8))
  |  |  ------------------
  |  |  |  Branch (84:40): [True: 0, False: 3.90k]
  |  |  ------------------
  ------------------
  772|      0|    return 0;  // version mismatch
  773|      0|  }
  774|  3.90k|  if (config == NULL) {
  ------------------
  |  Branch (774:7): [True: 0, False: 3.90k]
  ------------------
  775|      0|    return 0;
  776|      0|  }
  777|  3.90k|  WEBP_UNSAFE_MEMSET(config, 0, sizeof(*config));
  ------------------
  |  |  175|  3.90k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  778|  3.90k|  DefaultFeatures(&config->input);
  779|  3.90k|  if (!WebPInitDecBuffer(&config->output)) {
  ------------------
  |  Branch (779:7): [True: 0, False: 3.90k]
  ------------------
  780|      0|    return 0;
  781|      0|  }
  782|  3.90k|  return 1;
  783|  3.90k|}
WebPGetFeaturesInternal:
  844|  7.78k|                                      int version) {
  845|  7.78k|  if (WEBP_ABI_IS_INCOMPATIBLE(version, WEBP_DECODER_ABI_VERSION)) {
  ------------------
  |  |   84|  7.78k|#define WEBP_ABI_IS_INCOMPATIBLE(a, b) (((a) >> 8) != ((b) >> 8))
  |  |  ------------------
  |  |  |  Branch (84:40): [True: 0, False: 7.78k]
  |  |  ------------------
  ------------------
  846|      0|    return VP8_STATUS_INVALID_PARAM;  // version mismatch
  847|      0|  }
  848|  7.78k|  if (features == NULL) {
  ------------------
  |  Branch (848:7): [True: 0, False: 7.78k]
  ------------------
  849|      0|    return VP8_STATUS_INVALID_PARAM;
  850|      0|  }
  851|  7.78k|  return GetFeatures(data, data_size, features);
  852|  7.78k|}
WebPDecode:
  855|  3.87k|                         size_t data_size, WebPDecoderConfig* config) {
  856|  3.87k|  WebPDecParams params;
  857|  3.87k|  VP8StatusCode status;
  858|       |
  859|  3.87k|  if (config == NULL) {
  ------------------
  |  Branch (859:7): [True: 0, False: 3.87k]
  ------------------
  860|      0|    return VP8_STATUS_INVALID_PARAM;
  861|      0|  }
  862|       |
  863|  3.87k|  status = GetFeatures(data, data_size, &config->input);
  864|  3.87k|  if (status != VP8_STATUS_OK) {
  ------------------
  |  Branch (864:7): [True: 0, False: 3.87k]
  ------------------
  865|      0|    if (status == VP8_STATUS_NOT_ENOUGH_DATA) {
  ------------------
  |  Branch (865:9): [True: 0, False: 0]
  ------------------
  866|      0|      return VP8_STATUS_BITSTREAM_ERROR;  // Not-enough-data treated as error.
  867|      0|    }
  868|      0|    return status;
  869|      0|  }
  870|       |
  871|  3.87k|  WebPResetDecParams(&params);
  872|  3.87k|  params.options = &config->options;
  873|  3.87k|  params.output = &config->output;
  874|  3.87k|  if (WebPAvoidSlowMemory(params.output, &config->input)) {
  ------------------
  |  Branch (874:7): [True: 0, False: 3.87k]
  ------------------
  875|       |    // decoding to slow memory: use a temporary in-mem buffer to decode into.
  876|      0|    WebPDecBuffer in_mem_buffer;
  877|      0|    if (!WebPInitDecBuffer(&in_mem_buffer)) {
  ------------------
  |  Branch (877:9): [True: 0, False: 0]
  ------------------
  878|      0|      return VP8_STATUS_INVALID_PARAM;
  879|      0|    }
  880|      0|    in_mem_buffer.colorspace = config->output.colorspace;
  881|      0|    in_mem_buffer.width = config->input.width;
  882|      0|    in_mem_buffer.height = config->input.height;
  883|      0|    params.output = &in_mem_buffer;
  884|      0|    status = DecodeInto(data, data_size, &params);
  885|      0|    if (status == VP8_STATUS_OK) {  // do the slow-copy
  ------------------
  |  Branch (885:9): [True: 0, False: 0]
  ------------------
  886|      0|      status = WebPCopyDecBufferPixels(&in_mem_buffer, &config->output);
  887|      0|    }
  888|      0|    WebPFreeDecBuffer(&in_mem_buffer);
  889|  3.87k|  } else {
  890|  3.87k|    status = DecodeInto(data, data_size, &params);
  891|  3.87k|  }
  892|       |
  893|  3.87k|  return status;
  894|  3.87k|}
WebPIoInitFromOptions:
  907|  2.82k|                          VP8Io* const io, WEBP_CSP_MODE src_colorspace) {
  908|  2.82k|  const int W = io->width;
  909|  2.82k|  const int H = io->height;
  910|  2.82k|  int x = 0, y = 0, w = W, h = H;
  911|       |
  912|       |  // Cropping
  913|  2.82k|  io->use_cropping = (options != NULL) && options->use_cropping;
  ------------------
  |  Branch (913:22): [True: 2.82k, False: 0]
  |  Branch (913:43): [True: 0, False: 2.82k]
  ------------------
  914|  2.82k|  if (io->use_cropping) {
  ------------------
  |  Branch (914:7): [True: 0, False: 2.82k]
  ------------------
  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|  2.82k|  io->crop_left = x;
  928|  2.82k|  io->crop_top = y;
  929|  2.82k|  io->crop_right = x + w;
  930|  2.82k|  io->crop_bottom = y + h;
  931|  2.82k|  io->mb_w = w;
  932|  2.82k|  io->mb_h = h;
  933|       |
  934|       |  // Scaling
  935|  2.82k|  io->use_scaling = (options != NULL) && options->use_scaling;
  ------------------
  |  Branch (935:21): [True: 2.82k, False: 0]
  |  Branch (935:42): [True: 0, False: 2.82k]
  ------------------
  936|  2.82k|  if (io->use_scaling) {
  ------------------
  |  Branch (936:7): [True: 0, False: 2.82k]
  ------------------
  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|  2.82k|  io->bypass_filtering = (options != NULL) && options->bypass_filtering;
  ------------------
  |  Branch (947:26): [True: 2.82k, False: 0]
  |  Branch (947:47): [True: 0, False: 2.82k]
  ------------------
  948|       |
  949|       |  // Fancy upsampler
  950|  2.82k|#ifdef FANCY_UPSAMPLING
  951|  2.82k|  io->fancy_upsampling = (options == NULL) || (!options->no_fancy_upsampling);
  ------------------
  |  Branch (951:26): [True: 0, False: 2.82k]
  |  Branch (951:47): [True: 2.82k, False: 0]
  ------------------
  952|  2.82k|#endif
  953|       |
  954|  2.82k|  if (io->use_scaling) {
  ------------------
  |  Branch (954:7): [True: 0, False: 2.82k]
  ------------------
  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|  2.82k|  return 1;
  961|  2.82k|}
webp_dec.c:ParseHeadersInternal:
  298|  24.2k|    WebPHeaderStructure* const headers) {
  299|  24.2k|  size_t data_size = data_size_param;
  300|  24.2k|  const uint8_t* WEBP_COUNTED_BY(data_size) data = data_param;
  301|  24.2k|  int canvas_width = 0;
  302|  24.2k|  int canvas_height = 0;
  303|  24.2k|  int image_width = 0;
  304|  24.2k|  int image_height = 0;
  305|  24.2k|  int found_riff = 0;
  306|  24.2k|  int found_vp8x = 0;
  307|  24.2k|  int animation_present = 0;
  308|  24.2k|  const int have_all_data = (headers != NULL) ? headers->have_all_data : 0;
  ------------------
  |  Branch (308:29): [True: 3.87k, False: 20.3k]
  ------------------
  309|       |
  310|  24.2k|  VP8StatusCode status;
  311|  24.2k|  WebPHeaderStructure hdrs;
  312|       |
  313|  24.2k|  if (data == NULL || data_size < RIFF_HEADER_SIZE) {
  ------------------
  |  |   76|  24.2k|#define RIFF_HEADER_SIZE 12  // Size of the RIFF header ("RIFFnnnnWEBP").
  ------------------
  |  Branch (313:7): [True: 0, False: 24.2k]
  |  Branch (313:23): [True: 130, False: 24.0k]
  ------------------
  314|    130|    return VP8_STATUS_NOT_ENOUGH_DATA;
  315|    130|  }
  316|  24.0k|  WEBP_UNSAFE_MEMSET(&hdrs, 0, sizeof(hdrs));
  ------------------
  |  |  175|  24.0k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  317|  24.0k|  hdrs.data = data;
  318|  24.0k|  hdrs.data_size = data_size;
  319|       |
  320|       |  // Skip over RIFF header.
  321|  24.0k|  status = ParseRIFF(&data, &data_size, have_all_data, &hdrs.riff_size);
  322|  24.0k|  if (status != VP8_STATUS_OK) {
  ------------------
  |  Branch (322:7): [True: 4, False: 24.0k]
  ------------------
  323|      4|    return status;  // Wrong RIFF header / insufficient data.
  324|      4|  }
  325|  24.0k|  found_riff = (hdrs.riff_size > 0);
  326|       |
  327|       |  // Skip over VP8X.
  328|  24.0k|  {
  329|  24.0k|    uint32_t flags = 0;
  330|  24.0k|    status = ParseVP8X(&data, &data_size, &found_vp8x, &canvas_width,
  331|  24.0k|                       &canvas_height, &flags);
  332|  24.0k|    if (status != VP8_STATUS_OK) {
  ------------------
  |  Branch (332:9): [True: 105, False: 23.9k]
  ------------------
  333|    105|      return status;  // Wrong VP8X / insufficient data.
  334|    105|    }
  335|  23.9k|    animation_present = !!(flags & ANIMATION_FLAG);
  336|  23.9k|    if (!found_riff && found_vp8x) {
  ------------------
  |  Branch (336:9): [True: 23.9k, False: 0]
  |  Branch (336:24): [True: 10, False: 23.9k]
  ------------------
  337|       |      // Note: This restriction may be removed in the future, if it becomes
  338|       |      // necessary to send VP8X chunk to the decoder.
  339|     10|      return VP8_STATUS_BITSTREAM_ERROR;
  340|     10|    }
  341|  23.9k|    if (has_alpha != NULL) *has_alpha = !!(flags & ALPHA_FLAG);
  ------------------
  |  Branch (341:9): [True: 20.0k, False: 3.87k]
  ------------------
  342|  23.9k|    if (has_animation != NULL) *has_animation = animation_present;
  ------------------
  |  Branch (342:9): [True: 23.9k, False: 0]
  ------------------
  343|  23.9k|    if (format != NULL) *format = 0;  // default = undefined
  ------------------
  |  Branch (343:9): [True: 20.0k, False: 3.87k]
  ------------------
  344|       |
  345|  23.9k|    image_width = canvas_width;
  346|  23.9k|    image_height = canvas_height;
  347|  23.9k|    if (found_vp8x && animation_present && headers == NULL) {
  ------------------
  |  Branch (347:9): [True: 0, False: 23.9k]
  |  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|  23.9k|  }
  352|       |
  353|  23.9k|  if (data_size < TAG_SIZE) {
  ------------------
  |  |   73|  23.9k|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  |  Branch (353:7): [True: 0, False: 23.9k]
  ------------------
  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|  23.9k|  if ((found_riff && found_vp8x) ||
  ------------------
  |  Branch (359:8): [True: 0, False: 23.9k]
  |  Branch (359:22): [True: 0, False: 0]
  ------------------
  360|  23.9k|      (!found_riff && !found_vp8x && !memcmp(data, "ALPH", TAG_SIZE))) {
  ------------------
  |  |   73|  23.9k|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  |  Branch (360:8): [True: 23.9k, False: 0]
  |  Branch (360:23): [True: 23.9k, False: 0]
  |  Branch (360:38): [True: 224, False: 23.7k]
  ------------------
  361|    224|    size_t local_alpha_data_size = 0;
  362|    224|    const uint8_t* WEBP_COUNTED_BY(local_alpha_data_size) local_alpha_data =
  363|    224|        NULL;
  364|    224|    status = ParseOptionalChunks(&data, &data_size, hdrs.riff_size,
  365|    224|                                 &local_alpha_data, &local_alpha_data_size);
  366|    224|    if (status != VP8_STATUS_OK) {
  ------------------
  |  Branch (366:9): [True: 224, False: 0]
  ------------------
  367|    224|      goto ReturnWidthHeight;  // Invalid chunk size / insufficient data.
  368|    224|    }
  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|  23.7k|  status = ParseVP8Header(&data, &data_size, have_all_data, hdrs.riff_size,
  375|  23.7k|                          &hdrs.compressed_size, &hdrs.is_lossless);
  376|  23.7k|  if (status != VP8_STATUS_OK) {
  ------------------
  |  Branch (376:7): [True: 18, False: 23.7k]
  ------------------
  377|     18|    goto ReturnWidthHeight;  // Wrong VP8/VP8L chunk-header / insufficient data.
  378|     18|  }
  379|  23.7k|  if (hdrs.compressed_size > MAX_CHUNK_PAYLOAD) {
  ------------------
  |  |   89|  23.7k|#define MAX_CHUNK_PAYLOAD (~0U - CHUNK_HEADER_SIZE - 1)
  |  |  ------------------
  |  |  |  |   75|  23.7k|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  |  |  ------------------
  ------------------
  |  Branch (379:7): [True: 2, False: 23.7k]
  ------------------
  380|      2|    return VP8_STATUS_BITSTREAM_ERROR;
  381|      2|  }
  382|       |
  383|  23.7k|  if (format != NULL && !animation_present) {
  ------------------
  |  Branch (383:7): [True: 19.8k, False: 3.85k]
  |  Branch (383:25): [True: 19.8k, False: 0]
  ------------------
  384|  19.8k|    *format = hdrs.is_lossless ? 2 : 1;
  ------------------
  |  Branch (384:15): [True: 8.83k, False: 11.0k]
  ------------------
  385|  19.8k|  }
  386|       |
  387|  23.7k|  if (!hdrs.is_lossless) {
  ------------------
  |  Branch (387:7): [True: 13.1k, False: 10.5k]
  ------------------
  388|  13.1k|    if (data_size < VP8_FRAME_HEADER_SIZE) {
  ------------------
  |  |   24|  13.1k|#define VP8_FRAME_HEADER_SIZE 10  // Size of the frame header within VP8 data.
  ------------------
  |  Branch (388:9): [True: 25, False: 13.1k]
  ------------------
  389|     25|      status = VP8_STATUS_NOT_ENOUGH_DATA;
  390|     25|      goto ReturnWidthHeight;
  391|     25|    }
  392|       |    // Validates raw VP8 data.
  393|  13.1k|    if (!VP8GetInfo(data, data_size, (uint32_t)hdrs.compressed_size,
  ------------------
  |  Branch (393:9): [True: 309, False: 12.8k]
  ------------------
  394|  13.1k|                    &image_width, &image_height)) {
  395|    309|      return VP8_STATUS_BITSTREAM_ERROR;
  396|    309|    }
  397|  13.1k|  } else {
  398|  10.5k|    if (data_size < VP8L_FRAME_HEADER_SIZE) {
  ------------------
  |  |   33|  10.5k|#define VP8L_FRAME_HEADER_SIZE 5  // Size of the VP8L frame header.
  ------------------
  |  Branch (398:9): [True: 76, False: 10.4k]
  ------------------
  399|     76|      status = VP8_STATUS_NOT_ENOUGH_DATA;
  400|     76|      goto ReturnWidthHeight;
  401|     76|    }
  402|       |    // Validates raw VP8L data.
  403|  10.4k|    if (!VP8LGetInfo(data, data_size, &image_width, &image_height, has_alpha)) {
  ------------------
  |  Branch (403:9): [True: 32, False: 10.4k]
  ------------------
  404|     32|      return VP8_STATUS_BITSTREAM_ERROR;
  405|     32|    }
  406|  10.4k|  }
  407|       |  // Validates image size coherency.
  408|  23.2k|  if (found_vp8x) {
  ------------------
  |  Branch (408:7): [True: 0, False: 23.2k]
  ------------------
  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|  23.2k|  if (headers != NULL) {
  ------------------
  |  Branch (413:7): [True: 3.85k, False: 19.4k]
  ------------------
  414|  3.85k|    *headers = hdrs;
  415|  3.85k|    headers->offset = data - headers->data;
  416|  3.85k|    assert((uint64_t)(data - headers->data) < MAX_CHUNK_PAYLOAD);
  417|  3.85k|    assert(headers->offset == headers->data_size - data_size);
  418|  3.85k|  }
  419|  23.6k|ReturnWidthHeight:
  420|  23.6k|  if (status == VP8_STATUS_OK ||
  ------------------
  |  Branch (420:7): [True: 23.2k, False: 343]
  ------------------
  421|  23.2k|      (status == VP8_STATUS_NOT_ENOUGH_DATA && found_vp8x && headers == NULL)) {
  ------------------
  |  Branch (421:8): [True: 340, False: 3]
  |  Branch (421:48): [True: 0, False: 340]
  |  Branch (421:62): [True: 0, False: 0]
  ------------------
  422|  23.2k|    if (has_alpha != NULL) {
  ------------------
  |  Branch (422:9): [True: 19.4k, False: 3.85k]
  ------------------
  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|  19.4k|      *has_alpha |= (hdrs.alpha_data != NULL);
  426|  19.4k|    }
  427|  23.2k|    if (width != NULL) *width = image_width;
  ------------------
  |  Branch (427:9): [True: 19.4k, False: 3.85k]
  ------------------
  428|  23.2k|    if (height != NULL) *height = image_height;
  ------------------
  |  Branch (428:9): [True: 19.4k, False: 3.85k]
  ------------------
  429|  23.2k|    return VP8_STATUS_OK;
  430|  23.2k|  } else {
  431|    343|    return status;
  432|    343|  }
  433|  23.6k|}
webp_dec.c:ParseRIFF:
   68|  24.0k|                               size_t* WEBP_SINGLE const riff_size) {
   69|  24.0k|  assert(data != NULL);
   70|  24.0k|  assert(data_size != NULL);
   71|  24.0k|  assert(riff_size != NULL);
   72|       |
   73|  24.0k|  *riff_size = 0;  // Default: no RIFF present.
   74|  24.0k|  if (*data_size >= RIFF_HEADER_SIZE && !memcmp(*data, "RIFF", TAG_SIZE)) {
  ------------------
  |  |   76|  48.1k|#define RIFF_HEADER_SIZE 12  // Size of the RIFF header ("RIFFnnnnWEBP").
  ------------------
                if (*data_size >= RIFF_HEADER_SIZE && !memcmp(*data, "RIFF", TAG_SIZE)) {
  ------------------
  |  |   73|  24.0k|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  |  Branch (74:7): [True: 24.0k, False: 0]
  |  Branch (74:41): [True: 4, False: 24.0k]
  ------------------
   75|      4|    if (memcmp(*data + 8, "WEBP", TAG_SIZE)) {
  ------------------
  |  |   73|      4|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  |  Branch (75:9): [True: 4, False: 0]
  ------------------
   76|      4|      return VP8_STATUS_BITSTREAM_ERROR;  // Wrong image file signature.
   77|      4|    } 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|      4|  }
   95|  24.0k|  return VP8_STATUS_OK;
   96|  24.0k|}
webp_dec.c:ParseVP8X:
  111|  24.0k|                               uint32_t* WEBP_SINGLE const flags_ptr) {
  112|  24.0k|  const uint32_t vp8x_size = CHUNK_HEADER_SIZE + VP8X_CHUNK_SIZE;
  ------------------
  |  |   75|  24.0k|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
                const uint32_t vp8x_size = CHUNK_HEADER_SIZE + VP8X_CHUNK_SIZE;
  ------------------
  |  |   79|  24.0k|#define VP8X_CHUNK_SIZE 10   // Size of a VP8X chunk.
  ------------------
  113|  24.0k|  assert(data != NULL);
  114|  24.0k|  assert(data_size != NULL);
  115|  24.0k|  assert(found_vp8x != NULL);
  116|       |
  117|  24.0k|  *found_vp8x = 0;
  118|       |
  119|  24.0k|  if (*data_size < CHUNK_HEADER_SIZE) {
  ------------------
  |  |   75|  24.0k|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  |  Branch (119:7): [True: 0, False: 24.0k]
  ------------------
  120|      0|    return VP8_STATUS_NOT_ENOUGH_DATA;  // Insufficient data.
  121|      0|  }
  122|       |
  123|  24.0k|  if (!memcmp(*data, "VP8X", TAG_SIZE)) {
  ------------------
  |  |   73|  24.0k|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  |  Branch (123:7): [True: 115, False: 23.9k]
  ------------------
  124|    115|    int width, height;
  125|    115|    uint32_t flags;
  126|    115|    const uint32_t chunk_size = GetLE32(*data + TAG_SIZE);
  ------------------
  |  |   73|    115|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  127|    115|    if (chunk_size != VP8X_CHUNK_SIZE) {
  ------------------
  |  |   79|    115|#define VP8X_CHUNK_SIZE 10   // Size of a VP8X chunk.
  ------------------
  |  Branch (127:9): [True: 85, False: 30]
  ------------------
  128|     85|      return VP8_STATUS_BITSTREAM_ERROR;  // Wrong chunk size.
  129|     85|    }
  130|       |
  131|       |    // Verify if enough data is available to validate the VP8X chunk.
  132|     30|    if (*data_size < vp8x_size) {
  ------------------
  |  Branch (132:9): [True: 12, False: 18]
  ------------------
  133|     12|      return VP8_STATUS_NOT_ENOUGH_DATA;  // Insufficient data.
  134|     12|    }
  135|     18|    flags = GetLE32(*data + 8);
  136|     18|    width = 1 + GetLE24(*data + 12);
  137|     18|    height = 1 + GetLE24(*data + 15);
  138|     18|    if (width * (uint64_t)height >= MAX_IMAGE_AREA) {
  ------------------
  |  |   82|     18|#define MAX_IMAGE_AREA (1ULL << 32)    // 32-bit max for width x height.
  ------------------
  |  Branch (138:9): [True: 8, False: 10]
  ------------------
  139|      8|      return VP8_STATUS_BITSTREAM_ERROR;  // image is too large
  140|      8|    }
  141|       |
  142|     10|    if (flags_ptr != NULL) *flags_ptr = flags;
  ------------------
  |  Branch (142:9): [True: 10, False: 0]
  ------------------
  143|     10|    if (width_ptr != NULL) *width_ptr = width;
  ------------------
  |  Branch (143:9): [True: 10, False: 0]
  ------------------
  144|     10|    if (height_ptr != NULL) *height_ptr = height;
  ------------------
  |  Branch (144:9): [True: 10, False: 0]
  ------------------
  145|       |    // Skip over VP8X header bytes.
  146|     10|    *data_size -= vp8x_size;
  147|     10|    *data += vp8x_size;
  148|     10|    *found_vp8x = 1;
  149|     10|  }
  150|  23.9k|  return VP8_STATUS_OK;
  151|  24.0k|}
webp_dec.c:ParseOptionalChunks:
  164|    224|    size_t* WEBP_SINGLE const alpha_size) {
  165|    224|  size_t buf_size;
  166|    224|  const uint8_t* WEBP_COUNTED_BY(buf_size) buf;
  167|    224|  uint64_t total_size = TAG_SIZE +           // "WEBP".
  ------------------
  |  |   73|    224|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  168|    224|                        CHUNK_HEADER_SIZE +  // "VP8Xnnnn".
  ------------------
  |  |   75|    224|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  169|    224|                        VP8X_CHUNK_SIZE;     // data.
  ------------------
  |  |   79|    224|#define VP8X_CHUNK_SIZE 10   // Size of a VP8X chunk.
  ------------------
  170|    224|  assert(data != NULL);
  171|    224|  assert(data_size != NULL);
  172|    224|  buf = *data;
  173|    224|  buf_size = *data_size;
  174|       |
  175|    224|  assert(alpha_data != NULL);
  176|    224|  assert(alpha_size != NULL);
  177|    224|  *alpha_data = NULL;
  178|    224|  *alpha_size = 0;
  179|       |
  180|    523|  while (1) {
  ------------------
  |  Branch (180:10): [True: 523, Folded]
  ------------------
  181|    523|    uint32_t chunk_size;
  182|    523|    uint32_t disk_chunk_size;  // chunk_size with padding
  183|       |
  184|    523|    *data_size = buf_size;
  185|    523|    *data = buf;
  186|       |
  187|    523|    if (buf_size < CHUNK_HEADER_SIZE) {  // Insufficient data.
  ------------------
  |  |   75|    523|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  |  Branch (187:9): [True: 24, False: 499]
  ------------------
  188|     24|      return VP8_STATUS_NOT_ENOUGH_DATA;
  189|     24|    }
  190|       |
  191|    499|    chunk_size = GetLE32(buf + TAG_SIZE);
  ------------------
  |  |   73|    499|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  192|    499|    if (chunk_size > MAX_CHUNK_PAYLOAD) {
  ------------------
  |  |   89|    499|#define MAX_CHUNK_PAYLOAD (~0U - CHUNK_HEADER_SIZE - 1)
  |  |  ------------------
  |  |  |  |   75|    499|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  |  |  ------------------
  ------------------
  |  Branch (192:9): [True: 3, False: 496]
  ------------------
  193|      3|      return VP8_STATUS_BITSTREAM_ERROR;  // Not a valid chunk size.
  194|      3|    }
  195|       |    // For odd-sized chunk-payload, there's one byte padding at the end.
  196|    496|    disk_chunk_size = (CHUNK_HEADER_SIZE + chunk_size + 1) & ~1u;
  ------------------
  |  |   75|    496|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  197|    496|    total_size += disk_chunk_size;
  198|       |
  199|       |    // Check that total bytes skipped so far does not exceed riff_size.
  200|    496|    if (riff_size > 0 && (total_size > riff_size)) {
  ------------------
  |  Branch (200:9): [True: 0, False: 496]
  |  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|    496|    if (!memcmp(buf, "VP8 ", TAG_SIZE) || !memcmp(buf, "VP8L", TAG_SIZE)) {
  ------------------
  |  |   73|    496|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
                  if (!memcmp(buf, "VP8 ", TAG_SIZE) || !memcmp(buf, "VP8L", TAG_SIZE)) {
  ------------------
  |  |   73|    496|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  |  Branch (208:9): [True: 0, False: 496]
  |  Branch (208:43): [True: 0, False: 496]
  ------------------
  209|      0|      return VP8_STATUS_OK;
  210|      0|    }
  211|       |
  212|    496|    if (buf_size < disk_chunk_size) {  // Insufficient data.
  ------------------
  |  Branch (212:9): [True: 197, False: 299]
  ------------------
  213|    197|      return VP8_STATUS_NOT_ENOUGH_DATA;
  214|    197|    }
  215|       |
  216|    299|    if (!memcmp(buf, "ALPH", TAG_SIZE)) {  // A valid ALPH header.
  ------------------
  |  |   73|    299|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  |  Branch (216:9): [True: 89, False: 210]
  ------------------
  217|     89|      *alpha_data = buf + CHUNK_HEADER_SIZE;
  ------------------
  |  |   75|     89|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  218|     89|      *alpha_size = chunk_size;
  219|     89|    }
  220|       |
  221|       |    // We have a full and valid chunk; skip it.
  222|    299|    buf += disk_chunk_size;
  223|    299|    buf_size -= disk_chunk_size;
  224|    299|  }
  225|    224|}
webp_dec.c:ParseVP8Header:
  240|  23.7k|                                    int* WEBP_SINGLE const is_lossless) {
  241|  23.7k|  const size_t local_data_size = *data_size;
  242|  23.7k|  const uint8_t* WEBP_COUNTED_BY(local_data_size) const data = *data_ptr;
  243|  23.7k|  const int is_vp8 = !memcmp(data, "VP8 ", TAG_SIZE);
  ------------------
  |  |   73|  23.7k|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  244|  23.7k|  const int is_vp8l = !memcmp(data, "VP8L", TAG_SIZE);
  ------------------
  |  |   73|  23.7k|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  245|  23.7k|  const uint32_t minimal_size =
  246|  23.7k|      TAG_SIZE + CHUNK_HEADER_SIZE;  // "WEBP" + "VP8 nnnn" OR
  ------------------
  |  |   73|  23.7k|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
                    TAG_SIZE + CHUNK_HEADER_SIZE;  // "WEBP" + "VP8 nnnn" OR
  ------------------
  |  |   75|  23.7k|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  247|       |                                     // "WEBP" + "VP8Lnnnn"
  248|  23.7k|  (void)local_data_size;
  249|  23.7k|  assert(data != NULL);
  250|  23.7k|  assert(data_size != NULL);
  251|  23.7k|  assert(chunk_size != NULL);
  252|  23.7k|  assert(is_lossless != NULL);
  253|       |
  254|  23.7k|  if (*data_size < CHUNK_HEADER_SIZE) {
  ------------------
  |  |   75|  23.7k|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  |  Branch (254:7): [True: 0, False: 23.7k]
  ------------------
  255|      0|    return VP8_STATUS_NOT_ENOUGH_DATA;  // Insufficient data.
  256|      0|  }
  257|       |
  258|  23.7k|  if (is_vp8 || is_vp8l) {
  ------------------
  |  Branch (258:7): [True: 27, False: 23.7k]
  |  Branch (258:17): [True: 243, False: 23.4k]
  ------------------
  259|       |    // Bitstream contains VP8/VP8L header.
  260|    270|    const uint32_t size = GetLE32(data + TAG_SIZE);
  ------------------
  |  |   73|    270|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  261|    270|    if ((riff_size >= minimal_size) && (size > riff_size - minimal_size)) {
  ------------------
  |  Branch (261:9): [True: 0, False: 270]
  |  Branch (261:40): [True: 0, False: 0]
  ------------------
  262|      0|      return VP8_STATUS_BITSTREAM_ERROR;  // Inconsistent size information.
  263|      0|    }
  264|    270|    if (have_all_data && (size > *data_size - CHUNK_HEADER_SIZE)) {
  ------------------
  |  |   75|     18|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  |  Branch (264:9): [True: 18, False: 252]
  |  Branch (264:26): [True: 18, False: 0]
  ------------------
  265|     18|      return VP8_STATUS_NOT_ENOUGH_DATA;  // Truncated bitstream.
  266|     18|    }
  267|       |    // Skip over CHUNK_HEADER_SIZE bytes from VP8/VP8L Header.
  268|    252|    *chunk_size = size;
  269|    252|    *data_size -= CHUNK_HEADER_SIZE;
  ------------------
  |  |   75|    252|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  270|    252|    *data_ptr += CHUNK_HEADER_SIZE;
  ------------------
  |  |   75|    252|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  271|    252|    *is_lossless = is_vp8l;
  272|  23.4k|  } else {
  273|       |    // Raw VP8/VP8L bitstream (no header).
  274|  23.4k|    *is_lossless = VP8LCheckSignature(data, *data_size);
  275|  23.4k|    *chunk_size = *data_size;
  276|  23.4k|  }
  277|       |
  278|  23.7k|  return VP8_STATUS_OK;
  279|  23.7k|}
webp_dec.c:DecodeInto:
  474|  3.87k|    WebPDecParams* const params) {
  475|  3.87k|  VP8StatusCode status;
  476|  3.87k|  VP8Io io;
  477|  3.87k|  WebPHeaderStructure headers;
  478|       |
  479|  3.87k|  headers.data = data;
  480|  3.87k|  headers.data_size = data_size;
  481|  3.87k|  headers.have_all_data = 1;
  482|  3.87k|  status = WebPParseHeaders(&headers);  // Process Pre-VP8 chunks.
  483|  3.87k|  if (status != VP8_STATUS_OK) {
  ------------------
  |  Branch (483:7): [True: 18, False: 3.85k]
  ------------------
  484|     18|    return status;
  485|     18|  }
  486|       |
  487|  3.87k|  assert(params != NULL);
  488|  3.85k|  if (!VP8InitIo(&io)) {
  ------------------
  |  Branch (488:7): [True: 0, False: 3.85k]
  ------------------
  489|      0|    return VP8_STATUS_INVALID_PARAM;
  490|      0|  }
  491|  3.85k|  io.data = headers.data + headers.offset;
  492|  3.85k|  io.data_size = headers.data_size - headers.offset;
  493|  3.85k|  WebPInitCustomIo(params, &io);  // Plug the I/O functions.
  494|       |
  495|  3.85k|  if (!headers.is_lossless) {
  ------------------
  |  Branch (495:7): [True: 2.13k, False: 1.72k]
  ------------------
  496|  2.13k|    VP8Decoder* const dec = VP8New();
  497|  2.13k|    if (dec == NULL) {
  ------------------
  |  Branch (497:9): [True: 0, False: 2.13k]
  ------------------
  498|      0|      return VP8_STATUS_OUT_OF_MEMORY;
  499|      0|    }
  500|  2.13k|    dec->alpha_data = headers.alpha_data;
  501|  2.13k|    dec->alpha_data_size = headers.alpha_data_size;
  502|       |
  503|       |    // Decode bitstream header, update io->width/io->height.
  504|  2.13k|    if (!VP8GetHeaders(dec, &io)) {
  ------------------
  |  Branch (504:9): [True: 103, False: 2.03k]
  ------------------
  505|    103|      status = dec->status;  // An error occurred. Grab error status.
  506|  2.03k|    } else {
  507|       |      // Allocate/check output buffers.
  508|  2.03k|      status = WebPAllocateDecBuffer(io.width, io.height, params->options,
  509|  2.03k|                                     params->output);
  510|  2.03k|      if (status == VP8_STATUS_OK) {  // Decode
  ------------------
  |  Branch (510:11): [True: 2.03k, False: 0]
  ------------------
  511|       |        // This change must be done before calling VP8Decode()
  512|  2.03k|        dec->mt_method =
  513|  2.03k|            VP8GetThreadMethod(params->options, &headers, io.width, io.height);
  514|  2.03k|        VP8InitDithering(params->options, dec);
  515|  2.03k|        if (!VP8Decode(dec, &io)) {
  ------------------
  |  Branch (515:13): [True: 1.92k, False: 112]
  ------------------
  516|  1.92k|          status = dec->status;
  517|  1.92k|        }
  518|  2.03k|      }
  519|  2.03k|    }
  520|  2.13k|    VP8Delete(dec);
  521|  2.13k|  } else {
  522|  1.72k|    VP8LDecoder* const dec = VP8LNew();
  523|  1.72k|    if (dec == NULL) {
  ------------------
  |  Branch (523:9): [True: 0, False: 1.72k]
  ------------------
  524|      0|      return VP8_STATUS_OUT_OF_MEMORY;
  525|      0|    }
  526|  1.72k|    if (!VP8LDecodeHeader(dec, &io)) {
  ------------------
  |  Branch (526:9): [True: 933, False: 787]
  ------------------
  527|    933|      status = dec->status;  // An error occurred. Grab error status.
  528|    933|    } else {
  529|       |      // Allocate/check output buffers.
  530|    787|      status = WebPAllocateDecBuffer(io.width, io.height, params->options,
  531|    787|                                     params->output);
  532|    787|      if (status == VP8_STATUS_OK) {  // Decode
  ------------------
  |  Branch (532:11): [True: 787, False: 0]
  ------------------
  533|    787|        if (!VP8LDecodeImage(dec)) {
  ------------------
  |  Branch (533:13): [True: 162, False: 625]
  ------------------
  534|    162|          status = dec->status;
  535|    162|        }
  536|    787|      }
  537|    787|    }
  538|  1.72k|    VP8LDelete(dec);
  539|  1.72k|  }
  540|       |
  541|  3.85k|  if (status != VP8_STATUS_OK) {
  ------------------
  |  Branch (541:7): [True: 3.11k, False: 737]
  ------------------
  542|  3.11k|    WebPFreeDecBuffer(params->output);
  543|  3.11k|  } else {
  544|    737|    if (params->options != NULL && params->options->flip) {
  ------------------
  |  Branch (544:9): [True: 737, False: 0]
  |  Branch (544:36): [True: 0, False: 737]
  ------------------
  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|    737|  }
  550|  3.85k|  return status;
  551|  3.85k|}
webp_dec.c:GetFeatures:
  734|  20.3k|                                 WebPBitstreamFeatures* const features) {
  735|  20.3k|  if (features == NULL || data == NULL) {
  ------------------
  |  Branch (735:7): [True: 0, False: 20.3k]
  |  Branch (735:27): [True: 2, False: 20.3k]
  ------------------
  736|      2|    return VP8_STATUS_INVALID_PARAM;
  737|      2|  }
  738|  20.3k|  DefaultFeatures(features);
  739|       |
  740|       |  // Only parse enough of the data to retrieve the features.
  741|  20.3k|  return ParseHeadersInternal(
  742|  20.3k|      data, data_size, &features->width, &features->height,
  743|       |      &features->has_alpha, &features->has_animation, &features->format, NULL);
  744|  20.3k|}
webp_dec.c:DefaultFeatures:
  726|  24.2k|static void DefaultFeatures(WebPBitstreamFeatures* const features) {
  727|  24.2k|  assert(features != NULL);
  728|  24.2k|  WEBP_UNSAFE_MEMSET(features, 0, sizeof(*features));
  ------------------
  |  |  175|  24.2k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  729|  24.2k|}

WebPAnimDecoderNewInternal:
  103|  3.90k|    int abi_version) {
  104|  3.90k|  WebPAnimDecoderOptions options;
  105|  3.90k|  WebPAnimDecoder* dec = NULL;
  106|  3.90k|  WebPBitstreamFeatures features;
  107|  3.90k|  if (webp_data == NULL ||
  ------------------
  |  Branch (107:7): [True: 0, False: 3.90k]
  ------------------
  108|  3.90k|      WEBP_ABI_IS_INCOMPATIBLE(abi_version, WEBP_DEMUX_ABI_VERSION)) {
  ------------------
  |  |   84|  3.90k|#define WEBP_ABI_IS_INCOMPATIBLE(a, b) (((a) >> 8) != ((b) >> 8))
  |  |  ------------------
  |  |  |  Branch (84:40): [True: 0, False: 3.90k]
  |  |  ------------------
  ------------------
  109|      0|    return NULL;
  110|      0|  }
  111|       |
  112|       |  // Validate the bitstream before doing expensive allocations. The demuxer may
  113|       |  // be more tolerant than the decoder.
  114|  3.90k|  if (WebPGetFeatures(webp_data->bytes, webp_data->size, &features) !=
  ------------------
  |  Branch (114:7): [True: 0, False: 3.90k]
  ------------------
  115|  3.90k|      VP8_STATUS_OK) {
  116|      0|    return NULL;
  117|      0|  }
  118|       |
  119|       |  // Note: calloc() so that the pointer members are initialized to NULL.
  120|  3.90k|  dec = (WebPAnimDecoder*)WebPSafeCalloc(1ULL, sizeof(*dec));
  121|  3.90k|  if (dec == NULL) goto Error;
  ------------------
  |  Branch (121:7): [True: 0, False: 3.90k]
  ------------------
  122|       |
  123|  3.90k|  if (dec_options != NULL) {
  ------------------
  |  Branch (123:7): [True: 0, False: 3.90k]
  ------------------
  124|      0|    options = *dec_options;
  125|  3.90k|  } else {
  126|  3.90k|    DefaultDecoderOptions(&options);
  127|  3.90k|  }
  128|  3.90k|  if (!ApplyDecoderOptions(&options, dec)) goto Error;
  ------------------
  |  Branch (128:7): [True: 0, False: 3.90k]
  ------------------
  129|       |
  130|  3.90k|  dec->demux = WebPDemux(webp_data);
  131|  3.90k|  if (dec->demux == NULL) goto Error;
  ------------------
  |  Branch (131:7): [True: 34, False: 3.87k]
  ------------------
  132|       |
  133|  3.87k|  dec->info.canvas_width = WebPDemuxGetI(dec->demux, WEBP_FF_CANVAS_WIDTH);
  134|  3.87k|  dec->info.canvas_height = WebPDemuxGetI(dec->demux, WEBP_FF_CANVAS_HEIGHT);
  135|  3.87k|  dec->info.loop_count = WebPDemuxGetI(dec->demux, WEBP_FF_LOOP_COUNT);
  136|  3.87k|  dec->info.bgcolor = WebPDemuxGetI(dec->demux, WEBP_FF_BACKGROUND_COLOR);
  137|  3.87k|  dec->info.frame_count = WebPDemuxGetI(dec->demux, WEBP_FF_FRAME_COUNT);
  138|       |
  139|       |  // Note: calloc() because we fill frame with zeroes as well.
  140|  3.87k|  dec->curr_frame = (uint8_t*)WebPSafeCalloc(
  141|  3.87k|      dec->info.canvas_width * NUM_CHANNELS, dec->info.canvas_height);
  ------------------
  |  |   29|  3.87k|#define NUM_CHANNELS 4
  ------------------
  142|  3.87k|  if (dec->curr_frame == NULL) goto Error;
  ------------------
  |  Branch (142:7): [True: 0, False: 3.87k]
  ------------------
  143|  3.87k|  dec->prev_frame_disposed = (uint8_t*)WebPSafeCalloc(
  144|  3.87k|      dec->info.canvas_width * NUM_CHANNELS, dec->info.canvas_height);
  ------------------
  |  |   29|  3.87k|#define NUM_CHANNELS 4
  ------------------
  145|  3.87k|  if (dec->prev_frame_disposed == NULL) goto Error;
  ------------------
  |  Branch (145:7): [True: 0, False: 3.87k]
  ------------------
  146|       |
  147|  3.87k|  WebPAnimDecoderReset(dec);
  148|  3.87k|  return dec;
  149|       |
  150|     34|Error:
  151|     34|  WebPAnimDecoderDelete(dec);
  152|       |  return NULL;
  153|  3.87k|}
WebPAnimDecoderGetInfo:
  155|  3.87k|int WebPAnimDecoderGetInfo(const WebPAnimDecoder* dec, WebPAnimInfo* info) {
  156|  3.87k|  if (dec == NULL || info == NULL) return 0;
  ------------------
  |  Branch (156:7): [True: 0, False: 3.87k]
  |  Branch (156:22): [True: 0, False: 3.87k]
  ------------------
  157|  3.87k|  *info = dec->info;
  158|  3.87k|  return 1;
  159|  3.87k|}
WebPAnimDecoderGetNext:
  335|  3.87k|                           int* timestamp_ptr) {
  336|  3.87k|  WebPIterator iter;
  337|  3.87k|  uint32_t width;
  338|  3.87k|  uint32_t height;
  339|  3.87k|  int is_key_frame;
  340|  3.87k|  int timestamp;
  341|  3.87k|  BlendRowFunc blend_row;
  342|       |
  343|  3.87k|  if (dec == NULL || buf_ptr == NULL || timestamp_ptr == NULL) return 0;
  ------------------
  |  Branch (343:7): [True: 0, False: 3.87k]
  |  Branch (343:22): [True: 0, False: 3.87k]
  |  Branch (343:41): [True: 0, False: 3.87k]
  ------------------
  344|  3.87k|  if (!WebPAnimDecoderHasMoreFrames(dec)) return 0;
  ------------------
  |  Branch (344:7): [True: 0, False: 3.87k]
  ------------------
  345|       |
  346|  3.87k|  width = dec->info.canvas_width;
  347|  3.87k|  height = dec->info.canvas_height;
  348|  3.87k|  blend_row = dec->blend_func;
  349|       |
  350|       |  // Get compressed frame.
  351|  3.87k|  if (!WebPDemuxGetFrame(dec->demux, dec->next_frame, &iter)) {
  ------------------
  |  Branch (351:7): [True: 0, False: 3.87k]
  ------------------
  352|      0|    return 0;
  353|      0|  }
  354|  3.87k|  timestamp = dec->prev_frame_timestamp + iter.duration;
  355|       |
  356|       |  // Initialize.
  357|  3.87k|  is_key_frame = IsKeyFrame(&iter, &dec->prev_iter,
  358|  3.87k|                            dec->prev_frame_was_keyframe, width, height);
  359|  3.87k|  if (is_key_frame) {
  ------------------
  |  Branch (359:7): [True: 3.87k, False: 0]
  ------------------
  360|  3.87k|    if (!ZeroFillCanvas(dec->curr_frame, width, height)) {
  ------------------
  |  Branch (360:9): [True: 0, False: 3.87k]
  ------------------
  361|      0|      goto Error;
  362|      0|    }
  363|  3.87k|  } else {
  364|      0|    if (!CopyCanvas(dec->prev_frame_disposed, dec->curr_frame, width, height)) {
  ------------------
  |  Branch (364:9): [True: 0, False: 0]
  ------------------
  365|      0|      goto Error;
  366|      0|    }
  367|      0|  }
  368|       |
  369|       |  // Decode.
  370|  3.87k|  {
  371|  3.87k|    const uint8_t* in = iter.fragment.bytes;
  372|  3.87k|    const size_t in_size = iter.fragment.size;
  373|  3.87k|    const uint32_t stride = width * NUM_CHANNELS;  // at most 25 + 2 bits
  ------------------
  |  |   29|  3.87k|#define NUM_CHANNELS 4
  ------------------
  374|  3.87k|    const uint64_t out_offset = (uint64_t)iter.y_offset * stride +
  375|  3.87k|                                (uint64_t)iter.x_offset * NUM_CHANNELS;  // 53b
  ------------------
  |  |   29|  3.87k|#define NUM_CHANNELS 4
  ------------------
  376|  3.87k|    const uint64_t size = (uint64_t)iter.height * stride;  // at most 25 + 27b
  377|  3.87k|    WebPDecoderConfig* const config = &dec->config;
  378|  3.87k|    WebPRGBABuffer* const buf = &config->output.u.RGBA;
  379|  3.87k|    if ((size_t)size != size) goto Error;
  ------------------
  |  Branch (379:9): [True: 0, False: 3.87k]
  ------------------
  380|  3.87k|    buf->stride = (int)stride;
  381|  3.87k|    buf->size = (size_t)size;
  382|  3.87k|    buf->rgba = dec->curr_frame + out_offset;
  383|       |
  384|  3.87k|    if (WebPDecode(in, in_size, config) != VP8_STATUS_OK) {
  ------------------
  |  Branch (384:9): [True: 3.13k, False: 737]
  ------------------
  385|  3.13k|      goto Error;
  386|  3.13k|    }
  387|  3.87k|  }
  388|       |
  389|       |  // During the decoding of current frame, we may have set some pixels to be
  390|       |  // transparent (i.e. alpha < 255). However, the value of each of these
  391|       |  // pixels should have been determined by blending it against the value of
  392|       |  // that pixel in the previous frame if blending method of is WEBP_MUX_BLEND.
  393|    737|  if (iter.frame_num > 1 && iter.blend_method == WEBP_MUX_BLEND &&
  ------------------
  |  Branch (393:7): [True: 0, False: 737]
  |  Branch (393:29): [True: 0, False: 0]
  ------------------
  394|      0|      !is_key_frame) {
  ------------------
  |  Branch (394:7): [True: 0, False: 0]
  ------------------
  395|      0|    if (dec->prev_iter.dispose_method == WEBP_MUX_DISPOSE_NONE) {
  ------------------
  |  Branch (395:9): [True: 0, False: 0]
  ------------------
  396|      0|      int y;
  397|       |      // Blend transparent pixels with pixels in previous canvas.
  398|      0|      for (y = 0; y < iter.height; ++y) {
  ------------------
  |  Branch (398:19): [True: 0, False: 0]
  ------------------
  399|      0|        const size_t offset = (iter.y_offset + y) * width + iter.x_offset;
  400|      0|        blend_row((uint32_t*)dec->curr_frame + offset,
  401|      0|                  (uint32_t*)dec->prev_frame_disposed + offset, iter.width);
  402|      0|      }
  403|      0|    } else {
  404|      0|      int y;
  405|      0|      assert(dec->prev_iter.dispose_method == WEBP_MUX_DISPOSE_BACKGROUND);
  406|       |      // We need to blend a transparent pixel with its value just after
  407|       |      // initialization. That is, blend it with:
  408|       |      // * Fully transparent pixel if it belongs to prevRect <-- No-op.
  409|       |      // * The pixel in the previous canvas otherwise <-- Need alpha-blending.
  410|      0|      for (y = 0; y < iter.height; ++y) {
  ------------------
  |  Branch (410:19): [True: 0, False: 0]
  ------------------
  411|      0|        const int canvas_y = iter.y_offset + y;
  412|      0|        int left1, width1, left2, width2;
  413|      0|        FindBlendRangeAtRow(&iter, &dec->prev_iter, canvas_y, &left1, &width1,
  414|      0|                            &left2, &width2);
  415|      0|        if (width1 > 0) {
  ------------------
  |  Branch (415:13): [True: 0, False: 0]
  ------------------
  416|      0|          const size_t offset1 = canvas_y * width + left1;
  417|      0|          blend_row((uint32_t*)dec->curr_frame + offset1,
  418|      0|                    (uint32_t*)dec->prev_frame_disposed + offset1, width1);
  419|      0|        }
  420|      0|        if (width2 > 0) {
  ------------------
  |  Branch (420:13): [True: 0, False: 0]
  ------------------
  421|      0|          const size_t offset2 = canvas_y * width + left2;
  422|      0|          blend_row((uint32_t*)dec->curr_frame + offset2,
  423|      0|                    (uint32_t*)dec->prev_frame_disposed + offset2, width2);
  424|      0|        }
  425|      0|      }
  426|      0|    }
  427|      0|  }
  428|       |
  429|       |  // Update info of the previous frame and dispose it for the next iteration.
  430|    737|  dec->prev_frame_timestamp = timestamp;
  431|    737|  WebPDemuxReleaseIterator(&dec->prev_iter);
  432|    737|  dec->prev_iter = iter;
  433|    737|  dec->prev_frame_was_keyframe = is_key_frame;
  434|    737|  if (!CopyCanvas(dec->curr_frame, dec->prev_frame_disposed, width, height)) {
  ------------------
  |  Branch (434:7): [True: 0, False: 737]
  ------------------
  435|      0|    goto Error;
  436|      0|  }
  437|    737|  if (dec->prev_iter.dispose_method == WEBP_MUX_DISPOSE_BACKGROUND) {
  ------------------
  |  Branch (437:7): [True: 0, False: 737]
  ------------------
  438|      0|    ZeroFillFrameRect(dec->prev_frame_disposed, width * NUM_CHANNELS,
  ------------------
  |  |   29|      0|#define NUM_CHANNELS 4
  ------------------
  439|      0|                      dec->prev_iter.x_offset, dec->prev_iter.y_offset,
  440|      0|                      dec->prev_iter.width, dec->prev_iter.height);
  441|      0|  }
  442|    737|  ++dec->next_frame;
  443|       |
  444|       |  // All OK, fill in the values.
  445|    737|  *buf_ptr = dec->curr_frame;
  446|    737|  *timestamp_ptr = timestamp;
  447|    737|  return 1;
  448|       |
  449|  3.13k|Error:
  450|  3.13k|  WebPDemuxReleaseIterator(&iter);
  451|  3.13k|  return 0;
  452|    737|}
WebPAnimDecoderHasMoreFrames:
  454|  8.48k|int WebPAnimDecoderHasMoreFrames(const WebPAnimDecoder* dec) {
  455|  8.48k|  if (dec == NULL) return 0;
  ------------------
  |  Branch (455:7): [True: 0, False: 8.48k]
  ------------------
  456|  8.48k|  return (dec->next_frame <= (int)dec->info.frame_count);
  457|  8.48k|}
WebPAnimDecoderReset:
  459|  3.87k|void WebPAnimDecoderReset(WebPAnimDecoder* dec) {
  460|  3.87k|  if (dec != NULL) {
  ------------------
  |  Branch (460:7): [True: 3.87k, False: 0]
  ------------------
  461|  3.87k|    dec->prev_frame_timestamp = 0;
  462|  3.87k|    WebPDemuxReleaseIterator(&dec->prev_iter);
  463|  3.87k|    WEBP_UNSAFE_MEMSET(&dec->prev_iter, 0, sizeof(dec->prev_iter));
  ------------------
  |  |  175|  3.87k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  464|  3.87k|    dec->prev_frame_was_keyframe = 0;
  465|  3.87k|    dec->next_frame = 1;
  466|  3.87k|  }
  467|  3.87k|}
WebPAnimDecoderDelete:
  474|  3.94k|void WebPAnimDecoderDelete(WebPAnimDecoder* dec) {
  475|  3.94k|  if (dec != NULL) {
  ------------------
  |  Branch (475:7): [True: 3.90k, False: 34]
  ------------------
  476|  3.90k|    WebPDemuxReleaseIterator(&dec->prev_iter);
  477|  3.90k|    WebPDemuxDelete(dec->demux);
  478|  3.90k|    WebPSafeFree(dec->curr_frame);
  479|  3.90k|    WebPSafeFree(dec->prev_frame_disposed);
  480|  3.90k|    WebPSafeFree(dec);
  481|  3.90k|  }
  482|  3.94k|}
anim_decode.c:DefaultDecoderOptions:
   61|  3.90k|static void DefaultDecoderOptions(WebPAnimDecoderOptions* const dec_options) {
   62|  3.90k|  dec_options->color_mode = MODE_RGBA;
   63|  3.90k|  dec_options->use_threads = 0;
   64|  3.90k|}
anim_decode.c:ApplyDecoderOptions:
   78|  3.90k|    WebPAnimDecoder* const dec) {
   79|  3.90k|  WEBP_CSP_MODE mode;
   80|  3.90k|  WebPDecoderConfig* config = &dec->config;
   81|  3.90k|  assert(dec_options != NULL);
   82|       |
   83|  3.90k|  mode = dec_options->color_mode;
   84|  3.90k|  if (mode != MODE_RGBA && mode != MODE_BGRA && mode != MODE_rgbA &&
  ------------------
  |  Branch (84:7): [True: 0, False: 3.90k]
  |  Branch (84:28): [True: 0, False: 0]
  |  Branch (84:49): [True: 0, False: 0]
  ------------------
   85|      0|      mode != MODE_bgrA) {
  ------------------
  |  Branch (85:7): [True: 0, False: 0]
  ------------------
   86|      0|    return 0;
   87|      0|  }
   88|  3.90k|  dec->blend_func = (mode == MODE_RGBA || mode == MODE_BGRA)
  ------------------
  |  Branch (88:22): [True: 3.90k, False: 0]
  |  Branch (88:43): [True: 0, False: 0]
  ------------------
   89|  3.90k|                        ? &BlendPixelRowNonPremult
   90|  3.90k|                        : &BlendPixelRowPremult;
   91|  3.90k|  if (!WebPInitDecoderConfig(config)) {
  ------------------
  |  Branch (91:7): [True: 0, False: 3.90k]
  ------------------
   92|      0|    return 0;
   93|      0|  }
   94|  3.90k|  config->output.colorspace = mode;
   95|  3.90k|  config->output.is_external_memory = 1;
   96|  3.90k|  config->options.use_threads = dec_options->use_threads;
   97|       |  // Note: config->output.u.RGBA is set at the time of decoding each frame.
   98|  3.90k|  return 1;
   99|  3.90k|}
anim_decode.c:IsKeyFrame:
  205|  3.87k|                      int canvas_height) {
  206|  3.87k|  if (curr->frame_num == 1) {
  ------------------
  |  Branch (206:7): [True: 3.87k, False: 0]
  ------------------
  207|  3.87k|    return 1;
  208|  3.87k|  } else if ((!curr->has_alpha || curr->blend_method == WEBP_MUX_NO_BLEND) &&
  ------------------
  |  Branch (208:15): [True: 0, False: 0]
  |  Branch (208:35): [True: 0, False: 0]
  ------------------
  209|      0|             IsFullFrame(curr->width, curr->height, canvas_width,
  ------------------
  |  Branch (209:14): [True: 0, False: 0]
  ------------------
  210|      0|                         canvas_height)) {
  211|      0|    return 1;
  212|      0|  } else {
  213|      0|    return (prev->dispose_method == WEBP_MUX_DISPOSE_BACKGROUND) &&
  ------------------
  |  Branch (213:12): [True: 0, False: 0]
  ------------------
  214|      0|           (IsFullFrame(prev->width, prev->height, canvas_width,
  ------------------
  |  Branch (214:13): [True: 0, False: 0]
  ------------------
  215|      0|                        canvas_height) ||
  216|      0|            prev_frame_was_key_frame);
  ------------------
  |  Branch (216:13): [True: 0, False: 0]
  ------------------
  217|      0|  }
  218|  3.87k|}
anim_decode.c:ZeroFillCanvas:
  169|  3.87k|                                         uint32_t canvas_height) {
  170|  3.87k|  const uint64_t size =
  171|  3.87k|      (uint64_t)canvas_width * canvas_height * NUM_CHANNELS * sizeof(*buf);
  ------------------
  |  |   29|  3.87k|#define NUM_CHANNELS 4
  ------------------
  172|  3.87k|  if (!CheckSizeOverflow(size)) return 0;
  ------------------
  |  Branch (172:7): [True: 0, False: 3.87k]
  ------------------
  173|  3.87k|  WEBP_UNSAFE_MEMSET(buf, 0, (size_t)size);
  ------------------
  |  |  175|  3.87k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  174|  3.87k|  return 1;
  175|  3.87k|}
anim_decode.c:CopyCanvas:
  193|    737|                                     uint32_t width, uint32_t height) {
  194|    737|  const uint64_t size = (uint64_t)width * height * NUM_CHANNELS;
  ------------------
  |  |   29|    737|#define NUM_CHANNELS 4
  ------------------
  195|    737|  if (!CheckSizeOverflow(size)) return 0;
  ------------------
  |  Branch (195:7): [True: 0, False: 737]
  ------------------
  196|    737|  assert(src != NULL && dst != NULL);
  197|    737|  WEBP_UNSAFE_MEMCPY(dst, src, (size_t)size);
  ------------------
  |  |  174|    737|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
  198|    737|  return 1;
  199|    737|}

WebPDemuxInternal:
  708|  3.90k|                               WebPDemuxState* state, int version) {
  709|  3.90k|  const ChunkParser* parser;
  710|  3.90k|  int partial;
  711|  3.90k|  ParseStatus status = PARSE_ERROR;
  712|  3.90k|  MemBuffer mem;
  713|  3.90k|  WebPDemuxer* dmux;
  714|       |
  715|  3.90k|  if (state != NULL) *state = WEBP_DEMUX_PARSE_ERROR;
  ------------------
  |  Branch (715:7): [True: 0, False: 3.90k]
  ------------------
  716|       |
  717|  3.90k|  if (WEBP_ABI_IS_INCOMPATIBLE(version, WEBP_DEMUX_ABI_VERSION)) return NULL;
  ------------------
  |  |   84|  3.90k|#define WEBP_ABI_IS_INCOMPATIBLE(a, b) (((a) >> 8) != ((b) >> 8))
  |  |  ------------------
  |  |  |  Branch (84:40): [True: 0, False: 3.90k]
  |  |  ------------------
  ------------------
  718|  3.90k|  if (data == NULL || data->bytes == NULL || data->size == 0) return NULL;
  ------------------
  |  Branch (718:7): [True: 0, False: 3.90k]
  |  Branch (718:23): [True: 0, False: 3.90k]
  |  Branch (718:46): [True: 0, False: 3.90k]
  ------------------
  719|       |
  720|  3.90k|  if (!InitMemBuffer(&mem, data->bytes, data->size)) return NULL;
  ------------------
  |  Branch (720:7): [True: 0, False: 3.90k]
  ------------------
  721|  3.90k|  status = ReadHeader(&mem);
  722|  3.90k|  if (status != PARSE_OK) {
  ------------------
  |  Branch (722:7): [True: 3.90k, False: 0]
  ------------------
  723|       |    // If parsing of the webp file header fails attempt to handle a raw
  724|       |    // VP8/VP8L frame. Note 'allow_partial' is ignored in this case.
  725|  3.90k|    if (status == PARSE_ERROR) {
  ------------------
  |  Branch (725:9): [True: 3.87k, False: 34]
  ------------------
  726|  3.87k|      status = CreateRawImageDemuxer(&mem, &dmux);
  727|  3.87k|      if (status == PARSE_OK) {
  ------------------
  |  Branch (727:11): [True: 3.87k, False: 0]
  ------------------
  728|  3.87k|        if (state != NULL) *state = WEBP_DEMUX_DONE;
  ------------------
  |  Branch (728:13): [True: 0, False: 3.87k]
  ------------------
  729|  3.87k|        return dmux;
  730|  3.87k|      }
  731|  3.87k|    }
  732|     34|    if (state != NULL) {
  ------------------
  |  Branch (732:9): [True: 0, False: 34]
  ------------------
  733|      0|      *state = (status == PARSE_NEED_MORE_DATA) ? WEBP_DEMUX_PARSING_HEADER
  ------------------
  |  Branch (733:16): [True: 0, False: 0]
  ------------------
  734|      0|                                                : WEBP_DEMUX_PARSE_ERROR;
  735|      0|    }
  736|     34|    return NULL;
  737|  3.90k|  }
  738|       |
  739|      0|  partial = (mem.buf_size < mem.riff_end);
  740|      0|  if (!allow_partial && partial) return NULL;
  ------------------
  |  Branch (740:7): [True: 0, False: 0]
  |  Branch (740:25): [True: 0, False: 0]
  ------------------
  741|       |
  742|      0|  dmux = (WebPDemuxer*)WebPSafeCalloc(1ULL, sizeof(*dmux));
  743|      0|  if (dmux == NULL) return NULL;
  ------------------
  |  Branch (743:7): [True: 0, False: 0]
  ------------------
  744|      0|  InitDemux(dmux, &mem);
  745|       |
  746|      0|  status = PARSE_ERROR;
  747|      0|  for (parser = kMasterChunks; parser->parse != NULL; ++parser) {
  ------------------
  |  Branch (747:32): [True: 0, False: 0]
  ------------------
  748|      0|    if (!memcmp(parser->id, GetBuffer(&dmux->mem), TAG_SIZE)) {
  ------------------
  |  |   73|      0|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  |  Branch (748:9): [True: 0, False: 0]
  ------------------
  749|      0|      status = parser->parse(dmux);
  750|      0|      if (status == PARSE_OK) dmux->state = WEBP_DEMUX_DONE;
  ------------------
  |  Branch (750:11): [True: 0, False: 0]
  ------------------
  751|      0|      if (status == PARSE_NEED_MORE_DATA && !partial) status = PARSE_ERROR;
  ------------------
  |  Branch (751:11): [True: 0, False: 0]
  |  Branch (751:45): [True: 0, False: 0]
  ------------------
  752|      0|      if (status != PARSE_ERROR && !parser->valid(dmux)) status = PARSE_ERROR;
  ------------------
  |  Branch (752:11): [True: 0, False: 0]
  |  Branch (752:36): [True: 0, False: 0]
  ------------------
  753|      0|      if (status == PARSE_ERROR) dmux->state = WEBP_DEMUX_PARSE_ERROR;
  ------------------
  |  Branch (753:11): [True: 0, False: 0]
  ------------------
  754|      0|      break;
  755|      0|    }
  756|      0|  }
  757|      0|  if (state != NULL) *state = dmux->state;
  ------------------
  |  Branch (757:7): [True: 0, False: 0]
  ------------------
  758|       |
  759|      0|  if (status == PARSE_ERROR) {
  ------------------
  |  Branch (759:7): [True: 0, False: 0]
  ------------------
  760|      0|    WebPDemuxDelete(dmux);
  761|      0|    return NULL;
  762|      0|  }
  763|      0|  return dmux;
  764|      0|}
WebPDemuxDelete:
  766|  3.90k|void WebPDemuxDelete(WebPDemuxer* dmux) {
  767|  3.90k|  Chunk* c;
  768|  3.90k|  Frame* f;
  769|  3.90k|  if (dmux == NULL) return;
  ------------------
  |  Branch (769:7): [True: 34, False: 3.87k]
  ------------------
  770|       |
  771|  7.74k|  for (f = dmux->frames; f != NULL;) {
  ------------------
  |  Branch (771:26): [True: 3.87k, False: 3.87k]
  ------------------
  772|  3.87k|    Frame* const cur_frame = f;
  773|  3.87k|    f = f->next;
  774|  3.87k|    WebPSafeFree(cur_frame);
  775|  3.87k|  }
  776|  3.87k|  for (c = dmux->chunks; c != NULL;) {
  ------------------
  |  Branch (776:26): [True: 0, False: 3.87k]
  ------------------
  777|      0|    Chunk* const cur_chunk = c;
  778|      0|    c = c->next;
  779|      0|    WebPSafeFree(cur_chunk);
  780|      0|  }
  781|  3.87k|  WebPSafeFree(dmux);
  782|  3.87k|}
WebPDemuxGetI:
  786|  19.3k|uint32_t WebPDemuxGetI(const WebPDemuxer* dmux, WebPFormatFeature feature) {
  787|  19.3k|  if (dmux == NULL) return 0;
  ------------------
  |  Branch (787:7): [True: 0, False: 19.3k]
  ------------------
  788|       |
  789|  19.3k|  switch (feature) {
  ------------------
  |  Branch (789:11): [True: 19.3k, False: 0]
  ------------------
  790|      0|    case WEBP_FF_FORMAT_FLAGS:
  ------------------
  |  Branch (790:5): [True: 0, False: 19.3k]
  ------------------
  791|      0|      return dmux->feature_flags;
  792|  3.87k|    case WEBP_FF_CANVAS_WIDTH:
  ------------------
  |  Branch (792:5): [True: 3.87k, False: 15.4k]
  ------------------
  793|  3.87k|      return (uint32_t)dmux->canvas_width;
  794|  3.87k|    case WEBP_FF_CANVAS_HEIGHT:
  ------------------
  |  Branch (794:5): [True: 3.87k, False: 15.4k]
  ------------------
  795|  3.87k|      return (uint32_t)dmux->canvas_height;
  796|  3.87k|    case WEBP_FF_LOOP_COUNT:
  ------------------
  |  Branch (796:5): [True: 3.87k, False: 15.4k]
  ------------------
  797|  3.87k|      return (uint32_t)dmux->loop_count;
  798|  3.87k|    case WEBP_FF_BACKGROUND_COLOR:
  ------------------
  |  Branch (798:5): [True: 3.87k, False: 15.4k]
  ------------------
  799|  3.87k|      return dmux->bgcolor;
  800|  3.87k|    case WEBP_FF_FRAME_COUNT:
  ------------------
  |  Branch (800:5): [True: 3.87k, False: 15.4k]
  ------------------
  801|  3.87k|      return (uint32_t)dmux->num_frames;
  802|  19.3k|  }
  803|      0|  return 0;
  804|  19.3k|}
WebPDemuxGetFrame:
  879|  3.87k|int WebPDemuxGetFrame(const WebPDemuxer* dmux, int frame, WebPIterator* iter) {
  880|  3.87k|  if (iter == NULL) return 0;
  ------------------
  |  Branch (880:7): [True: 0, False: 3.87k]
  ------------------
  881|       |
  882|  3.87k|  WEBP_UNSAFE_MEMSET(iter, 0, sizeof(*iter));
  ------------------
  |  |  175|  3.87k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  883|  3.87k|  iter->private_ = (void*)dmux;
  884|  3.87k|  return SetFrame(frame, iter);
  885|  3.87k|}
WebPDemuxReleaseIterator:
  898|  11.6k|void WebPDemuxReleaseIterator(WebPIterator* iter) { (void)iter; }
demux.c:InitMemBuffer:
  120|  3.90k|                         size_t size) {
  121|  3.90k|  WEBP_UNSAFE_MEMSET(mem, 0, sizeof(*mem));
  ------------------
  |  |  175|  3.90k|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  122|  3.90k|  return RemapMemBuffer(mem, data, size);
  123|  3.90k|}
demux.c:RemapMemBuffer:
  111|  3.90k|                          size_t size) {
  112|  3.90k|  if (size < mem->buf_size) return 0;  // can't remap to a shorter buffer!
  ------------------
  |  Branch (112:7): [True: 0, False: 3.90k]
  ------------------
  113|       |
  114|  3.90k|  mem->buf = data;
  115|  3.90k|  mem->end = mem->buf_size = size;
  116|  3.90k|  return 1;
  117|  3.90k|}
demux.c:ReadHeader:
  378|  3.90k|static ParseStatus ReadHeader(MemBuffer* const mem) {
  379|  3.90k|  const size_t min_size = RIFF_HEADER_SIZE + CHUNK_HEADER_SIZE;
  ------------------
  |  |   76|  3.90k|#define RIFF_HEADER_SIZE 12  // Size of the RIFF header ("RIFFnnnnWEBP").
  ------------------
                const size_t min_size = RIFF_HEADER_SIZE + CHUNK_HEADER_SIZE;
  ------------------
  |  |   75|  3.90k|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  380|  3.90k|  uint32_t riff_size;
  381|       |
  382|       |  // Basic file level validation.
  383|  3.90k|  if (MemDataSize(mem) < min_size) return PARSE_NEED_MORE_DATA;
  ------------------
  |  Branch (383:7): [True: 34, False: 3.87k]
  ------------------
  384|  3.87k|  if (memcmp(GetBuffer(mem), "RIFF", CHUNK_SIZE_BYTES) ||
  ------------------
  |  |   74|  3.87k|#define CHUNK_SIZE_BYTES 4   // Size needed to store chunk's size.
  ------------------
  |  Branch (384:7): [True: 3.87k, False: 0]
  ------------------
  385|  3.87k|      memcmp(GetBuffer(mem) + CHUNK_HEADER_SIZE, "WEBP", CHUNK_SIZE_BYTES)) {
  ------------------
  |  |   75|      0|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
                    memcmp(GetBuffer(mem) + CHUNK_HEADER_SIZE, "WEBP", CHUNK_SIZE_BYTES)) {
  ------------------
  |  |   74|      0|#define CHUNK_SIZE_BYTES 4   // Size needed to store chunk's size.
  ------------------
  |  Branch (385:7): [True: 0, False: 0]
  ------------------
  386|  3.87k|    return PARSE_ERROR;
  387|  3.87k|  }
  388|       |
  389|      0|  riff_size = GetLE32(GetBuffer(mem) + TAG_SIZE);
  ------------------
  |  |   73|      0|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  390|      0|  if (riff_size < CHUNK_HEADER_SIZE) return PARSE_ERROR;
  ------------------
  |  |   75|      0|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  |  Branch (390:7): [True: 0, False: 0]
  ------------------
  391|      0|  if (riff_size > MAX_CHUNK_PAYLOAD) return PARSE_ERROR;
  ------------------
  |  |   89|      0|#define MAX_CHUNK_PAYLOAD (~0U - CHUNK_HEADER_SIZE - 1)
  |  |  ------------------
  |  |  |  |   75|      0|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  |  |  ------------------
  ------------------
  |  Branch (391:7): [True: 0, False: 0]
  ------------------
  392|       |
  393|       |  // There's no point in reading past the end of the RIFF chunk
  394|      0|  mem->riff_end = riff_size + CHUNK_HEADER_SIZE;
  ------------------
  |  |   75|      0|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  395|      0|  if (mem->buf_size > mem->riff_end) {
  ------------------
  |  Branch (395:7): [True: 0, False: 0]
  ------------------
  396|      0|    mem->buf_size = mem->end = mem->riff_end;
  397|      0|  }
  398|       |
  399|      0|  Skip(mem, RIFF_HEADER_SIZE);
  ------------------
  |  |   76|      0|#define RIFF_HEADER_SIZE 12  // Size of the RIFF header ("RIFFnnnnWEBP").
  ------------------
  400|      0|  return PARSE_OK;
  401|      0|}
demux.c:MemDataSize:
  126|  3.90k|static WEBP_INLINE size_t MemDataSize(const MemBuffer* const mem) {
  127|  3.90k|  return (mem->end - mem->start);
  128|  3.90k|}
demux.c:CreateRawImageDemuxer:
  673|  3.87k|                                         WebPDemuxer** demuxer) {
  674|  3.87k|  WebPBitstreamFeatures features;
  675|  3.87k|  const VP8StatusCode status =
  676|  3.87k|      WebPGetFeatures(mem->buf, mem->buf_size, &features);
  677|  3.87k|  *demuxer = NULL;
  678|  3.87k|  if (status != VP8_STATUS_OK) {
  ------------------
  |  Branch (678:7): [True: 0, False: 3.87k]
  ------------------
  679|      0|    return (status == VP8_STATUS_NOT_ENOUGH_DATA) ? PARSE_NEED_MORE_DATA
  ------------------
  |  Branch (679:12): [True: 0, False: 0]
  ------------------
  680|      0|                                                  : PARSE_ERROR;
  681|      0|  }
  682|       |
  683|  3.87k|  {
  684|  3.87k|    WebPDemuxer* const dmux = (WebPDemuxer*)WebPSafeCalloc(1ULL, sizeof(*dmux));
  685|  3.87k|    Frame* const frame = (Frame*)WebPSafeCalloc(1ULL, sizeof(*frame));
  686|  3.87k|    if (dmux == NULL || frame == NULL) goto Error;
  ------------------
  |  Branch (686:9): [True: 0, False: 3.87k]
  |  Branch (686:25): [True: 0, False: 3.87k]
  ------------------
  687|  3.87k|    InitDemux(dmux, mem);
  688|  3.87k|    SetFrameInfo(0, mem->buf_size, 1 /*frame_num*/, 1 /*complete*/, &features,
  689|  3.87k|                 frame);
  690|  3.87k|    if (!AddFrame(dmux, frame)) goto Error;
  ------------------
  |  Branch (690:9): [True: 0, False: 3.87k]
  ------------------
  691|  3.87k|    dmux->state = WEBP_DEMUX_DONE;
  692|  3.87k|    dmux->canvas_width = frame->width;
  693|  3.87k|    dmux->canvas_height = frame->height;
  694|  3.87k|    dmux->feature_flags |= frame->has_alpha ? ALPHA_FLAG : 0;
  ------------------
  |  Branch (694:28): [True: 573, False: 3.30k]
  ------------------
  695|  3.87k|    dmux->num_frames = 1;
  696|  3.87k|    assert(IsValidSimpleFormat(dmux));
  697|  3.87k|    *demuxer = dmux;
  698|  3.87k|    return PARSE_OK;
  699|       |
  700|      0|  Error:
  701|      0|    WebPSafeFree(dmux);
  702|      0|    WebPSafeFree(frame);
  703|      0|    return PARSE_ERROR;
  704|  3.87k|  }
  705|  3.87k|}
demux.c:SetFrameInfo:
  199|  3.87k|                         Frame* const frame) {
  200|  3.87k|  frame->img_components[0].offset = start_offset;
  201|  3.87k|  frame->img_components[0].size = size;
  202|  3.87k|  frame->width = features->width;
  203|  3.87k|  frame->height = features->height;
  204|  3.87k|  frame->has_alpha |= features->has_alpha;
  205|  3.87k|  frame->frame_num = frame_num;
  206|  3.87k|  frame->complete = complete;
  207|  3.87k|}
demux.c:AddFrame:
  186|  3.87k|static int AddFrame(WebPDemuxer* const dmux, Frame* const frame) {
  187|  3.87k|  const Frame* const last_frame = *dmux->frames_tail;
  188|  3.87k|  if (last_frame != NULL && !last_frame->complete) return 0;
  ------------------
  |  Branch (188:7): [True: 0, False: 3.87k]
  |  Branch (188:29): [True: 0, False: 0]
  ------------------
  189|       |
  190|  3.87k|  *dmux->frames_tail = frame;
  191|       |  frame->next = NULL;
  192|  3.87k|  dmux->frames_tail = &frame->next;
  193|  3.87k|  return 1;
  194|  3.87k|}
demux.c:InitDemux:
  661|  3.87k|static void InitDemux(WebPDemuxer* const dmux, const MemBuffer* const mem) {
  662|  3.87k|  dmux->state = WEBP_DEMUX_PARSING_HEADER;
  663|  3.87k|  dmux->loop_count = 1;
  664|  3.87k|  dmux->bgcolor = 0xFFFFFFFF;  // White background by default.
  665|  3.87k|  dmux->canvas_width = -1;
  666|  3.87k|  dmux->canvas_height = -1;
  667|  3.87k|  dmux->frames_tail = &dmux->frames;
  668|  3.87k|  dmux->chunks_tail = &dmux->chunks;
  669|  3.87k|  dmux->mem = *mem;
  670|  3.87k|}
demux.c:GetBuffer:
  143|  3.87k|static WEBP_INLINE const uint8_t* GetBuffer(MemBuffer* const mem) {
  144|  3.87k|  return mem->buf + mem->start;
  145|  3.87k|}
demux.c:SetFrame:
  866|  3.87k|static int SetFrame(int frame_num, WebPIterator* const iter) {
  867|  3.87k|  const Frame* frame;
  868|  3.87k|  const WebPDemuxer* const dmux = (WebPDemuxer*)iter->private_;
  869|  3.87k|  if (dmux == NULL || frame_num < 0) return 0;
  ------------------
  |  Branch (869:7): [True: 0, False: 3.87k]
  |  Branch (869:23): [True: 0, False: 3.87k]
  ------------------
  870|  3.87k|  if (frame_num > dmux->num_frames) return 0;
  ------------------
  |  Branch (870:7): [True: 0, False: 3.87k]
  ------------------
  871|  3.87k|  if (frame_num == 0) frame_num = dmux->num_frames;
  ------------------
  |  Branch (871:7): [True: 0, False: 3.87k]
  ------------------
  872|       |
  873|  3.87k|  frame = GetFrame(dmux, frame_num);
  874|  3.87k|  if (frame == NULL) return 0;
  ------------------
  |  Branch (874:7): [True: 0, False: 3.87k]
  ------------------
  875|       |
  876|  3.87k|  return SynthesizeFrame(dmux, frame, iter);
  877|  3.87k|}
demux.c:GetFrame:
  809|  3.87k|static const Frame* GetFrame(const WebPDemuxer* const dmux, int frame_num) {
  810|  3.87k|  const Frame* f;
  811|  3.87k|  for (f = dmux->frames; f != NULL; f = f->next) {
  ------------------
  |  Branch (811:26): [True: 3.87k, False: 0]
  ------------------
  812|  3.87k|    if (frame_num == f->frame_num) break;
  ------------------
  |  Branch (812:9): [True: 3.87k, False: 0]
  ------------------
  813|  3.87k|  }
  814|  3.87k|  return f;
  815|  3.87k|}
demux.c:SynthesizeFrame:
  843|  3.87k|                           const Frame* const frame, WebPIterator* const iter) {
  844|  3.87k|  const uint8_t* const mem_buf = dmux->mem.buf;
  845|  3.87k|  size_t payload_size = 0;
  846|  3.87k|  const uint8_t* const payload = GetFramePayload(mem_buf, frame, &payload_size);
  847|  3.87k|  if (payload == NULL) return 0;
  ------------------
  |  Branch (847:7): [True: 0, False: 3.87k]
  ------------------
  848|  3.87k|  assert(frame != NULL);
  849|       |
  850|  3.87k|  iter->frame_num = frame->frame_num;
  851|  3.87k|  iter->num_frames = dmux->num_frames;
  852|  3.87k|  iter->x_offset = frame->x_offset;
  853|  3.87k|  iter->y_offset = frame->y_offset;
  854|  3.87k|  iter->width = frame->width;
  855|  3.87k|  iter->height = frame->height;
  856|  3.87k|  iter->has_alpha = frame->has_alpha;
  857|  3.87k|  iter->duration = frame->duration;
  858|  3.87k|  iter->dispose_method = frame->dispose_method;
  859|  3.87k|  iter->blend_method = frame->blend_method;
  860|  3.87k|  iter->complete = frame->complete;
  861|  3.87k|  iter->fragment.bytes = payload;
  862|  3.87k|  iter->fragment.size = payload_size;
  863|  3.87k|  return 1;
  864|  3.87k|}
demux.c:GetFramePayload:
  819|  3.87k|                                      size_t* const data_size) {
  820|  3.87k|  *data_size = 0;
  821|  3.87k|  if (frame != NULL) {
  ------------------
  |  Branch (821:7): [True: 3.87k, False: 0]
  ------------------
  822|  3.87k|    const ChunkData* const image = frame->img_components;
  823|  3.87k|    const ChunkData* const alpha = frame->img_components + 1;
  824|  3.87k|    size_t start_offset = image->offset;
  825|  3.87k|    *data_size = image->size;
  826|       |
  827|       |    // if alpha exists it precedes image, update the size allowing for
  828|       |    // intervening chunks.
  829|  3.87k|    if (alpha->size > 0) {
  ------------------
  |  Branch (829:9): [True: 0, False: 3.87k]
  ------------------
  830|      0|      const size_t inter_size =
  831|      0|          (image->offset > 0) ? image->offset - (alpha->offset + alpha->size)
  ------------------
  |  Branch (831:11): [True: 0, False: 0]
  ------------------
  832|      0|                              : 0;
  833|      0|      start_offset = alpha->offset;
  834|      0|      *data_size += alpha->size + inter_size;
  835|      0|    }
  836|  3.87k|    return mem_buf + start_offset;
  837|  3.87k|  }
  838|      0|  return NULL;
  839|  3.87k|}

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

cpu.c:x86CPUInfo:
  118|     13|static int x86CPUInfo(CPUFeature feature) {
  119|     13|  int max_cpuid_value;
  120|     13|  int cpu_info[4];
  121|     13|  int is_intel = 0;
  122|       |
  123|       |  // get the highest feature value cpuid supports
  124|     13|  GetCPUInfo(cpu_info, 0);
  125|     13|  max_cpuid_value = cpu_info[0];
  126|     13|  if (max_cpuid_value < 1) {
  ------------------
  |  Branch (126:7): [True: 0, False: 13]
  ------------------
  127|      0|    return 0;
  128|     13|  } else {
  129|     13|    const int VENDOR_ID_INTEL_EBX = 0x756e6547;  // uneG
  130|     13|    const int VENDOR_ID_INTEL_EDX = 0x49656e69;  // Ieni
  131|     13|    const int VENDOR_ID_INTEL_ECX = 0x6c65746e;  // letn
  132|     13|    is_intel = (cpu_info[1] == VENDOR_ID_INTEL_EBX &&
  ------------------
  |  Branch (132:17): [True: 13, False: 0]
  ------------------
  133|     13|                cpu_info[2] == VENDOR_ID_INTEL_ECX &&
  ------------------
  |  Branch (133:17): [True: 13, False: 0]
  ------------------
  134|     13|                cpu_info[3] == VENDOR_ID_INTEL_EDX);  // genuine Intel?
  ------------------
  |  Branch (134:17): [True: 13, False: 0]
  ------------------
  135|     13|  }
  136|       |
  137|     13|  GetCPUInfo(cpu_info, 1);
  138|     13|  if (feature == kSSE2) {
  ------------------
  |  Branch (138:7): [True: 5, False: 8]
  ------------------
  139|      5|    return !!(cpu_info[3] & (1 << 26));
  140|      5|  }
  141|      8|  if (feature == kSSE3) {
  ------------------
  |  Branch (141:7): [True: 0, False: 8]
  ------------------
  142|      0|    return !!(cpu_info[2] & (1 << 0));
  143|      0|  }
  144|      8|  if (feature == kSlowSSSE3) {
  ------------------
  |  Branch (144:7): [True: 1, False: 7]
  ------------------
  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|      7|  if (feature == kSSE4_1) {
  ------------------
  |  Branch (151:7): [True: 5, False: 2]
  ------------------
  152|      5|    return !!(cpu_info[2] & (1 << 19));
  153|      5|  }
  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|     27|static WEBP_INLINE void GetCPUInfo(int cpu_info[4], int info_type) {
   46|     27|  __asm__ volatile("cpuid\n"
   47|     27|                   : "=a"(cpu_info[0]), "=b"(cpu_info[1]), "=c"(cpu_info[2]),
   48|     27|                     "=d"(cpu_info[3])
   49|     27|                   : "a"(info_type), "c"(0));
   50|     27|}
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.13k|  WEBP_TSAN_IGNORE_FUNCTION void name(void) { WEBP_DSP_INIT(name##_body); } \
  ------------------
  |  |  234|  2.13k|  do {                                                     \
  |  |  235|  2.13k|    if (pthread_mutex_lock(&func##_lock)) break;           \
  |  |  ------------------
  |  |  |  Branch (235:9): [True: 0, False: 2.13k]
  |  |  ------------------
  |  |  236|  2.13k|    if (func##_last_cpuinfo_used != VP8GetCPUInfo) func(); \
  |  |  ------------------
  |  |  |  Branch (236:9): [True: 1, False: 2.13k]
  |  |  ------------------
  |  |  237|  2.13k|    func##_last_cpuinfo_used = VP8GetCPUInfo;              \
  |  |  238|  2.13k|    (void)pthread_mutex_unlock(&func##_lock);              \
  |  |  239|  2.13k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (239:12): [Folded, False: 2.13k]
  |  |  ------------------
  ------------------
WebPInitAlphaProcessing:
  266|  2.03k|  WEBP_TSAN_IGNORE_FUNCTION void name(void) { WEBP_DSP_INIT(name##_body); } \
  ------------------
  |  |  234|  2.03k|  do {                                                     \
  |  |  235|  2.03k|    if (pthread_mutex_lock(&func##_lock)) break;           \
  |  |  ------------------
  |  |  |  Branch (235:9): [True: 0, False: 2.03k]
  |  |  ------------------
  |  |  236|  2.03k|    if (func##_last_cpuinfo_used != VP8GetCPUInfo) func(); \
  |  |  ------------------
  |  |  |  Branch (236:9): [True: 1, False: 2.03k]
  |  |  ------------------
  |  |  237|  2.03k|    func##_last_cpuinfo_used = VP8GetCPUInfo;              \
  |  |  238|  2.03k|    (void)pthread_mutex_unlock(&func##_lock);              \
  |  |  239|  2.03k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (239:12): [Folded, False: 2.03k]
  |  |  ------------------
  ------------------
VP8DspInit:
  266|  2.03k|  WEBP_TSAN_IGNORE_FUNCTION void name(void) { WEBP_DSP_INIT(name##_body); } \
  ------------------
  |  |  234|  2.03k|  do {                                                     \
  |  |  235|  2.03k|    if (pthread_mutex_lock(&func##_lock)) break;           \
  |  |  ------------------
  |  |  |  Branch (235:9): [True: 0, False: 2.03k]
  |  |  ------------------
  |  |  236|  2.03k|    if (func##_last_cpuinfo_used != VP8GetCPUInfo) func(); \
  |  |  ------------------
  |  |  |  Branch (236:9): [True: 1, False: 2.03k]
  |  |  ------------------
  |  |  237|  2.03k|    func##_last_cpuinfo_used = VP8GetCPUInfo;              \
  |  |  238|  2.03k|    (void)pthread_mutex_unlock(&func##_lock);              \
  |  |  239|  2.03k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (239:12): [Folded, False: 2.03k]
  |  |  ------------------
  ------------------
VP8LDspInit:
  266|  1.72k|  WEBP_TSAN_IGNORE_FUNCTION void name(void) { WEBP_DSP_INIT(name##_body); } \
  ------------------
  |  |  234|  1.72k|  do {                                                     \
  |  |  235|  1.72k|    if (pthread_mutex_lock(&func##_lock)) break;           \
  |  |  ------------------
  |  |  |  Branch (235:9): [True: 0, False: 1.72k]
  |  |  ------------------
  |  |  236|  1.72k|    if (func##_last_cpuinfo_used != VP8GetCPUInfo) func(); \
  |  |  ------------------
  |  |  |  Branch (236:9): [True: 1, False: 1.71k]
  |  |  ------------------
  |  |  237|  1.72k|    func##_last_cpuinfo_used = VP8GetCPUInfo;              \
  |  |  238|  1.72k|    (void)pthread_mutex_unlock(&func##_lock);              \
  |  |  239|  1.72k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (239:12): [Folded, False: 1.72k]
  |  |  ------------------
  ------------------
WebPInitUpsamplers:
  266|  2.03k|  WEBP_TSAN_IGNORE_FUNCTION void name(void) { WEBP_DSP_INIT(name##_body); } \
  ------------------
  |  |  234|  2.03k|  do {                                                     \
  |  |  235|  2.03k|    if (pthread_mutex_lock(&func##_lock)) break;           \
  |  |  ------------------
  |  |  |  Branch (235:9): [True: 0, False: 2.03k]
  |  |  ------------------
  |  |  236|  2.03k|    if (func##_last_cpuinfo_used != VP8GetCPUInfo) func(); \
  |  |  ------------------
  |  |  |  Branch (236:9): [True: 1, False: 2.03k]
  |  |  ------------------
  |  |  237|  2.03k|    func##_last_cpuinfo_used = VP8GetCPUInfo;              \
  |  |  238|  2.03k|    (void)pthread_mutex_unlock(&func##_lock);              \
  |  |  239|  2.03k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (239:12): [Folded, False: 2.03k]
  |  |  ------------------
  ------------------
WebPInitSamplers:
  266|  2.03k|  WEBP_TSAN_IGNORE_FUNCTION void name(void) { WEBP_DSP_INIT(name##_body); } \
  ------------------
  |  |  234|  2.03k|  do {                                                     \
  |  |  235|  2.03k|    if (pthread_mutex_lock(&func##_lock)) break;           \
  |  |  ------------------
  |  |  |  Branch (235:9): [True: 0, False: 2.03k]
  |  |  ------------------
  |  |  236|  2.03k|    if (func##_last_cpuinfo_used != VP8GetCPUInfo) func(); \
  |  |  ------------------
  |  |  |  Branch (236:9): [True: 1, False: 2.03k]
  |  |  ------------------
  |  |  237|  2.03k|    func##_last_cpuinfo_used = VP8GetCPUInfo;              \
  |  |  238|  2.03k|    (void)pthread_mutex_unlock(&func##_lock);              \
  |  |  239|  2.03k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (239:12): [Folded, False: 2.03k]
  |  |  ------------------
  ------------------

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

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

VP8LPredictor2_C:
  126|   181k|                          const uint32_t* const top) {
  127|   181k|  (void)left;
  128|   181k|  return top[0];
  129|   181k|}
VP8LPredictor3_C:
  131|  8.57k|                          const uint32_t* const top) {
  132|  8.57k|  (void)left;
  133|  8.57k|  return top[1];
  134|  8.57k|}
VP8LPredictor4_C:
  136|  8.47k|                          const uint32_t* const top) {
  137|  8.47k|  (void)left;
  138|  8.47k|  return top[-1];
  139|  8.47k|}
VP8LPredictor8_C:
  156|  11.3k|                          const uint32_t* const top) {
  157|  11.3k|  const uint32_t pred = Average2(top[-1], top[0]);
  158|  11.3k|  (void)left;
  159|  11.3k|  return pred;
  160|  11.3k|}
VP8LPredictor9_C:
  162|  14.2k|                          const uint32_t* const top) {
  163|  14.2k|  const uint32_t pred = Average2(top[0], top[1]);
  164|  14.2k|  (void)left;
  165|  14.2k|  return pred;
  166|  14.2k|}
VP8LPredictor10_C:
  168|  15.0k|                           const uint32_t* const top) {
  169|  15.0k|  const uint32_t pred = Average4(*left, top[-1], top[0], top[1]);
  170|  15.0k|  return pred;
  171|  15.0k|}
VP8LPredictor11_C:
  173|  14.5k|                           const uint32_t* const top) {
  174|  14.5k|  const uint32_t pred = Select(top[0], *left, top[-1]);
  175|  14.5k|  return pred;
  176|  14.5k|}
VP8LPredictor12_C:
  178|  25.2k|                           const uint32_t* const top) {
  179|  25.2k|  const uint32_t pred = ClampedAddSubtractFull(*left, top[0], top[-1]);
  180|  25.2k|  return pred;
  181|  25.2k|}
VP8LAddGreenToBlueAndRed_C:
  266|    105|                                uint32_t* dst) {
  267|    105|  int i;
  268|    320|  for (i = 0; i < num_pixels; ++i) {
  ------------------
  |  Branch (268:15): [True: 215, False: 105]
  ------------------
  269|    215|    const uint32_t argb = src[i];
  270|    215|    const uint32_t green = ((argb >> 8) & 0xff);
  271|    215|    uint32_t red_blue = (argb & 0x00ff00ffu);
  272|    215|    red_blue += (green << 16) | green;
  273|    215|    red_blue &= 0x00ff00ffu;
  274|    215|    dst[i] = (argb & 0xff00ff00u) | red_blue;
  275|    215|  }
  276|    105|}
VP8LTransformColorInverse_C:
  291|  40.0k|                                 uint32_t* dst) {
  292|  40.0k|  int i;
  293|   122k|  for (i = 0; i < num_pixels; ++i) {
  ------------------
  |  Branch (293:15): [True: 82.9k, False: 40.0k]
  ------------------
  294|  82.9k|    const uint32_t argb = src[i];
  295|  82.9k|    const int8_t green = (int8_t)(argb >> 8);
  296|  82.9k|    const uint32_t red = argb >> 16;
  297|  82.9k|    int new_red = red & 0xff;
  298|  82.9k|    int new_blue = argb & 0xff;
  299|  82.9k|    new_red += ColorTransformDelta((int8_t)m->green_to_red, green);
  300|  82.9k|    new_red &= 0xff;
  301|  82.9k|    new_blue += ColorTransformDelta((int8_t)m->green_to_blue, green);
  302|  82.9k|    new_blue += ColorTransformDelta((int8_t)m->red_to_blue, (int8_t)new_red);
  303|  82.9k|    new_blue &= 0xff;
  304|  82.9k|    dst[i] = (argb & 0xff00ff00u) | (new_red << 16) | (new_blue);
  305|  82.9k|  }
  306|  40.0k|}
VP8LInverseTransform:
  426|  38.6k|                          uint32_t* const out) {
  427|  38.6k|  const int width = transform->xsize;
  428|  38.6k|  assert(row_start < row_end);
  429|  38.6k|  assert(row_end <= transform->ysize);
  430|  38.6k|  switch (transform->type) {
  ------------------
  |  Branch (430:11): [True: 38.6k, False: 0]
  ------------------
  431|  8.74k|    case SUBTRACT_GREEN_TRANSFORM:
  ------------------
  |  Branch (431:5): [True: 8.74k, False: 29.8k]
  ------------------
  432|  8.74k|      VP8LAddGreenToBlueAndRed(in, (row_end - row_start) * width, out);
  433|  8.74k|      break;
  434|  11.1k|    case PREDICTOR_TRANSFORM:
  ------------------
  |  Branch (434:5): [True: 11.1k, False: 27.4k]
  ------------------
  435|  11.1k|      PredictorInverseTransform_C(transform, row_start, row_end, in, out);
  436|  11.1k|      if (row_end != transform->ysize) {
  ------------------
  |  Branch (436:11): [True: 10.7k, False: 450]
  ------------------
  437|       |        // The last predicted row in this iteration will be the top-pred row
  438|       |        // for the first row in next iteration.
  439|  10.7k|        memcpy(out - width, out + (row_end - row_start - 1) * width,
  440|  10.7k|               width * sizeof(*out));
  441|  10.7k|      }
  442|  11.1k|      break;
  443|  4.87k|    case CROSS_COLOR_TRANSFORM:
  ------------------
  |  Branch (443:5): [True: 4.87k, False: 33.7k]
  ------------------
  444|  4.87k|      ColorSpaceInverseTransform_C(transform, row_start, row_end, in, out);
  445|  4.87k|      break;
  446|  13.8k|    case COLOR_INDEXING_TRANSFORM:
  ------------------
  |  Branch (446:5): [True: 13.8k, False: 24.7k]
  ------------------
  447|  13.8k|      if (in == out && transform->bits > 0) {
  ------------------
  |  Branch (447:11): [True: 6.84k, False: 6.99k]
  |  Branch (447:24): [True: 4.44k, False: 2.39k]
  ------------------
  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|  4.44k|        const int out_stride = (row_end - row_start) * width;
  454|  4.44k|        const int in_stride =
  455|  4.44k|            (row_end - row_start) *
  456|  4.44k|            VP8LSubSampleSize(transform->xsize, transform->bits);
  457|  4.44k|        uint32_t* const src = out + out_stride - in_stride;
  458|  4.44k|        memmove(src, out, in_stride * sizeof(*src));
  459|  4.44k|        ColorIndexInverseTransform_C(transform, row_start, row_end, src, out);
  460|  9.39k|      } else {
  461|  9.39k|        ColorIndexInverseTransform_C(transform, row_start, row_end, in, out);
  462|  9.39k|      }
  463|  13.8k|      break;
  464|  38.6k|  }
  465|  38.6k|}
VP8LConvertBGRAToRGBA_C:
  490|   436k|                             uint8_t* WEBP_RESTRICT dst) {
  491|   436k|  const uint32_t* const src_end = src + num_pixels;
  492|  2.08M|  while (src < src_end) {
  ------------------
  |  Branch (492:10): [True: 1.64M, False: 436k]
  ------------------
  493|  1.64M|    const uint32_t argb = *src++;
  494|  1.64M|    *dst++ = (argb >> 16) & 0xff;
  495|  1.64M|    *dst++ = (argb >> 8) & 0xff;
  496|  1.64M|    *dst++ = (argb >> 0) & 0xff;
  497|  1.64M|    *dst++ = (argb >> 24) & 0xff;
  498|  1.64M|  }
  499|   436k|}
VP8LConvertFromBGRA:
  561|   478k|                         WEBP_CSP_MODE out_colorspace, uint8_t* const rgba) {
  562|   478k|  switch (out_colorspace) {
  563|      0|    case MODE_RGB:
  ------------------
  |  Branch (563:5): [True: 0, False: 478k]
  ------------------
  564|      0|      VP8LConvertBGRAToRGB(in_data, num_pixels, rgba);
  565|      0|      break;
  566|   478k|    case MODE_RGBA:
  ------------------
  |  Branch (566:5): [True: 478k, False: 0]
  ------------------
  567|   478k|      VP8LConvertBGRAToRGBA(in_data, num_pixels, rgba);
  568|   478k|      break;
  569|      0|    case MODE_rgbA:
  ------------------
  |  Branch (569:5): [True: 0, False: 478k]
  ------------------
  570|      0|      VP8LConvertBGRAToRGBA(in_data, num_pixels, rgba);
  571|      0|      WebPApplyAlphaMultiply(rgba, 0, num_pixels, 1, 0);
  572|      0|      break;
  573|      0|    case MODE_BGR:
  ------------------
  |  Branch (573:5): [True: 0, False: 478k]
  ------------------
  574|      0|      VP8LConvertBGRAToBGR(in_data, num_pixels, rgba);
  575|      0|      break;
  576|      0|    case MODE_BGRA:
  ------------------
  |  Branch (576:5): [True: 0, False: 478k]
  ------------------
  577|      0|      CopyOrSwap(in_data, num_pixels, rgba, 1);
  578|      0|      break;
  579|      0|    case MODE_bgrA:
  ------------------
  |  Branch (579:5): [True: 0, False: 478k]
  ------------------
  580|      0|      CopyOrSwap(in_data, num_pixels, rgba, 1);
  581|      0|      WebPApplyAlphaMultiply(rgba, 0, num_pixels, 1, 0);
  582|      0|      break;
  583|      0|    case MODE_ARGB:
  ------------------
  |  Branch (583:5): [True: 0, False: 478k]
  ------------------
  584|      0|      CopyOrSwap(in_data, num_pixels, rgba, 0);
  585|      0|      break;
  586|      0|    case MODE_Argb:
  ------------------
  |  Branch (586:5): [True: 0, False: 478k]
  ------------------
  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: 478k]
  ------------------
  591|      0|      VP8LConvertBGRAToRGBA4444(in_data, num_pixels, rgba);
  592|      0|      break;
  593|      0|    case MODE_rgbA_4444:
  ------------------
  |  Branch (593:5): [True: 0, False: 478k]
  ------------------
  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: 478k]
  ------------------
  598|      0|      VP8LConvertBGRAToRGB565(in_data, num_pixels, rgba);
  599|      0|      break;
  600|      0|    default:
  ------------------
  |  Branch (600:5): [True: 0, False: 478k]
  ------------------
  601|       |      assert(0);  // Code flow should not reach here.
  602|   478k|  }
  603|   478k|}
lossless.c:Average2:
   35|  70.8k|static WEBP_INLINE uint32_t Average2(uint32_t a0, uint32_t a1) {
   36|  70.8k|  return (((a0 ^ a1) & 0xfefefefeu) >> 1) + (a0 & a1);
   37|  70.8k|}
lossless.c:Average4:
   44|  15.0k|                                     uint32_t a3) {
   45|  15.0k|  return Average2(Average2(a0, a1), Average2(a2, a3));
   46|  15.0k|}
lossless.c:Select:
  102|  14.5k|static WEBP_INLINE uint32_t Select(uint32_t a, uint32_t b, uint32_t c) {
  103|  14.5k|  const int pa_minus_pb =
  104|  14.5k|      Sub3((a >> 24), (b >> 24), (c >> 24)) +
  105|  14.5k|      Sub3((a >> 16) & 0xff, (b >> 16) & 0xff, (c >> 16) & 0xff) +
  106|  14.5k|      Sub3((a >> 8) & 0xff, (b >> 8) & 0xff, (c >> 8) & 0xff) +
  107|  14.5k|      Sub3((a) & 0xff, (b) & 0xff, (c) & 0xff);
  108|  14.5k|  return (pa_minus_pb <= 0) ? a : b;
  ------------------
  |  Branch (108:10): [True: 13.6k, False: 888]
  ------------------
  109|  14.5k|}
lossless.c:Sub3:
   94|  58.2k|static LOCAL_INLINE int Sub3(int a, int b, int c) {
   95|  58.2k|  const int pb = b - c;
   96|  58.2k|  const int pa = a - c;
   97|  58.2k|  return abs(pb) - abs(pa);
   98|  58.2k|}
lossless.c:ClampedAddSubtractFull:
   62|  25.2k|                                                   uint32_t c2) {
   63|  25.2k|  const int a = AddSubtractComponentFull(c0 >> 24, c1 >> 24, c2 >> 24);
   64|  25.2k|  const int r = AddSubtractComponentFull((c0 >> 16) & 0xff, (c1 >> 16) & 0xff,
   65|  25.2k|                                         (c2 >> 16) & 0xff);
   66|  25.2k|  const int g = AddSubtractComponentFull((c0 >> 8) & 0xff, (c1 >> 8) & 0xff,
   67|  25.2k|                                         (c2 >> 8) & 0xff);
   68|  25.2k|  const int b = AddSubtractComponentFull(c0 & 0xff, c1 & 0xff, c2 & 0xff);
   69|  25.2k|  return ((uint32_t)a << 24) | (r << 16) | (g << 8) | b;
   70|  25.2k|}
lossless.c:AddSubtractComponentFull:
   57|   100k|static WEBP_INLINE int AddSubtractComponentFull(int a, int b, int c) {
   58|   100k|  return Clip255((uint32_t)(a + b - c));
   59|   100k|}
lossless.c:Clip255:
   48|   100k|static WEBP_INLINE uint32_t Clip255(uint32_t a) {
   49|   100k|  if (a < 256) {
  ------------------
  |  Branch (49:7): [True: 86.3k, False: 14.5k]
  ------------------
   50|  86.3k|    return a;
   51|  86.3k|  }
   52|       |  // return 0, when a is a negative integer.
   53|       |  // return 255, when a is positive.
   54|  14.5k|  return ~a >> 24;
   55|   100k|}
lossless.c:ColorTransformDelta:
  278|   248k|static WEBP_INLINE int ColorTransformDelta(int8_t color_pred, int8_t color) {
  279|   248k|  return ((int)color_pred * color) >> 5;
  280|   248k|}
lossless.c:PredictorInverseTransform_C:
  221|  11.1k|                                        const uint32_t* in, uint32_t* out) {
  222|  11.1k|  const int width = transform->xsize;
  223|  11.1k|  if (y_start == 0) {  // First Row follows the L (mode=1) mode.
  ------------------
  |  Branch (223:7): [True: 459, False: 10.7k]
  ------------------
  224|    459|    PredictorAdd0_C(in, NULL, 1, out);
  225|    459|    PredictorAdd1_C(in + 1, NULL, width - 1, out + 1);
  226|    459|    in += width;
  227|    459|    out += width;
  228|    459|    ++y_start;
  229|    459|  }
  230|       |
  231|  11.1k|  {
  232|  11.1k|    int y = y_start;
  233|  11.1k|    const int tile_width = 1 << transform->bits;
  234|  11.1k|    const int mask = tile_width - 1;
  235|  11.1k|    const int tiles_per_row = VP8LSubSampleSize(width, transform->bits);
  236|  11.1k|    const uint32_t* pred_mode_base =
  237|  11.1k|        transform->data + (y >> transform->bits) * tiles_per_row;
  238|       |
  239|   184k|    while (y < y_end) {
  ------------------
  |  Branch (239:12): [True: 173k, False: 11.1k]
  ------------------
  240|   173k|      const uint32_t* pred_mode_src = pred_mode_base;
  241|   173k|      int x = 1;
  242|       |      // First pixel follows the T (mode=2) mode.
  243|   173k|      PredictorAdd2_C(in, out - width, 1, out);
  244|       |      // .. the rest:
  245|   454k|      while (x < width) {
  ------------------
  |  Branch (245:14): [True: 280k, False: 173k]
  ------------------
  246|   280k|        const VP8LPredictorAddSubFunc pred_func =
  247|   280k|            VP8LPredictorsAdd[((*pred_mode_src++) >> 8) & 0xf];
  248|   280k|        int x_end = (x & ~mask) + tile_width;
  249|   280k|        if (x_end > width) x_end = width;
  ------------------
  |  Branch (249:13): [True: 142k, False: 138k]
  ------------------
  250|   280k|        pred_func(in + x, out + x - width, x_end - x, out + x);
  251|   280k|        x = x_end;
  252|   280k|      }
  253|   173k|      in += width;
  254|   173k|      out += width;
  255|   173k|      ++y;
  256|   173k|      if ((y & mask) == 0) {  // Use the same mask, since tiles are squares.
  ------------------
  |  Branch (256:11): [True: 16.5k, False: 157k]
  ------------------
  257|  16.5k|        pred_mode_base += tiles_per_row;
  258|  16.5k|      }
  259|   173k|    }
  260|  11.1k|  }
  261|  11.1k|}
lossless.c:PredictorAdd0_C:
  189|  74.6k|                            int num_pixels, uint32_t* WEBP_RESTRICT out) {
  190|  74.6k|  int x;
  191|  74.6k|  (void)upper;
  192|   193k|  for (x = 0; x < num_pixels; ++x) out[x] = VP8LAddPixels(in[x], ARGB_BLACK);
  ------------------
  |  |   38|   118k|#define ARGB_BLACK 0xff000000
  ------------------
  |  Branch (192:15): [True: 118k, False: 74.6k]
  ------------------
  193|  74.6k|}
lossless.c:PredictorAdd1_C:
  195|  14.6k|                            int num_pixels, uint32_t* WEBP_RESTRICT out) {
  196|  14.6k|  int i;
  197|  14.6k|  uint32_t left = out[-1];
  198|  14.6k|  (void)upper;
  199|   367k|  for (i = 0; i < num_pixels; ++i) {
  ------------------
  |  Branch (199:15): [True: 353k, False: 14.6k]
  ------------------
  200|   353k|    out[i] = left = VP8LAddPixels(in[i], left);
  201|   353k|  }
  202|  14.6k|}
lossless.c:ColorSpaceInverseTransform_C:
  311|  4.87k|                                         const uint32_t* src, uint32_t* dst) {
  312|  4.87k|  const int width = transform->xsize;
  313|  4.87k|  const int tile_width = 1 << transform->bits;
  314|  4.87k|  const int mask = tile_width - 1;
  315|  4.87k|  const int safe_width = width & ~mask;
  316|  4.87k|  const int remaining_width = width - safe_width;
  317|  4.87k|  const int tiles_per_row = VP8LSubSampleSize(width, transform->bits);
  318|  4.87k|  int y = y_start;
  319|  4.87k|  const uint32_t* pred_row =
  320|  4.87k|      transform->data + (y >> transform->bits) * tiles_per_row;
  321|       |
  322|  81.5k|  while (y < y_end) {
  ------------------
  |  Branch (322:10): [True: 76.7k, False: 4.87k]
  ------------------
  323|  76.7k|    const uint32_t* pred = pred_row;
  324|  76.7k|    VP8LMultipliers m = {0, 0, 0};
  325|  76.7k|    const uint32_t* const src_safe_end = src + safe_width;
  326|  76.7k|    const uint32_t* const src_end = src + width;
  327|   291k|    while (src < src_safe_end) {
  ------------------
  |  Branch (327:12): [True: 215k, False: 76.7k]
  ------------------
  328|   215k|      ColorCodeToMultipliers(*pred++, &m);
  329|   215k|      VP8LTransformColorInverse(&m, src, tile_width, dst);
  330|   215k|      src += tile_width;
  331|   215k|      dst += tile_width;
  332|   215k|    }
  333|  76.7k|    if (src < src_end) {  // Left-overs using C-version.
  ------------------
  |  Branch (333:9): [True: 62.6k, False: 14.0k]
  ------------------
  334|  62.6k|      ColorCodeToMultipliers(*pred++, &m);
  335|  62.6k|      VP8LTransformColorInverse(&m, src, remaining_width, dst);
  336|  62.6k|      src += remaining_width;
  337|  62.6k|      dst += remaining_width;
  338|  62.6k|    }
  339|  76.7k|    ++y;
  340|  76.7k|    if ((y & mask) == 0) pred_row += tiles_per_row;
  ------------------
  |  Branch (340:9): [True: 3.63k, False: 73.0k]
  ------------------
  341|  76.7k|  }
  342|  4.87k|}
lossless.c:ColorCodeToMultipliers:
  283|   277k|                                               VP8LMultipliers* const m) {
  284|   277k|  m->green_to_red = (color_code >> 0) & 0xff;
  285|   277k|  m->green_to_blue = (color_code >> 8) & 0xff;
  286|   277k|  m->red_to_blue = (color_code >> 16) & 0xff;
  287|   277k|}
lossless.c:ColorIndexInverseTransform_C:
  361|  13.8k|                           TYPE* dst) {                                        \
  362|  13.8k|  int y;                                                                       \
  363|  13.8k|  const int bits_per_pixel = 8 >> transform->bits;                             \
  364|  13.8k|  const int width = transform->xsize;                                          \
  365|  13.8k|  const uint32_t* const color_map = transform->data;                           \
  366|  13.8k|  if (bits_per_pixel < 8) {                                                    \
  ------------------
  |  Branch (366:7): [True: 9.40k, False: 4.44k]
  ------------------
  367|  9.40k|    const int pixels_per_byte = 1 << transform->bits;                          \
  368|  9.40k|    const uint32_t bit_mask = (1 << bits_per_pixel) - 1;                       \
  369|   158k|    for (y = y_start; y < y_end; ++y) {                                        \
  ------------------
  |  Branch (369:23): [True: 149k, False: 9.40k]
  ------------------
  370|   149k|      int x;                                                                   \
  371|   546k|      for (x = 0; x + pixels_per_byte <= width; x += pixels_per_byte) {        \
  ------------------
  |  Branch (371:19): [True: 397k, False: 149k]
  ------------------
  372|   397k|        uint32_t packed = GET_INDEX(*src++);                                   \
  373|   397k|        if (bits_per_pixel == 1) {                                             \
  ------------------
  |  Branch (373:13): [True: 51.7k, False: 345k]
  ------------------
  374|  51.7k|          *dst++ = GET_VALUE(color_map[packed & 1]);                           \
  375|  51.7k|          packed >>= 1;                                                        \
  376|  51.7k|          *dst++ = GET_VALUE(color_map[packed & 1]);                           \
  377|  51.7k|          packed >>= 1;                                                        \
  378|  51.7k|          *dst++ = GET_VALUE(color_map[packed & 1]);                           \
  379|  51.7k|          packed >>= 1;                                                        \
  380|  51.7k|          *dst++ = GET_VALUE(color_map[packed & 1]);                           \
  381|  51.7k|          packed >>= 1;                                                        \
  382|  51.7k|          *dst++ = GET_VALUE(color_map[packed & 1]);                           \
  383|  51.7k|          packed >>= 1;                                                        \
  384|  51.7k|          *dst++ = GET_VALUE(color_map[packed & 1]);                           \
  385|  51.7k|          packed >>= 1;                                                        \
  386|  51.7k|          *dst++ = GET_VALUE(color_map[packed & 1]);                           \
  387|  51.7k|          packed >>= 1;                                                        \
  388|  51.7k|          *dst++ = GET_VALUE(color_map[packed & 1]);                           \
  389|   345k|        } else if (bits_per_pixel == 2) {                                      \
  ------------------
  |  Branch (389:20): [True: 122k, False: 223k]
  ------------------
  390|   122k|          *dst++ = GET_VALUE(color_map[packed & 3]);                           \
  391|   122k|          packed >>= 2;                                                        \
  392|   122k|          *dst++ = GET_VALUE(color_map[packed & 3]);                           \
  393|   122k|          packed >>= 2;                                                        \
  394|   122k|          *dst++ = GET_VALUE(color_map[packed & 3]);                           \
  395|   122k|          packed >>= 2;                                                        \
  396|   122k|          *dst++ = GET_VALUE(color_map[packed & 3]);                           \
  397|   223k|        } else {                                                               \
  398|   223k|          *dst++ = GET_VALUE(color_map[packed & 15]);                          \
  399|   223k|          packed >>= 4;                                                        \
  400|   223k|          *dst++ = GET_VALUE(color_map[packed & 15]);                          \
  401|   223k|        }                                                                      \
  402|   397k|      }                                                                        \
  403|   149k|      if (x < width) {                                                         \
  ------------------
  |  Branch (403:11): [True: 115k, False: 33.5k]
  ------------------
  404|   115k|        uint32_t packed = GET_INDEX(*src++);                                   \
  405|   455k|        for (; x < width; ++x) {                                               \
  ------------------
  |  Branch (405:16): [True: 340k, False: 115k]
  ------------------
  406|   340k|          *dst++ = GET_VALUE(color_map[packed & bit_mask]);                    \
  407|   340k|          packed >>= bits_per_pixel;                                           \
  408|   340k|        }                                                                      \
  409|   115k|      }                                                                        \
  410|   149k|    }                                                                          \
  411|  9.40k|  } else {                                                                     \
  412|  4.44k|    VP8LMapColor##BIT_SUFFIX(src, color_map, dst, y_start, y_end, width);      \
  413|  4.44k|  }                                                                            \
  414|  13.8k|}
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|  4.44k|                   TYPE* dst, int y_start, int y_end, int width) {             \
  351|  4.44k|  int y;                                                                       \
  352|  74.9k|  for (y = y_start; y < y_end; ++y) {                                          \
  ------------------
  |  Branch (352:21): [True: 70.5k, False: 4.44k]
  ------------------
  353|  70.5k|    int x;                                                                     \
  354|   896k|    for (x = 0; x < width; ++x) {                                              \
  ------------------
  |  Branch (354:17): [True: 826k, False: 70.5k]
  ------------------
  355|   826k|      *dst++ = GET_VALUE(color_map[GET_INDEX(*src++)]);                        \
  356|   826k|    }                                                                          \
  357|  70.5k|  }                                                                            \
  358|  4.44k|}                                                                              \

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|   144k|                               int num_pixels, uint32_t* WEBP_RESTRICT out) {
   44|   144k|  int i;
   45|   144k|  const __m256i black = _mm256_set1_epi32((int)ARGB_BLACK);
  ------------------
  |  |   38|   144k|#define ARGB_BLACK 0xff000000
  ------------------
   46|   259k|  for (i = 0; i + 8 <= num_pixels; i += 8) {
  ------------------
  |  Branch (46:15): [True: 114k, False: 144k]
  ------------------
   47|   114k|    const __m256i src = _mm256_loadu_si256((const __m256i*)&in[i]);
   48|   114k|    const __m256i res = _mm256_add_epi8(src, black);
   49|   114k|    _mm256_storeu_si256((__m256i*)&out[i], res);
   50|   114k|  }
   51|   144k|  if (i != num_pixels) {
  ------------------
  |  Branch (51:7): [True: 122k, False: 22.1k]
  ------------------
   52|       |    VP8LPredictorsAdd_SSE[0](in + i, NULL, num_pixels - i, out + i);
   53|   122k|  }
   54|   144k|  (void)upper;
   55|   144k|}
lossless_avx2.c:PredictorAdd1_AVX2:
   59|  36.9k|                               int num_pixels, uint32_t* WEBP_RESTRICT out) {
   60|  36.9k|  int i;
   61|  36.9k|  __m256i prev = _mm256_set1_epi32((int)out[-1]);
   62|   100k|  for (i = 0; i + 8 <= num_pixels; i += 8) {
  ------------------
  |  Branch (62:15): [True: 63.0k, False: 36.9k]
  ------------------
   63|       |    // h | g | f | e | d | c | b | a
   64|  63.0k|    const __m256i src = _mm256_loadu_si256((const __m256i*)&in[i]);
   65|       |    // g | f | e | 0 | c | b | a | 0
   66|  63.0k|    const __m256i shift0 = _mm256_slli_si256(src, 4);
   67|       |    // g + h | f + g | e + f | e | c + d | b + c | a + b | a
   68|  63.0k|    const __m256i sum0 = _mm256_add_epi8(src, shift0);
   69|       |    // e + f | e | 0 | 0 | a + b | a | 0 | 0
   70|  63.0k|    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|  63.0k|    const __m256i sum1 = _mm256_add_epi8(sum0, shift1);
   74|       |    // Add a + b + c + d to the upper lane.
   75|  63.0k|    const int32_t sum_abcd = _mm256_extract_epi32(sum1, 3);
   76|  63.0k|    const __m256i sum2 = _mm256_add_epi8(
   77|  63.0k|        sum1,
   78|  63.0k|        _mm256_set_epi32(sum_abcd, sum_abcd, sum_abcd, sum_abcd, 0, 0, 0, 0));
   79|       |
   80|  63.0k|    const __m256i res = _mm256_add_epi8(sum2, prev);
   81|  63.0k|    _mm256_storeu_si256((__m256i*)&out[i], res);
   82|       |    // replicate last res output in prev.
   83|  63.0k|    prev = _mm256_permutevar8x32_epi32(
   84|  63.0k|        res, _mm256_set_epi32(7, 7, 7, 7, 7, 7, 7, 7));
   85|  63.0k|  }
   86|  36.9k|  if (i != num_pixels) {
  ------------------
  |  Branch (86:7): [True: 31.4k, False: 5.51k]
  ------------------
   87|  31.4k|    VP8LPredictorsAdd_SSE[1](in + i, upper + i, num_pixels - i, out + i);
   88|  31.4k|  }
   89|  36.9k|}
lossless_avx2.c:PredictorAdd2_AVX2:
   96|  5.53k|                                     uint32_t* WEBP_RESTRICT out) {           \
   97|  5.53k|    int i;                                                                    \
   98|  54.6k|    for (i = 0; i + 8 <= num_pixels; i += 8) {                                \
  ------------------
  |  Branch (98:17): [True: 49.0k, False: 5.53k]
  ------------------
   99|  49.0k|      const __m256i src = _mm256_loadu_si256((const __m256i*)&in[i]);         \
  100|  49.0k|      const __m256i other = _mm256_loadu_si256((const __m256i*)&(IN));        \
  101|  49.0k|      const __m256i res = _mm256_add_epi8(src, other);                        \
  102|  49.0k|      _mm256_storeu_si256((__m256i*)&out[i], res);                            \
  103|  49.0k|    }                                                                         \
  104|  5.53k|    if (i != num_pixels) {                                                    \
  ------------------
  |  Branch (104:9): [True: 3.81k, False: 1.71k]
  ------------------
  105|  3.81k|      VP8LPredictorsAdd_SSE[(X)](in + i, upper + i, num_pixels - i, out + i); \
  106|  3.81k|    }                                                                         \
  107|  5.53k|  }
lossless_avx2.c:PredictorAdd3_AVX2:
   96|  7.18k|                                     uint32_t* WEBP_RESTRICT out) {           \
   97|  7.18k|    int i;                                                                    \
   98|  50.2k|    for (i = 0; i + 8 <= num_pixels; i += 8) {                                \
  ------------------
  |  Branch (98:17): [True: 43.0k, False: 7.18k]
  ------------------
   99|  43.0k|      const __m256i src = _mm256_loadu_si256((const __m256i*)&in[i]);         \
  100|  43.0k|      const __m256i other = _mm256_loadu_si256((const __m256i*)&(IN));        \
  101|  43.0k|      const __m256i res = _mm256_add_epi8(src, other);                        \
  102|  43.0k|      _mm256_storeu_si256((__m256i*)&out[i], res);                            \
  103|  43.0k|    }                                                                         \
  104|  7.18k|    if (i != num_pixels) {                                                    \
  ------------------
  |  Branch (104:9): [True: 4.86k, False: 2.32k]
  ------------------
  105|  4.86k|      VP8LPredictorsAdd_SSE[(X)](in + i, upper + i, num_pixels - i, out + i); \
  106|  4.86k|    }                                                                         \
  107|  7.18k|  }
lossless_avx2.c:PredictorAdd4_AVX2:
   96|  12.6k|                                     uint32_t* WEBP_RESTRICT out) {           \
   97|  12.6k|    int i;                                                                    \
   98|  83.9k|    for (i = 0; i + 8 <= num_pixels; i += 8) {                                \
  ------------------
  |  Branch (98:17): [True: 71.2k, False: 12.6k]
  ------------------
   99|  71.2k|      const __m256i src = _mm256_loadu_si256((const __m256i*)&in[i]);         \
  100|  71.2k|      const __m256i other = _mm256_loadu_si256((const __m256i*)&(IN));        \
  101|  71.2k|      const __m256i res = _mm256_add_epi8(src, other);                        \
  102|  71.2k|      _mm256_storeu_si256((__m256i*)&out[i], res);                            \
  103|  71.2k|    }                                                                         \
  104|  12.6k|    if (i != num_pixels) {                                                    \
  ------------------
  |  Branch (104:9): [True: 4.47k, False: 8.20k]
  ------------------
  105|  4.47k|      VP8LPredictorsAdd_SSE[(X)](in + i, upper + i, num_pixels - i, out + i); \
  106|  4.47k|    }                                                                         \
  107|  12.6k|  }
lossless_avx2.c:PredictorAdd8_AVX2:
  123|  7.85k|                                     uint32_t* WEBP_RESTRICT out) {           \
  124|  7.85k|    int i;                                                                    \
  125|  57.6k|    for (i = 0; i + 8 <= num_pixels; i += 8) {                                \
  ------------------
  |  Branch (125:17): [True: 49.8k, False: 7.85k]
  ------------------
  126|  49.8k|      const __m256i Tother = _mm256_loadu_si256((const __m256i*)&(IN));       \
  127|  49.8k|      const __m256i T = _mm256_loadu_si256((const __m256i*)&upper[i]);        \
  128|  49.8k|      const __m256i src = _mm256_loadu_si256((const __m256i*)&in[i]);         \
  129|  49.8k|      __m256i avg, res;                                                       \
  130|  49.8k|      Average2_m256i(&T, &Tother, &avg);                                      \
  131|  49.8k|      res = _mm256_add_epi8(avg, src);                                        \
  132|  49.8k|      _mm256_storeu_si256((__m256i*)&out[i], res);                            \
  133|  49.8k|    }                                                                         \
  134|  7.85k|    if (i != num_pixels) {                                                    \
  ------------------
  |  Branch (134:9): [True: 5.23k, False: 2.62k]
  ------------------
  135|  5.23k|      VP8LPredictorsAdd_SSE[(X)](in + i, upper + i, num_pixels - i, out + i); \
  136|  5.23k|    }                                                                         \
  137|  7.85k|  }
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|  9.03k|                                     uint32_t* WEBP_RESTRICT out) {           \
  124|  9.03k|    int i;                                                                    \
  125|  71.6k|    for (i = 0; i + 8 <= num_pixels; i += 8) {                                \
  ------------------
  |  Branch (125:17): [True: 62.5k, False: 9.03k]
  ------------------
  126|  62.5k|      const __m256i Tother = _mm256_loadu_si256((const __m256i*)&(IN));       \
  127|  62.5k|      const __m256i T = _mm256_loadu_si256((const __m256i*)&upper[i]);        \
  128|  62.5k|      const __m256i src = _mm256_loadu_si256((const __m256i*)&in[i]);         \
  129|  62.5k|      __m256i avg, res;                                                       \
  130|  62.5k|      Average2_m256i(&T, &Tother, &avg);                                      \
  131|  62.5k|      res = _mm256_add_epi8(avg, src);                                        \
  132|  62.5k|      _mm256_storeu_si256((__m256i*)&out[i], res);                            \
  133|  62.5k|    }                                                                         \
  134|  9.03k|    if (i != num_pixels) {                                                    \
  ------------------
  |  Branch (134:9): [True: 7.51k, False: 1.51k]
  ------------------
  135|  7.51k|      VP8LPredictorsAdd_SSE[(X)](in + i, upper + i, num_pixels - i, out + i); \
  136|  7.51k|    }                                                                         \
  137|  9.03k|  }
lossless_avx2.c:PredictorAdd10_AVX2:
  163|  8.94k|                                int num_pixels, uint32_t* WEBP_RESTRICT out) {
  164|  8.94k|  int i, j;
  165|  8.94k|  __m256i L = _mm256_setr_epi32((int)out[-1], 0, 0, 0, 0, 0, 0, 0);
  166|  70.5k|  for (i = 0; i + 8 <= num_pixels; i += 8) {
  ------------------
  |  Branch (166:15): [True: 61.5k, False: 8.94k]
  ------------------
  167|  61.5k|    __m256i src = _mm256_loadu_si256((const __m256i*)&in[i]);
  168|  61.5k|    __m256i TL = _mm256_loadu_si256((const __m256i*)&upper[i - 1]);
  169|  61.5k|    const __m256i T = _mm256_loadu_si256((const __m256i*)&upper[i]);
  170|  61.5k|    const __m256i TR = _mm256_loadu_si256((const __m256i*)&upper[i + 1]);
  171|  61.5k|    __m256i avgTTR;
  172|  61.5k|    Average2_m256i(&T, &TR, &avgTTR);
  173|  61.5k|    {
  174|  61.5k|      const __m256i avgTTR_bak = avgTTR;
  175|  61.5k|      const __m256i TL_bak = TL;
  176|  61.5k|      const __m256i src_bak = src;
  177|   307k|      for (j = 0; j < 4; ++j) {
  ------------------
  |  Branch (177:19): [True: 246k, False: 61.5k]
  ------------------
  178|   246k|        DO_PRED10(j);
  ------------------
  |  |  146|   246k|  do {                                                  \
  |  |  147|   246k|    __m256i avgLTL, avg;                                \
  |  |  148|   246k|    Average2_m256i(&L, &TL, &avgLTL);                   \
  |  |  149|   246k|    Average2_m256i(&avgTTR, &avgLTL, &avg);             \
  |  |  150|   246k|    L = _mm256_add_epi8(avg, src);                      \
  |  |  151|   246k|    out[i + (OUT)] = (uint32_t)_mm256_cvtsi256_si32(L); \
  |  |  152|   246k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (152:12): [Folded, False: 246k]
  |  |  ------------------
  ------------------
  179|   246k|        DO_PRED10_SHIFT;
  ------------------
  |  |  155|   246k|  do {                                                          \
  |  |  156|   246k|    /* Rotate the pre-computed values for the next iteration.*/ \
  |  |  157|   246k|    avgTTR = _mm256_srli_si256(avgTTR, 4);                      \
  |  |  158|   246k|    TL = _mm256_srli_si256(TL, 4);                              \
  |  |  159|   246k|    src = _mm256_srli_si256(src, 4);                            \
  |  |  160|   246k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (160:12): [Folded, False: 246k]
  |  |  ------------------
  ------------------
  180|   246k|      }
  181|  61.5k|      avgTTR = _mm256_permute2x128_si256(avgTTR_bak, avgTTR_bak, 1);
  182|  61.5k|      TL = _mm256_permute2x128_si256(TL_bak, TL_bak, 1);
  183|  61.5k|      src = _mm256_permute2x128_si256(src_bak, src_bak, 1);
  184|   307k|      for (; j < 8; ++j) {
  ------------------
  |  Branch (184:14): [True: 246k, False: 61.5k]
  ------------------
  185|   246k|        DO_PRED10(j);
  ------------------
  |  |  146|   246k|  do {                                                  \
  |  |  147|   246k|    __m256i avgLTL, avg;                                \
  |  |  148|   246k|    Average2_m256i(&L, &TL, &avgLTL);                   \
  |  |  149|   246k|    Average2_m256i(&avgTTR, &avgLTL, &avg);             \
  |  |  150|   246k|    L = _mm256_add_epi8(avg, src);                      \
  |  |  151|   246k|    out[i + (OUT)] = (uint32_t)_mm256_cvtsi256_si32(L); \
  |  |  152|   246k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (152:12): [Folded, False: 246k]
  |  |  ------------------
  ------------------
  186|   246k|        DO_PRED10_SHIFT;
  ------------------
  |  |  155|   246k|  do {                                                          \
  |  |  156|   246k|    /* Rotate the pre-computed values for the next iteration.*/ \
  |  |  157|   246k|    avgTTR = _mm256_srli_si256(avgTTR, 4);                      \
  |  |  158|   246k|    TL = _mm256_srli_si256(TL, 4);                              \
  |  |  159|   246k|    src = _mm256_srli_si256(src, 4);                            \
  |  |  160|   246k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (160:12): [Folded, False: 246k]
  |  |  ------------------
  ------------------
  187|   246k|      }
  188|  61.5k|    }
  189|  61.5k|  }
  190|  8.94k|  if (i != num_pixels) {
  ------------------
  |  Branch (190:7): [True: 7.55k, False: 1.39k]
  ------------------
  191|  7.55k|    VP8LPredictorsAdd_SSE[10](in + i, upper + i, num_pixels - i, out + i);
  192|  7.55k|  }
  193|  8.94k|}
lossless_avx2.c:PredictorAdd11_AVX2:
  221|  8.08k|                                int num_pixels, uint32_t* WEBP_RESTRICT out) {
  222|  8.08k|  int i, j;
  223|  8.08k|  __m256i pa;
  224|  8.08k|  __m256i L = _mm256_setr_epi32((int)out[-1], 0, 0, 0, 0, 0, 0, 0);
  225|  64.7k|  for (i = 0; i + 8 <= num_pixels; i += 8) {
  ------------------
  |  Branch (225:15): [True: 56.6k, False: 8.08k]
  ------------------
  226|  56.6k|    __m256i T = _mm256_loadu_si256((const __m256i*)&upper[i]);
  227|  56.6k|    __m256i TL = _mm256_loadu_si256((const __m256i*)&upper[i - 1]);
  228|  56.6k|    __m256i src = _mm256_loadu_si256((const __m256i*)&in[i]);
  229|  56.6k|    {
  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|  56.6k|      const __m256i T_lo = _mm256_unpacklo_epi32(T, T);
  234|  56.6k|      const __m256i TL_lo = _mm256_unpacklo_epi32(TL, T);
  235|  56.6k|      const __m256i T_hi = _mm256_unpackhi_epi32(T, T);
  236|  56.6k|      const __m256i TL_hi = _mm256_unpackhi_epi32(TL, T);
  237|  56.6k|      const __m256i s_lo = _mm256_sad_epu8(T_lo, TL_lo);
  238|  56.6k|      const __m256i s_hi = _mm256_sad_epu8(T_hi, TL_hi);
  239|  56.6k|      pa = _mm256_packs_epi32(s_lo, s_hi);  // pa = sum |T-TL|
  240|  56.6k|    }
  241|  56.6k|    {
  242|  56.6k|      const __m256i T_bak = T;
  243|  56.6k|      const __m256i TL_bak = TL;
  244|  56.6k|      const __m256i src_bak = src;
  245|  56.6k|      const __m256i pa_bak = pa;
  246|   283k|      for (j = 0; j < 4; ++j) {
  ------------------
  |  Branch (246:19): [True: 226k, False: 56.6k]
  ------------------
  247|   226k|        DO_PRED11(j);
  ------------------
  |  |  199|   226k|  do {                                                                      \
  |  |  200|   226k|    const __m256i L_lo = _mm256_unpacklo_epi32(L, T);                       \
  |  |  201|   226k|    const __m256i TL_lo = _mm256_unpacklo_epi32(TL, T);                     \
  |  |  202|   226k|    const __m256i pb = _mm256_sad_epu8(L_lo, TL_lo); /* pb = sum |L-TL|*/   \
  |  |  203|   226k|    const __m256i mask = _mm256_cmpgt_epi32(pb, pa);                        \
  |  |  204|   226k|    const __m256i A = _mm256_and_si256(mask, L);                            \
  |  |  205|   226k|    const __m256i B = _mm256_andnot_si256(mask, T);                         \
  |  |  206|   226k|    const __m256i pred = _mm256_or_si256(A, B); /* pred = (pa > b)? L : T*/ \
  |  |  207|   226k|    L = _mm256_add_epi8(src, pred);                                         \
  |  |  208|   226k|    out[i + (OUT)] = (uint32_t)_mm256_cvtsi256_si32(L);                     \
  |  |  209|   226k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (209:12): [Folded, False: 226k]
  |  |  ------------------
  ------------------
  248|   226k|        DO_PRED11_SHIFT;
  ------------------
  |  |  212|   226k|  do {                                                        \
  |  |  213|   226k|    /* Shift the pre-computed value for the next iteration.*/ \
  |  |  214|   226k|    T = _mm256_srli_si256(T, 4);                              \
  |  |  215|   226k|    TL = _mm256_srli_si256(TL, 4);                            \
  |  |  216|   226k|    src = _mm256_srli_si256(src, 4);                          \
  |  |  217|   226k|    pa = _mm256_srli_si256(pa, 4);                            \
  |  |  218|   226k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (218:12): [Folded, False: 226k]
  |  |  ------------------
  ------------------
  249|   226k|      }
  250|  56.6k|      T = _mm256_permute2x128_si256(T_bak, T_bak, 1);
  251|  56.6k|      TL = _mm256_permute2x128_si256(TL_bak, TL_bak, 1);
  252|  56.6k|      src = _mm256_permute2x128_si256(src_bak, src_bak, 1);
  253|  56.6k|      pa = _mm256_permute2x128_si256(pa_bak, pa_bak, 1);
  254|   283k|      for (; j < 8; ++j) {
  ------------------
  |  Branch (254:14): [True: 226k, False: 56.6k]
  ------------------
  255|   226k|        DO_PRED11(j);
  ------------------
  |  |  199|   226k|  do {                                                                      \
  |  |  200|   226k|    const __m256i L_lo = _mm256_unpacklo_epi32(L, T);                       \
  |  |  201|   226k|    const __m256i TL_lo = _mm256_unpacklo_epi32(TL, T);                     \
  |  |  202|   226k|    const __m256i pb = _mm256_sad_epu8(L_lo, TL_lo); /* pb = sum |L-TL|*/   \
  |  |  203|   226k|    const __m256i mask = _mm256_cmpgt_epi32(pb, pa);                        \
  |  |  204|   226k|    const __m256i A = _mm256_and_si256(mask, L);                            \
  |  |  205|   226k|    const __m256i B = _mm256_andnot_si256(mask, T);                         \
  |  |  206|   226k|    const __m256i pred = _mm256_or_si256(A, B); /* pred = (pa > b)? L : T*/ \
  |  |  207|   226k|    L = _mm256_add_epi8(src, pred);                                         \
  |  |  208|   226k|    out[i + (OUT)] = (uint32_t)_mm256_cvtsi256_si32(L);                     \
  |  |  209|   226k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (209:12): [Folded, False: 226k]
  |  |  ------------------
  ------------------
  256|   226k|        DO_PRED11_SHIFT;
  ------------------
  |  |  212|   226k|  do {                                                        \
  |  |  213|   226k|    /* Shift the pre-computed value for the next iteration.*/ \
  |  |  214|   226k|    T = _mm256_srli_si256(T, 4);                              \
  |  |  215|   226k|    TL = _mm256_srli_si256(TL, 4);                            \
  |  |  216|   226k|    src = _mm256_srli_si256(src, 4);                          \
  |  |  217|   226k|    pa = _mm256_srli_si256(pa, 4);                            \
  |  |  218|   226k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (218:12): [Folded, False: 226k]
  |  |  ------------------
  ------------------
  257|   226k|      }
  258|  56.6k|    }
  259|  56.6k|  }
  260|  8.08k|  if (i != num_pixels) {
  ------------------
  |  Branch (260:7): [True: 7.15k, False: 938]
  ------------------
  261|  7.15k|    VP8LPredictorsAdd_SSE[11](in + i, upper + i, num_pixels - i, out + i);
  262|  7.15k|  }
  263|  8.08k|}
lossless_avx2.c:PredictorAdd12_AVX2:
  285|  20.2k|                                int num_pixels, uint32_t* WEBP_RESTRICT out) {
  286|  20.2k|  int i;
  287|  20.2k|  const __m256i zero = _mm256_setzero_si256();
  288|  20.2k|  const __m256i L8 = _mm256_setr_epi32((int)out[-1], 0, 0, 0, 0, 0, 0, 0);
  289|  20.2k|  __m256i L = _mm256_unpacklo_epi8(L8, zero);
  290|   125k|  for (i = 0; i + 8 <= num_pixels; i += 8) {
  ------------------
  |  Branch (290:15): [True: 105k, False: 20.2k]
  ------------------
  291|       |    // Load 8 pixels at a time.
  292|   105k|    __m256i src = _mm256_loadu_si256((const __m256i*)&in[i]);
  293|   105k|    const __m256i T = _mm256_loadu_si256((const __m256i*)&upper[i]);
  294|   105k|    const __m256i T_lo = _mm256_unpacklo_epi8(T, zero);
  295|   105k|    const __m256i T_hi = _mm256_unpackhi_epi8(T, zero);
  296|   105k|    const __m256i TL = _mm256_loadu_si256((const __m256i*)&upper[i - 1]);
  297|   105k|    const __m256i TL_lo = _mm256_unpacklo_epi8(TL, zero);
  298|   105k|    const __m256i TL_hi = _mm256_unpackhi_epi8(TL, zero);
  299|   105k|    __m256i diff_lo = _mm256_sub_epi16(T_lo, TL_lo);
  300|   105k|    __m256i diff_hi = _mm256_sub_epi16(T_hi, TL_hi);
  301|   105k|    const __m256i diff_lo_bak = diff_lo;
  302|   105k|    const __m256i diff_hi_bak = diff_hi;
  303|   105k|    const __m256i src_bak = src;
  304|   105k|    DO_PRED12(diff_lo, 0);
  ------------------
  |  |  269|   105k|  do {                                                    \
  |  |  270|   105k|    const __m256i all = _mm256_add_epi16(L, (DIFF));      \
  |  |  271|   105k|    const __m256i alls = _mm256_packus_epi16(all, all);   \
  |  |  272|   105k|    const __m256i res = _mm256_add_epi8(src, alls);       \
  |  |  273|   105k|    out[i + (OUT)] = (uint32_t)_mm256_cvtsi256_si32(res); \
  |  |  274|   105k|    L = _mm256_unpacklo_epi8(res, zero);                  \
  |  |  275|   105k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (275:12): [Folded, False: 105k]
  |  |  ------------------
  ------------------
  305|   105k|    DO_PRED12_SHIFT(diff_lo, 0);
  ------------------
  |  |  278|   105k|  do {                                                        \
  |  |  279|   105k|    /* Shift the pre-computed value for the next iteration.*/ \
  |  |  280|   105k|    if ((LANE) == 0) (DIFF) = _mm256_srli_si256(DIFF, 8);     \
  |  |  ------------------
  |  |  |  Branch (280:9): [True: 105k, Folded]
  |  |  ------------------
  |  |  281|   105k|    src = _mm256_srli_si256(src, 4);                          \
  |  |  282|   105k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (282:12): [Folded, False: 105k]
  |  |  ------------------
  ------------------
  306|   105k|    DO_PRED12(diff_lo, 1);
  ------------------
  |  |  269|   105k|  do {                                                    \
  |  |  270|   105k|    const __m256i all = _mm256_add_epi16(L, (DIFF));      \
  |  |  271|   105k|    const __m256i alls = _mm256_packus_epi16(all, all);   \
  |  |  272|   105k|    const __m256i res = _mm256_add_epi8(src, alls);       \
  |  |  273|   105k|    out[i + (OUT)] = (uint32_t)_mm256_cvtsi256_si32(res); \
  |  |  274|   105k|    L = _mm256_unpacklo_epi8(res, zero);                  \
  |  |  275|   105k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (275:12): [Folded, False: 105k]
  |  |  ------------------
  ------------------
  307|   105k|    DO_PRED12_SHIFT(diff_lo, 0);
  ------------------
  |  |  278|   105k|  do {                                                        \
  |  |  279|   105k|    /* Shift the pre-computed value for the next iteration.*/ \
  |  |  280|   105k|    if ((LANE) == 0) (DIFF) = _mm256_srli_si256(DIFF, 8);     \
  |  |  ------------------
  |  |  |  Branch (280:9): [True: 105k, Folded]
  |  |  ------------------
  |  |  281|   105k|    src = _mm256_srli_si256(src, 4);                          \
  |  |  282|   105k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (282:12): [Folded, False: 105k]
  |  |  ------------------
  ------------------
  308|   105k|    DO_PRED12(diff_hi, 2);
  ------------------
  |  |  269|   105k|  do {                                                    \
  |  |  270|   105k|    const __m256i all = _mm256_add_epi16(L, (DIFF));      \
  |  |  271|   105k|    const __m256i alls = _mm256_packus_epi16(all, all);   \
  |  |  272|   105k|    const __m256i res = _mm256_add_epi8(src, alls);       \
  |  |  273|   105k|    out[i + (OUT)] = (uint32_t)_mm256_cvtsi256_si32(res); \
  |  |  274|   105k|    L = _mm256_unpacklo_epi8(res, zero);                  \
  |  |  275|   105k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (275:12): [Folded, False: 105k]
  |  |  ------------------
  ------------------
  309|   105k|    DO_PRED12_SHIFT(diff_hi, 0);
  ------------------
  |  |  278|   105k|  do {                                                        \
  |  |  279|   105k|    /* Shift the pre-computed value for the next iteration.*/ \
  |  |  280|   105k|    if ((LANE) == 0) (DIFF) = _mm256_srli_si256(DIFF, 8);     \
  |  |  ------------------
  |  |  |  Branch (280:9): [True: 105k, Folded]
  |  |  ------------------
  |  |  281|   105k|    src = _mm256_srli_si256(src, 4);                          \
  |  |  282|   105k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (282:12): [Folded, False: 105k]
  |  |  ------------------
  ------------------
  310|   105k|    DO_PRED12(diff_hi, 3);
  ------------------
  |  |  269|   105k|  do {                                                    \
  |  |  270|   105k|    const __m256i all = _mm256_add_epi16(L, (DIFF));      \
  |  |  271|   105k|    const __m256i alls = _mm256_packus_epi16(all, all);   \
  |  |  272|   105k|    const __m256i res = _mm256_add_epi8(src, alls);       \
  |  |  273|   105k|    out[i + (OUT)] = (uint32_t)_mm256_cvtsi256_si32(res); \
  |  |  274|   105k|    L = _mm256_unpacklo_epi8(res, zero);                  \
  |  |  275|   105k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (275:12): [Folded, False: 105k]
  |  |  ------------------
  ------------------
  311|   105k|    DO_PRED12_SHIFT(diff_hi, 0);
  ------------------
  |  |  278|   105k|  do {                                                        \
  |  |  279|   105k|    /* Shift the pre-computed value for the next iteration.*/ \
  |  |  280|   105k|    if ((LANE) == 0) (DIFF) = _mm256_srli_si256(DIFF, 8);     \
  |  |  ------------------
  |  |  |  Branch (280:9): [True: 105k, Folded]
  |  |  ------------------
  |  |  281|   105k|    src = _mm256_srli_si256(src, 4);                          \
  |  |  282|   105k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (282:12): [Folded, False: 105k]
  |  |  ------------------
  ------------------
  312|       |
  313|       |    // Process the upper lane.
  314|   105k|    diff_lo = _mm256_permute2x128_si256(diff_lo_bak, diff_lo_bak, 1);
  315|   105k|    diff_hi = _mm256_permute2x128_si256(diff_hi_bak, diff_hi_bak, 1);
  316|   105k|    src = _mm256_permute2x128_si256(src_bak, src_bak, 1);
  317|       |
  318|   105k|    DO_PRED12(diff_lo, 4);
  ------------------
  |  |  269|   105k|  do {                                                    \
  |  |  270|   105k|    const __m256i all = _mm256_add_epi16(L, (DIFF));      \
  |  |  271|   105k|    const __m256i alls = _mm256_packus_epi16(all, all);   \
  |  |  272|   105k|    const __m256i res = _mm256_add_epi8(src, alls);       \
  |  |  273|   105k|    out[i + (OUT)] = (uint32_t)_mm256_cvtsi256_si32(res); \
  |  |  274|   105k|    L = _mm256_unpacklo_epi8(res, zero);                  \
  |  |  275|   105k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (275:12): [Folded, False: 105k]
  |  |  ------------------
  ------------------
  319|   105k|    DO_PRED12_SHIFT(diff_lo, 0);
  ------------------
  |  |  278|   105k|  do {                                                        \
  |  |  279|   105k|    /* Shift the pre-computed value for the next iteration.*/ \
  |  |  280|   105k|    if ((LANE) == 0) (DIFF) = _mm256_srli_si256(DIFF, 8);     \
  |  |  ------------------
  |  |  |  Branch (280:9): [True: 105k, Folded]
  |  |  ------------------
  |  |  281|   105k|    src = _mm256_srli_si256(src, 4);                          \
  |  |  282|   105k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (282:12): [Folded, False: 105k]
  |  |  ------------------
  ------------------
  320|   105k|    DO_PRED12(diff_lo, 5);
  ------------------
  |  |  269|   105k|  do {                                                    \
  |  |  270|   105k|    const __m256i all = _mm256_add_epi16(L, (DIFF));      \
  |  |  271|   105k|    const __m256i alls = _mm256_packus_epi16(all, all);   \
  |  |  272|   105k|    const __m256i res = _mm256_add_epi8(src, alls);       \
  |  |  273|   105k|    out[i + (OUT)] = (uint32_t)_mm256_cvtsi256_si32(res); \
  |  |  274|   105k|    L = _mm256_unpacklo_epi8(res, zero);                  \
  |  |  275|   105k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (275:12): [Folded, False: 105k]
  |  |  ------------------
  ------------------
  321|   105k|    DO_PRED12_SHIFT(diff_lo, 1);
  ------------------
  |  |  278|   105k|  do {                                                        \
  |  |  279|   105k|    /* Shift the pre-computed value for the next iteration.*/ \
  |  |  280|   105k|    if ((LANE) == 0) (DIFF) = _mm256_srli_si256(DIFF, 8);     \
  |  |  ------------------
  |  |  |  Branch (280:9): [Folded, False: 105k]
  |  |  ------------------
  |  |  281|   105k|    src = _mm256_srli_si256(src, 4);                          \
  |  |  282|   105k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (282:12): [Folded, False: 105k]
  |  |  ------------------
  ------------------
  322|   105k|    DO_PRED12(diff_hi, 6);
  ------------------
  |  |  269|   105k|  do {                                                    \
  |  |  270|   105k|    const __m256i all = _mm256_add_epi16(L, (DIFF));      \
  |  |  271|   105k|    const __m256i alls = _mm256_packus_epi16(all, all);   \
  |  |  272|   105k|    const __m256i res = _mm256_add_epi8(src, alls);       \
  |  |  273|   105k|    out[i + (OUT)] = (uint32_t)_mm256_cvtsi256_si32(res); \
  |  |  274|   105k|    L = _mm256_unpacklo_epi8(res, zero);                  \
  |  |  275|   105k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (275:12): [Folded, False: 105k]
  |  |  ------------------
  ------------------
  323|   105k|    DO_PRED12_SHIFT(diff_hi, 0);
  ------------------
  |  |  278|   105k|  do {                                                        \
  |  |  279|   105k|    /* Shift the pre-computed value for the next iteration.*/ \
  |  |  280|   105k|    if ((LANE) == 0) (DIFF) = _mm256_srli_si256(DIFF, 8);     \
  |  |  ------------------
  |  |  |  Branch (280:9): [True: 105k, Folded]
  |  |  ------------------
  |  |  281|   105k|    src = _mm256_srli_si256(src, 4);                          \
  |  |  282|   105k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (282:12): [Folded, False: 105k]
  |  |  ------------------
  ------------------
  324|   105k|    DO_PRED12(diff_hi, 7);
  ------------------
  |  |  269|   105k|  do {                                                    \
  |  |  270|   105k|    const __m256i all = _mm256_add_epi16(L, (DIFF));      \
  |  |  271|   105k|    const __m256i alls = _mm256_packus_epi16(all, all);   \
  |  |  272|   105k|    const __m256i res = _mm256_add_epi8(src, alls);       \
  |  |  273|   105k|    out[i + (OUT)] = (uint32_t)_mm256_cvtsi256_si32(res); \
  |  |  274|   105k|    L = _mm256_unpacklo_epi8(res, zero);                  \
  |  |  275|   105k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (275:12): [Folded, False: 105k]
  |  |  ------------------
  ------------------
  325|   105k|  }
  326|  20.2k|  if (i != num_pixels) {
  ------------------
  |  Branch (326:7): [True: 17.1k, False: 3.10k]
  ------------------
  327|  17.1k|    VP8LPredictorsAdd_SSE[12](in + i, upper + i, num_pixels - i, out + i);
  328|  17.1k|  }
  329|  20.2k|}
lossless_avx2.c:AddGreenToBlueAndRed_AVX2:
  340|  8.74k|                                      uint32_t* dst) {
  341|  8.74k|  int i;
  342|  8.74k|  const __m256i kCstShuffle = _mm256_set_epi8(
  343|  8.74k|      -1, 29, -1, 29, -1, 25, -1, 25, -1, 21, -1, 21, -1, 17, -1, 17, -1, 13,
  344|  8.74k|      -1, 13, -1, 9, -1, 9, -1, 5, -1, 5, -1, 1, -1, 1);
  345|   262k|  for (i = 0; i + 8 <= num_pixels; i += 8) {
  ------------------
  |  Branch (345:15): [True: 253k, False: 8.74k]
  ------------------
  346|   253k|    const __m256i in = _mm256_loadu_si256((const __m256i*)&src[i]);  // argb
  347|   253k|    const __m256i in_0g0g = _mm256_shuffle_epi8(in, kCstShuffle);    // 0g0g
  348|   253k|    const __m256i out = _mm256_add_epi8(in, in_0g0g);
  349|   253k|    _mm256_storeu_si256((__m256i*)&dst[i], out);
  350|   253k|  }
  351|       |  // fallthrough and finish off with SSE.
  352|  8.74k|  if (i != num_pixels) {
  ------------------
  |  Branch (352:7): [True: 156, False: 8.58k]
  ------------------
  353|    156|    VP8LAddGreenToBlueAndRed_SSE(src + i, num_pixels - i, dst + i);
  354|    156|  }
  355|  8.74k|}
lossless_avx2.c:TransformColorInverse_AVX2:
  362|   277k|                                       int num_pixels, uint32_t* dst) {
  363|       |// sign-extended multiplying constants, pre-shifted by 5.
  364|   277k|#define CST(X) (((int16_t)(m->X << 8)) >> 5)  // sign-extend
  365|   277k|  const __m256i mults_rb = _mm256_set1_epi32(
  366|   277k|      (int)((uint32_t)CST(green_to_red) << 16 | (CST(green_to_blue) & 0xffff)));
  ------------------
  |  |  364|   277k|#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|   277k|#define CST(X) (((int16_t)(m->X << 8)) >> 5)  // sign-extend
  ------------------
  367|   277k|  const __m256i mults_b2 = _mm256_set1_epi32(CST(red_to_blue));
  ------------------
  |  |  364|   277k|#define CST(X) (((int16_t)(m->X << 8)) >> 5)  // sign-extend
  ------------------
  368|   277k|#undef CST
  369|   277k|  const __m256i mask_ag = _mm256_set1_epi32((int)0xff00ff00);
  370|   277k|  const __m256i perm1 = _mm256_setr_epi8(
  371|   277k|      -1, 1, -1, 1, -1, 5, -1, 5, -1, 9, -1, 9, -1, 13, -1, 13, -1, 17, -1, 17,
  372|   277k|      -1, 21, -1, 21, -1, 25, -1, 25, -1, 29, -1, 29);
  373|   277k|  const __m256i perm2 = _mm256_setr_epi8(
  374|   277k|      -1, 2, -1, -1, -1, 6, -1, -1, -1, 10, -1, -1, -1, 14, -1, -1, -1, 18, -1,
  375|   277k|      -1, -1, 22, -1, -1, -1, 26, -1, -1, -1, 30, -1, -1);
  376|   277k|  int i;
  377|   514k|  for (i = 0; i + 8 <= num_pixels; i += 8) {
  ------------------
  |  Branch (377:15): [True: 236k, False: 277k]
  ------------------
  378|   236k|    const __m256i A = _mm256_loadu_si256((const __m256i*)(src + i));
  379|   236k|    const __m256i B = _mm256_shuffle_epi8(A, perm1);  // argb -> g0g0
  380|   236k|    const __m256i C = _mm256_mulhi_epi16(B, mults_rb);
  381|   236k|    const __m256i D = _mm256_add_epi8(A, C);
  382|   236k|    const __m256i E = _mm256_shuffle_epi8(D, perm2);
  383|   236k|    const __m256i F = _mm256_mulhi_epi16(E, mults_b2);
  384|   236k|    const __m256i G = _mm256_add_epi8(D, F);
  385|   236k|    const __m256i out = _mm256_blendv_epi8(G, A, mask_ag);
  386|   236k|    _mm256_storeu_si256((__m256i*)&dst[i], out);
  387|   236k|  }
  388|       |  // Fall-back to SSE-version for left-overs.
  389|   277k|  if (i != num_pixels) {
  ------------------
  |  Branch (389:7): [True: 206k, False: 70.9k]
  ------------------
  390|   206k|    VP8LTransformColorInverse_SSE(m, src + i, num_pixels - i, dst + i);
  391|   206k|  }
  392|   277k|}
lossless_avx2.c:ConvertBGRAToRGBA_AVX2:
  398|   478k|                                   int num_pixels, uint8_t* WEBP_RESTRICT dst) {
  399|   478k|  const __m256i* in = (const __m256i*)src;
  400|   478k|  __m256i* out = (__m256i*)dst;
  401|   296M|  while (num_pixels >= 8) {
  ------------------
  |  Branch (401:10): [True: 296M, False: 478k]
  ------------------
  402|   296M|    const __m256i A = _mm256_loadu_si256(in++);
  403|   296M|    const __m256i B = _mm256_shuffle_epi8(
  404|   296M|        A,
  405|   296M|        _mm256_set_epi8(15, 12, 13, 14, 11, 8, 9, 10, 7, 4, 5, 6, 3, 0, 1, 2,
  406|   296M|                        15, 12, 13, 14, 11, 8, 9, 10, 7, 4, 5, 6, 3, 0, 1, 2));
  407|   296M|    _mm256_storeu_si256(out++, B);
  408|   296M|    num_pixels -= 8;
  409|   296M|  }
  410|       |  // left-overs
  411|   478k|  if (num_pixels > 0) {
  ------------------
  |  Branch (411:7): [True: 436k, False: 42.6k]
  ------------------
  412|   436k|    VP8LConvertBGRAToRGBA_SSE((const uint32_t*)in, num_pixels, (uint8_t*)out);
  413|   436k|  }
  414|   478k|}

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

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|   146k|                                const uint32_t* const top) {
  132|   146k|  const uint32_t pred = Average3_SSE2(*left, top[0], top[1]);
  133|   146k|  return pred;
  134|   146k|}
lossless_sse2.c:Average3_SSE2:
  110|   146k|                                          uint32_t a2) {
  111|   146k|  const __m128i zero = _mm_setzero_si128();
  112|   146k|  const __m128i avg1 = Average2_uint32_16_SSE2(a0, a2);
  113|   146k|  const __m128i A1 = _mm_unpacklo_epi8(_mm_cvtsi32_si128((int)a1), zero);
  114|   146k|  const __m128i sum = _mm_add_epi16(avg1, A1);
  115|   146k|  const __m128i avg2 = _mm_srli_epi16(sum, 1);
  116|   146k|  const __m128i A2 = _mm_packus_epi16(avg2, avg2);
  117|   146k|  return (uint32_t)_mm_cvtsi128_si32(A2);
  118|   146k|}
lossless_sse2.c:Average2_uint32_16_SSE2:
   95|   146k|static WEBP_INLINE __m128i Average2_uint32_16_SSE2(uint32_t a0, uint32_t a1) {
   96|   146k|  const __m128i zero = _mm_setzero_si128();
   97|   146k|  const __m128i A0 = _mm_unpacklo_epi8(_mm_cvtsi32_si128((int)a0), zero);
   98|   146k|  const __m128i A1 = _mm_unpacklo_epi8(_mm_cvtsi32_si128((int)a1), zero);
   99|   146k|  const __m128i sum = _mm_add_epi16(A1, A0);
  100|   146k|  return _mm_srli_epi16(sum, 1);
  101|   146k|}
lossless_sse2.c:Predictor6_SSE2:
  136|   304k|                                const uint32_t* const top) {
  137|   304k|  const uint32_t pred = Average2_SSE2(*left, top[-1]);
  138|   304k|  return pred;
  139|   304k|}
lossless_sse2.c:Average2_SSE2:
  103|   409k|static WEBP_INLINE uint32_t Average2_SSE2(uint32_t a0, uint32_t a1) {
  104|   409k|  __m128i output;
  105|   409k|  Average2_uint32_SSE2(a0, a1, &output);
  106|   409k|  return (uint32_t)_mm_cvtsi128_si32(output);
  107|   409k|}
lossless_sse2.c:Average2_uint32_SSE2:
   85|   409k|                                             __m128i* const avg) {
   86|       |  // (a + b) >> 1 = ((a + b + 1) >> 1) - ((a ^ b) & 1)
   87|   409k|  const __m128i ones = _mm_set1_epi8(1);
   88|   409k|  const __m128i A0 = _mm_cvtsi32_si128((int)a0);
   89|   409k|  const __m128i A1 = _mm_cvtsi32_si128((int)a1);
   90|   409k|  const __m128i avg1 = _mm_avg_epu8(A0, A1);
   91|   409k|  const __m128i one = _mm_and_si128(_mm_xor_si128(A0, A1), ones);
   92|   409k|  *avg = _mm_sub_epi8(avg1, one);
   93|   409k|}
lossless_sse2.c:Predictor7_SSE2:
  141|   105k|                                const uint32_t* const top) {
  142|   105k|  const uint32_t pred = Average2_SSE2(*left, top[0]);
  143|   105k|  return pred;
  144|   105k|}
lossless_sse2.c:Predictor13_SSE2:
  173|   178k|                                 const uint32_t* const top) {
  174|   178k|  const uint32_t pred = ClampedAddSubtractHalf_SSE2(*left, top[0], top[-1]);
  175|   178k|  return pred;
  176|   178k|}
lossless_sse2.c:ClampedAddSubtractHalf_SSE2:
   46|   178k|                                                        uint32_t c2) {
   47|   178k|  const __m128i zero = _mm_setzero_si128();
   48|   178k|  const __m128i C0 = _mm_unpacklo_epi8(_mm_cvtsi32_si128((int)c0), zero);
   49|   178k|  const __m128i C1 = _mm_unpacklo_epi8(_mm_cvtsi32_si128((int)c1), zero);
   50|   178k|  const __m128i B0 = _mm_unpacklo_epi8(_mm_cvtsi32_si128((int)c2), zero);
   51|   178k|  const __m128i avg = _mm_add_epi16(C1, C0);
   52|   178k|  const __m128i A0 = _mm_srli_epi16(avg, 1);
   53|   178k|  const __m128i A1 = _mm_sub_epi16(A0, B0);
   54|   178k|  const __m128i BgtA = _mm_cmpgt_epi16(B0, A0);
   55|   178k|  const __m128i A2 = _mm_sub_epi16(A1, BgtA);
   56|   178k|  const __m128i A3 = _mm_srai_epi16(A2, 1);
   57|   178k|  const __m128i A4 = _mm_add_epi16(A0, A3);
   58|   178k|  const __m128i A5 = _mm_packus_epi16(A4, A4);
   59|   178k|  return (uint32_t)_mm_cvtsi128_si32(A5);
   60|   178k|}
lossless_sse2.c:PredictorAdd0_SSE2:
  182|   125k|                               int num_pixels, uint32_t* WEBP_RESTRICT out) {
  183|   125k|  int i;
  184|   125k|  const __m128i black = _mm_set1_epi32((int)ARGB_BLACK);
  ------------------
  |  |   38|   125k|#define ARGB_BLACK 0xff000000
  ------------------
  185|   216k|  for (i = 0; i + 4 <= num_pixels; i += 4) {
  ------------------
  |  Branch (185:15): [True: 91.4k, False: 125k]
  ------------------
  186|  91.4k|    const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);
  187|  91.4k|    const __m128i res = _mm_add_epi8(src, black);
  188|  91.4k|    _mm_storeu_si128((__m128i*)&out[i], res);
  189|  91.4k|  }
  190|   125k|  if (i != num_pixels) {
  ------------------
  |  Branch (190:7): [True: 74.1k, False: 51.1k]
  ------------------
  191|       |    VP8LPredictorsAdd_C[0](in + i, NULL, num_pixels - i, out + i);
  192|  74.1k|  }
  193|   125k|  (void)upper;
  194|   125k|}
lossless_sse2.c:PredictorAdd1_SSE2:
  198|  31.4k|                               int num_pixels, uint32_t* WEBP_RESTRICT out) {
  199|  31.4k|  int i;
  200|  31.4k|  __m128i prev = _mm_set1_epi32((int)out[-1]);
  201|  56.0k|  for (i = 0; i + 4 <= num_pixels; i += 4) {
  ------------------
  |  Branch (201:15): [True: 24.6k, False: 31.4k]
  ------------------
  202|       |    // a | b | c | d
  203|  24.6k|    const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);
  204|       |    // 0 | a | b | c
  205|  24.6k|    const __m128i shift0 = _mm_slli_si128(src, 4);
  206|       |    // a | a + b | b + c | c + d
  207|  24.6k|    const __m128i sum0 = _mm_add_epi8(src, shift0);
  208|       |    // 0 | 0 | a | a + b
  209|  24.6k|    const __m128i shift1 = _mm_slli_si128(sum0, 8);
  210|       |    // a | a + b | a + b + c | a + b + c + d
  211|  24.6k|    const __m128i sum1 = _mm_add_epi8(sum0, shift1);
  212|  24.6k|    const __m128i res = _mm_add_epi8(sum1, prev);
  213|  24.6k|    _mm_storeu_si128((__m128i*)&out[i], res);
  214|       |    // replicate prev output on the four lanes
  215|  24.6k|    prev = _mm_shuffle_epi32(res, (3 << 0) | (3 << 2) | (3 << 4) | (3 << 6));
  216|  24.6k|  }
  217|  31.4k|  if (i != num_pixels) {
  ------------------
  |  Branch (217:7): [True: 14.2k, False: 17.2k]
  ------------------
  218|  14.2k|    VP8LPredictorsAdd_C[1](in + i, upper + i, num_pixels - i, out + i);
  219|  14.2k|  }
  220|  31.4k|}
lossless_sse2.c:PredictorAdd2_SSE2:
  227|  3.81k|                                     uint32_t* WEBP_RESTRICT out) {         \
  228|  3.81k|    int i;                                                                  \
  229|  6.45k|    for (i = 0; i + 4 <= num_pixels; i += 4) {                              \
  ------------------
  |  Branch (229:17): [True: 2.63k, False: 3.81k]
  ------------------
  230|  2.63k|      const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);          \
  231|  2.63k|      const __m128i other = _mm_loadu_si128((const __m128i*)&(IN));         \
  232|  2.63k|      const __m128i res = _mm_add_epi8(src, other);                         \
  233|  2.63k|      _mm_storeu_si128((__m128i*)&out[i], res);                             \
  234|  2.63k|    }                                                                       \
  235|  3.81k|    if (i != num_pixels) {                                                  \
  ------------------
  |  Branch (235:9): [True: 3.18k, False: 631]
  ------------------
  236|  3.18k|      VP8LPredictorsAdd_C[(X)](in + i, upper + i, num_pixels - i, out + i); \
  237|  3.18k|    }                                                                       \
  238|  3.81k|  }
lossless_sse2.c:PredictorAdd3_SSE2:
  227|  4.86k|                                     uint32_t* WEBP_RESTRICT out) {         \
  228|  4.86k|    int i;                                                                  \
  229|  8.29k|    for (i = 0; i + 4 <= num_pixels; i += 4) {                              \
  ------------------
  |  Branch (229:17): [True: 3.42k, False: 4.86k]
  ------------------
  230|  3.42k|      const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);          \
  231|  3.42k|      const __m128i other = _mm_loadu_si128((const __m128i*)&(IN));         \
  232|  3.42k|      const __m128i res = _mm_add_epi8(src, other);                         \
  233|  3.42k|      _mm_storeu_si128((__m128i*)&out[i], res);                             \
  234|  3.42k|    }                                                                       \
  235|  4.86k|    if (i != num_pixels) {                                                  \
  ------------------
  |  Branch (235:9): [True: 3.72k, False: 1.14k]
  ------------------
  236|  3.72k|      VP8LPredictorsAdd_C[(X)](in + i, upper + i, num_pixels - i, out + i); \
  237|  3.72k|    }                                                                       \
  238|  4.86k|  }
lossless_sse2.c:PredictorAdd4_SSE2:
  227|  4.47k|                                     uint32_t* WEBP_RESTRICT out) {         \
  228|  4.47k|    int i;                                                                  \
  229|  7.65k|    for (i = 0; i + 4 <= num_pixels; i += 4) {                              \
  ------------------
  |  Branch (229:17): [True: 3.18k, False: 4.47k]
  ------------------
  230|  3.18k|      const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);          \
  231|  3.18k|      const __m128i other = _mm_loadu_si128((const __m128i*)&(IN));         \
  232|  3.18k|      const __m128i res = _mm_add_epi8(src, other);                         \
  233|  3.18k|      _mm_storeu_si128((__m128i*)&out[i], res);                             \
  234|  3.18k|    }                                                                       \
  235|  4.47k|    if (i != num_pixels) {                                                  \
  ------------------
  |  Branch (235:9): [True: 3.39k, False: 1.07k]
  ------------------
  236|  3.39k|      VP8LPredictorsAdd_C[(X)](in + i, upper + i, num_pixels - i, out + i); \
  237|  3.39k|    }                                                                       \
  238|  4.47k|  }
lossless_sse2.c:PredictorAdd8_SSE2:
  257|  5.23k|                                     uint32_t* WEBP_RESTRICT out) {         \
  258|  5.23k|    int i;                                                                  \
  259|  7.74k|    for (i = 0; i + 4 <= num_pixels; i += 4) {                              \
  ------------------
  |  Branch (259:17): [True: 2.51k, False: 5.23k]
  ------------------
  260|  2.51k|      const __m128i Tother = _mm_loadu_si128((const __m128i*)&(IN));        \
  261|  2.51k|      const __m128i T = _mm_loadu_si128((const __m128i*)&upper[i]);         \
  262|  2.51k|      const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);          \
  263|  2.51k|      __m128i avg, res;                                                     \
  264|  2.51k|      Average2_m128i(&T, &Tother, &avg);                                    \
  265|  2.51k|      res = _mm_add_epi8(avg, src);                                         \
  266|  2.51k|      _mm_storeu_si128((__m128i*)&out[i], res);                             \
  267|  2.51k|    }                                                                       \
  268|  5.23k|    if (i != num_pixels) {                                                  \
  ------------------
  |  Branch (268:9): [True: 4.67k, False: 558]
  ------------------
  269|  4.67k|      VP8LPredictorsAdd_C[(X)](in + i, upper + i, num_pixels - i, out + i); \
  270|  4.67k|    }                                                                       \
  271|  5.23k|  }
lossless_sse2.c:Average2_m128i:
   75|  58.6k|                                       __m128i* const avg) {
   76|       |  // (a + b) >> 1 = ((a + b + 1) >> 1) - ((a ^ b) & 1)
   77|  58.6k|  const __m128i ones = _mm_set1_epi8(1);
   78|  58.6k|  const __m128i avg1 = _mm_avg_epu8(*a0, *a1);
   79|  58.6k|  const __m128i one = _mm_and_si128(_mm_xor_si128(*a0, *a1), ones);
   80|  58.6k|  *avg = _mm_sub_epi8(avg1, one);
   81|  58.6k|}
lossless_sse2.c:PredictorAdd9_SSE2:
  257|  7.51k|                                     uint32_t* WEBP_RESTRICT out) {         \
  258|  7.51k|    int i;                                                                  \
  259|  12.0k|    for (i = 0; i + 4 <= num_pixels; i += 4) {                              \
  ------------------
  |  Branch (259:17): [True: 4.48k, False: 7.51k]
  ------------------
  260|  4.48k|      const __m128i Tother = _mm_loadu_si128((const __m128i*)&(IN));        \
  261|  4.48k|      const __m128i T = _mm_loadu_si128((const __m128i*)&upper[i]);         \
  262|  4.48k|      const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);          \
  263|  4.48k|      __m128i avg, res;                                                     \
  264|  4.48k|      Average2_m128i(&T, &Tother, &avg);                                    \
  265|  4.48k|      res = _mm_add_epi8(avg, src);                                         \
  266|  4.48k|      _mm_storeu_si128((__m128i*)&out[i], res);                             \
  267|  4.48k|    }                                                                       \
  268|  7.51k|    if (i != num_pixels) {                                                  \
  ------------------
  |  Branch (268:9): [True: 6.20k, False: 1.31k]
  ------------------
  269|  6.20k|      VP8LPredictorsAdd_C[(X)](in + i, upper + i, num_pixels - i, out + i); \
  270|  6.20k|    }                                                                       \
  271|  7.51k|  }
lossless_sse2.c:PredictorAdd10_SSE2:
  297|  7.55k|                                int num_pixels, uint32_t* WEBP_RESTRICT out) {
  298|  7.55k|  int i;
  299|  7.55k|  __m128i L = _mm_cvtsi32_si128((int)out[-1]);
  300|  13.2k|  for (i = 0; i + 4 <= num_pixels; i += 4) {
  ------------------
  |  Branch (300:15): [True: 5.73k, False: 7.55k]
  ------------------
  301|  5.73k|    __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);
  302|  5.73k|    __m128i TL = _mm_loadu_si128((const __m128i*)&upper[i - 1]);
  303|  5.73k|    const __m128i T = _mm_loadu_si128((const __m128i*)&upper[i]);
  304|  5.73k|    const __m128i TR = _mm_loadu_si128((const __m128i*)&upper[i + 1]);
  305|  5.73k|    __m128i avgTTR;
  306|  5.73k|    Average2_m128i(&T, &TR, &avgTTR);
  307|  5.73k|    DO_PRED10(0);
  ------------------
  |  |  280|  5.73k|  do {                                               \
  |  |  281|  5.73k|    __m128i avgLTL, avg;                             \
  |  |  282|  5.73k|    Average2_m128i(&L, &TL, &avgLTL);                \
  |  |  283|  5.73k|    Average2_m128i(&avgTTR, &avgLTL, &avg);          \
  |  |  284|  5.73k|    L = _mm_add_epi8(avg, src);                      \
  |  |  285|  5.73k|    out[i + (OUT)] = (uint32_t)_mm_cvtsi128_si32(L); \
  |  |  286|  5.73k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (286:12): [Folded, False: 5.73k]
  |  |  ------------------
  ------------------
  308|  5.73k|    DO_PRED10_SHIFT;
  ------------------
  |  |  289|  5.73k|  do {                                                          \
  |  |  290|  5.73k|    /* Rotate the pre-computed values for the next iteration.*/ \
  |  |  291|  5.73k|    avgTTR = _mm_srli_si128(avgTTR, 4);                         \
  |  |  292|  5.73k|    TL = _mm_srli_si128(TL, 4);                                 \
  |  |  293|  5.73k|    src = _mm_srli_si128(src, 4);                               \
  |  |  294|  5.73k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (294:12): [Folded, False: 5.73k]
  |  |  ------------------
  ------------------
  309|  5.73k|    DO_PRED10(1);
  ------------------
  |  |  280|  5.73k|  do {                                               \
  |  |  281|  5.73k|    __m128i avgLTL, avg;                             \
  |  |  282|  5.73k|    Average2_m128i(&L, &TL, &avgLTL);                \
  |  |  283|  5.73k|    Average2_m128i(&avgTTR, &avgLTL, &avg);          \
  |  |  284|  5.73k|    L = _mm_add_epi8(avg, src);                      \
  |  |  285|  5.73k|    out[i + (OUT)] = (uint32_t)_mm_cvtsi128_si32(L); \
  |  |  286|  5.73k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (286:12): [Folded, False: 5.73k]
  |  |  ------------------
  ------------------
  310|  5.73k|    DO_PRED10_SHIFT;
  ------------------
  |  |  289|  5.73k|  do {                                                          \
  |  |  290|  5.73k|    /* Rotate the pre-computed values for the next iteration.*/ \
  |  |  291|  5.73k|    avgTTR = _mm_srli_si128(avgTTR, 4);                         \
  |  |  292|  5.73k|    TL = _mm_srli_si128(TL, 4);                                 \
  |  |  293|  5.73k|    src = _mm_srli_si128(src, 4);                               \
  |  |  294|  5.73k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (294:12): [Folded, False: 5.73k]
  |  |  ------------------
  ------------------
  311|  5.73k|    DO_PRED10(2);
  ------------------
  |  |  280|  5.73k|  do {                                               \
  |  |  281|  5.73k|    __m128i avgLTL, avg;                             \
  |  |  282|  5.73k|    Average2_m128i(&L, &TL, &avgLTL);                \
  |  |  283|  5.73k|    Average2_m128i(&avgTTR, &avgLTL, &avg);          \
  |  |  284|  5.73k|    L = _mm_add_epi8(avg, src);                      \
  |  |  285|  5.73k|    out[i + (OUT)] = (uint32_t)_mm_cvtsi128_si32(L); \
  |  |  286|  5.73k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (286:12): [Folded, False: 5.73k]
  |  |  ------------------
  ------------------
  312|  5.73k|    DO_PRED10_SHIFT;
  ------------------
  |  |  289|  5.73k|  do {                                                          \
  |  |  290|  5.73k|    /* Rotate the pre-computed values for the next iteration.*/ \
  |  |  291|  5.73k|    avgTTR = _mm_srli_si128(avgTTR, 4);                         \
  |  |  292|  5.73k|    TL = _mm_srli_si128(TL, 4);                                 \
  |  |  293|  5.73k|    src = _mm_srli_si128(src, 4);                               \
  |  |  294|  5.73k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (294:12): [Folded, False: 5.73k]
  |  |  ------------------
  ------------------
  313|  5.73k|    DO_PRED10(3);
  ------------------
  |  |  280|  5.73k|  do {                                               \
  |  |  281|  5.73k|    __m128i avgLTL, avg;                             \
  |  |  282|  5.73k|    Average2_m128i(&L, &TL, &avgLTL);                \
  |  |  283|  5.73k|    Average2_m128i(&avgTTR, &avgLTL, &avg);          \
  |  |  284|  5.73k|    L = _mm_add_epi8(avg, src);                      \
  |  |  285|  5.73k|    out[i + (OUT)] = (uint32_t)_mm_cvtsi128_si32(L); \
  |  |  286|  5.73k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (286:12): [Folded, False: 5.73k]
  |  |  ------------------
  ------------------
  314|  5.73k|  }
  315|  7.55k|  if (i != num_pixels) {
  ------------------
  |  Branch (315:7): [True: 5.57k, False: 1.97k]
  ------------------
  316|  5.57k|    VP8LPredictorsAdd_C[10](in + i, upper + i, num_pixels - i, out + i);
  317|  5.57k|  }
  318|  7.55k|}
lossless_sse2.c:PredictorAdd11_SSE2:
  346|  7.15k|                                int num_pixels, uint32_t* WEBP_RESTRICT out) {
  347|  7.15k|  int i;
  348|  7.15k|  __m128i pa;
  349|  7.15k|  __m128i L = _mm_cvtsi32_si128((int)out[-1]);
  350|  11.8k|  for (i = 0; i + 4 <= num_pixels; i += 4) {
  ------------------
  |  Branch (350:15): [True: 4.72k, False: 7.15k]
  ------------------
  351|  4.72k|    __m128i T = _mm_loadu_si128((const __m128i*)&upper[i]);
  352|  4.72k|    __m128i TL = _mm_loadu_si128((const __m128i*)&upper[i - 1]);
  353|  4.72k|    __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);
  354|  4.72k|    {
  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|  4.72k|      const __m128i T_lo = _mm_unpacklo_epi32(T, T);
  359|  4.72k|      const __m128i TL_lo = _mm_unpacklo_epi32(TL, T);
  360|  4.72k|      const __m128i T_hi = _mm_unpackhi_epi32(T, T);
  361|  4.72k|      const __m128i TL_hi = _mm_unpackhi_epi32(TL, T);
  362|  4.72k|      const __m128i s_lo = _mm_sad_epu8(T_lo, TL_lo);
  363|  4.72k|      const __m128i s_hi = _mm_sad_epu8(T_hi, TL_hi);
  364|  4.72k|      pa = _mm_packs_epi32(s_lo, s_hi);  // pa = sum |T-TL|
  365|  4.72k|    }
  366|  4.72k|    DO_PRED11(0);
  ------------------
  |  |  324|  4.72k|  do {                                                                   \
  |  |  325|  4.72k|    const __m128i L_lo = _mm_unpacklo_epi32(L, T);                       \
  |  |  326|  4.72k|    const __m128i TL_lo = _mm_unpacklo_epi32(TL, T);                     \
  |  |  327|  4.72k|    const __m128i pb = _mm_sad_epu8(L_lo, TL_lo); /* pb = sum |L-TL|*/   \
  |  |  328|  4.72k|    const __m128i mask = _mm_cmpgt_epi32(pb, pa);                        \
  |  |  329|  4.72k|    const __m128i A = _mm_and_si128(mask, L);                            \
  |  |  330|  4.72k|    const __m128i B = _mm_andnot_si128(mask, T);                         \
  |  |  331|  4.72k|    const __m128i pred = _mm_or_si128(A, B); /* pred = (pa > b)? L : T*/ \
  |  |  332|  4.72k|    L = _mm_add_epi8(src, pred);                                         \
  |  |  333|  4.72k|    out[i + (OUT)] = (uint32_t)_mm_cvtsi128_si32(L);                     \
  |  |  334|  4.72k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (334:12): [Folded, False: 4.72k]
  |  |  ------------------
  ------------------
  367|  4.72k|    DO_PRED11_SHIFT;
  ------------------
  |  |  337|  4.72k|  do {                                                        \
  |  |  338|  4.72k|    /* Shift the pre-computed value for the next iteration.*/ \
  |  |  339|  4.72k|    T = _mm_srli_si128(T, 4);                                 \
  |  |  340|  4.72k|    TL = _mm_srli_si128(TL, 4);                               \
  |  |  341|  4.72k|    src = _mm_srli_si128(src, 4);                             \
  |  |  342|  4.72k|    pa = _mm_srli_si128(pa, 4);                               \
  |  |  343|  4.72k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (343:12): [Folded, False: 4.72k]
  |  |  ------------------
  ------------------
  368|  4.72k|    DO_PRED11(1);
  ------------------
  |  |  324|  4.72k|  do {                                                                   \
  |  |  325|  4.72k|    const __m128i L_lo = _mm_unpacklo_epi32(L, T);                       \
  |  |  326|  4.72k|    const __m128i TL_lo = _mm_unpacklo_epi32(TL, T);                     \
  |  |  327|  4.72k|    const __m128i pb = _mm_sad_epu8(L_lo, TL_lo); /* pb = sum |L-TL|*/   \
  |  |  328|  4.72k|    const __m128i mask = _mm_cmpgt_epi32(pb, pa);                        \
  |  |  329|  4.72k|    const __m128i A = _mm_and_si128(mask, L);                            \
  |  |  330|  4.72k|    const __m128i B = _mm_andnot_si128(mask, T);                         \
  |  |  331|  4.72k|    const __m128i pred = _mm_or_si128(A, B); /* pred = (pa > b)? L : T*/ \
  |  |  332|  4.72k|    L = _mm_add_epi8(src, pred);                                         \
  |  |  333|  4.72k|    out[i + (OUT)] = (uint32_t)_mm_cvtsi128_si32(L);                     \
  |  |  334|  4.72k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (334:12): [Folded, False: 4.72k]
  |  |  ------------------
  ------------------
  369|  4.72k|    DO_PRED11_SHIFT;
  ------------------
  |  |  337|  4.72k|  do {                                                        \
  |  |  338|  4.72k|    /* Shift the pre-computed value for the next iteration.*/ \
  |  |  339|  4.72k|    T = _mm_srli_si128(T, 4);                                 \
  |  |  340|  4.72k|    TL = _mm_srli_si128(TL, 4);                               \
  |  |  341|  4.72k|    src = _mm_srli_si128(src, 4);                             \
  |  |  342|  4.72k|    pa = _mm_srli_si128(pa, 4);                               \
  |  |  343|  4.72k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (343:12): [Folded, False: 4.72k]
  |  |  ------------------
  ------------------
  370|  4.72k|    DO_PRED11(2);
  ------------------
  |  |  324|  4.72k|  do {                                                                   \
  |  |  325|  4.72k|    const __m128i L_lo = _mm_unpacklo_epi32(L, T);                       \
  |  |  326|  4.72k|    const __m128i TL_lo = _mm_unpacklo_epi32(TL, T);                     \
  |  |  327|  4.72k|    const __m128i pb = _mm_sad_epu8(L_lo, TL_lo); /* pb = sum |L-TL|*/   \
  |  |  328|  4.72k|    const __m128i mask = _mm_cmpgt_epi32(pb, pa);                        \
  |  |  329|  4.72k|    const __m128i A = _mm_and_si128(mask, L);                            \
  |  |  330|  4.72k|    const __m128i B = _mm_andnot_si128(mask, T);                         \
  |  |  331|  4.72k|    const __m128i pred = _mm_or_si128(A, B); /* pred = (pa > b)? L : T*/ \
  |  |  332|  4.72k|    L = _mm_add_epi8(src, pred);                                         \
  |  |  333|  4.72k|    out[i + (OUT)] = (uint32_t)_mm_cvtsi128_si32(L);                     \
  |  |  334|  4.72k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (334:12): [Folded, False: 4.72k]
  |  |  ------------------
  ------------------
  371|  4.72k|    DO_PRED11_SHIFT;
  ------------------
  |  |  337|  4.72k|  do {                                                        \
  |  |  338|  4.72k|    /* Shift the pre-computed value for the next iteration.*/ \
  |  |  339|  4.72k|    T = _mm_srli_si128(T, 4);                                 \
  |  |  340|  4.72k|    TL = _mm_srli_si128(TL, 4);                               \
  |  |  341|  4.72k|    src = _mm_srli_si128(src, 4);                             \
  |  |  342|  4.72k|    pa = _mm_srli_si128(pa, 4);                               \
  |  |  343|  4.72k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (343:12): [Folded, False: 4.72k]
  |  |  ------------------
  ------------------
  372|  4.72k|    DO_PRED11(3);
  ------------------
  |  |  324|  4.72k|  do {                                                                   \
  |  |  325|  4.72k|    const __m128i L_lo = _mm_unpacklo_epi32(L, T);                       \
  |  |  326|  4.72k|    const __m128i TL_lo = _mm_unpacklo_epi32(TL, T);                     \
  |  |  327|  4.72k|    const __m128i pb = _mm_sad_epu8(L_lo, TL_lo); /* pb = sum |L-TL|*/   \
  |  |  328|  4.72k|    const __m128i mask = _mm_cmpgt_epi32(pb, pa);                        \
  |  |  329|  4.72k|    const __m128i A = _mm_and_si128(mask, L);                            \
  |  |  330|  4.72k|    const __m128i B = _mm_andnot_si128(mask, T);                         \
  |  |  331|  4.72k|    const __m128i pred = _mm_or_si128(A, B); /* pred = (pa > b)? L : T*/ \
  |  |  332|  4.72k|    L = _mm_add_epi8(src, pred);                                         \
  |  |  333|  4.72k|    out[i + (OUT)] = (uint32_t)_mm_cvtsi128_si32(L);                     \
  |  |  334|  4.72k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (334:12): [Folded, False: 4.72k]
  |  |  ------------------
  ------------------
  373|  4.72k|  }
  374|  7.15k|  if (i != num_pixels) {
  ------------------
  |  Branch (374:7): [True: 5.92k, False: 1.23k]
  ------------------
  375|  5.92k|    VP8LPredictorsAdd_C[11](in + i, upper + i, num_pixels - i, out + i);
  376|  5.92k|  }
  377|  7.15k|}
lossless_sse2.c:PredictorAdd12_SSE2:
  399|  17.1k|                                int num_pixels, uint32_t* WEBP_RESTRICT out) {
  400|  17.1k|  int i;
  401|  17.1k|  const __m128i zero = _mm_setzero_si128();
  402|  17.1k|  const __m128i L8 = _mm_cvtsi32_si128((int)out[-1]);
  403|  17.1k|  __m128i L = _mm_unpacklo_epi8(L8, zero);
  404|  30.2k|  for (i = 0; i + 4 <= num_pixels; i += 4) {
  ------------------
  |  Branch (404:15): [True: 13.1k, False: 17.1k]
  ------------------
  405|       |    // Load 4 pixels at a time.
  406|  13.1k|    __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);
  407|  13.1k|    const __m128i T = _mm_loadu_si128((const __m128i*)&upper[i]);
  408|  13.1k|    const __m128i T_lo = _mm_unpacklo_epi8(T, zero);
  409|  13.1k|    const __m128i T_hi = _mm_unpackhi_epi8(T, zero);
  410|  13.1k|    const __m128i TL = _mm_loadu_si128((const __m128i*)&upper[i - 1]);
  411|  13.1k|    const __m128i TL_lo = _mm_unpacklo_epi8(TL, zero);
  412|  13.1k|    const __m128i TL_hi = _mm_unpackhi_epi8(TL, zero);
  413|  13.1k|    __m128i diff_lo = _mm_sub_epi16(T_lo, TL_lo);
  414|  13.1k|    __m128i diff_hi = _mm_sub_epi16(T_hi, TL_hi);
  415|  13.1k|    DO_PRED12(diff_lo, 0, 0);
  ------------------
  |  |  383|  13.1k|  do {                                                 \
  |  |  384|  13.1k|    const __m128i all = _mm_add_epi16(L, (DIFF));      \
  |  |  385|  13.1k|    const __m128i alls = _mm_packus_epi16(all, all);   \
  |  |  386|  13.1k|    const __m128i res = _mm_add_epi8(src, alls);       \
  |  |  387|  13.1k|    out[i + (OUT)] = (uint32_t)_mm_cvtsi128_si32(res); \
  |  |  388|  13.1k|    L = _mm_unpacklo_epi8(res, zero);                  \
  |  |  389|  13.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (389:12): [Folded, False: 13.1k]
  |  |  ------------------
  ------------------
  416|  13.1k|    DO_PRED12_SHIFT(diff_lo, 0);
  ------------------
  |  |  392|  13.1k|  do {                                                        \
  |  |  393|  13.1k|    /* Shift the pre-computed value for the next iteration.*/ \
  |  |  394|  13.1k|    if ((LANE) == 0) (DIFF) = _mm_srli_si128((DIFF), 8);      \
  |  |  ------------------
  |  |  |  Branch (394:9): [True: 13.1k, Folded]
  |  |  ------------------
  |  |  395|  13.1k|    src = _mm_srli_si128(src, 4);                             \
  |  |  396|  13.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (396:12): [Folded, False: 13.1k]
  |  |  ------------------
  ------------------
  417|  13.1k|    DO_PRED12(diff_lo, 1, 1);
  ------------------
  |  |  383|  13.1k|  do {                                                 \
  |  |  384|  13.1k|    const __m128i all = _mm_add_epi16(L, (DIFF));      \
  |  |  385|  13.1k|    const __m128i alls = _mm_packus_epi16(all, all);   \
  |  |  386|  13.1k|    const __m128i res = _mm_add_epi8(src, alls);       \
  |  |  387|  13.1k|    out[i + (OUT)] = (uint32_t)_mm_cvtsi128_si32(res); \
  |  |  388|  13.1k|    L = _mm_unpacklo_epi8(res, zero);                  \
  |  |  389|  13.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (389:12): [Folded, False: 13.1k]
  |  |  ------------------
  ------------------
  418|  13.1k|    DO_PRED12_SHIFT(diff_lo, 1);
  ------------------
  |  |  392|  13.1k|  do {                                                        \
  |  |  393|  13.1k|    /* Shift the pre-computed value for the next iteration.*/ \
  |  |  394|  13.1k|    if ((LANE) == 0) (DIFF) = _mm_srli_si128((DIFF), 8);      \
  |  |  ------------------
  |  |  |  Branch (394:9): [Folded, False: 13.1k]
  |  |  ------------------
  |  |  395|  13.1k|    src = _mm_srli_si128(src, 4);                             \
  |  |  396|  13.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (396:12): [Folded, False: 13.1k]
  |  |  ------------------
  ------------------
  419|  13.1k|    DO_PRED12(diff_hi, 0, 2);
  ------------------
  |  |  383|  13.1k|  do {                                                 \
  |  |  384|  13.1k|    const __m128i all = _mm_add_epi16(L, (DIFF));      \
  |  |  385|  13.1k|    const __m128i alls = _mm_packus_epi16(all, all);   \
  |  |  386|  13.1k|    const __m128i res = _mm_add_epi8(src, alls);       \
  |  |  387|  13.1k|    out[i + (OUT)] = (uint32_t)_mm_cvtsi128_si32(res); \
  |  |  388|  13.1k|    L = _mm_unpacklo_epi8(res, zero);                  \
  |  |  389|  13.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (389:12): [Folded, False: 13.1k]
  |  |  ------------------
  ------------------
  420|  13.1k|    DO_PRED12_SHIFT(diff_hi, 0);
  ------------------
  |  |  392|  13.1k|  do {                                                        \
  |  |  393|  13.1k|    /* Shift the pre-computed value for the next iteration.*/ \
  |  |  394|  13.1k|    if ((LANE) == 0) (DIFF) = _mm_srli_si128((DIFF), 8);      \
  |  |  ------------------
  |  |  |  Branch (394:9): [True: 13.1k, Folded]
  |  |  ------------------
  |  |  395|  13.1k|    src = _mm_srli_si128(src, 4);                             \
  |  |  396|  13.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (396:12): [Folded, False: 13.1k]
  |  |  ------------------
  ------------------
  421|  13.1k|    DO_PRED12(diff_hi, 1, 3);
  ------------------
  |  |  383|  13.1k|  do {                                                 \
  |  |  384|  13.1k|    const __m128i all = _mm_add_epi16(L, (DIFF));      \
  |  |  385|  13.1k|    const __m128i alls = _mm_packus_epi16(all, all);   \
  |  |  386|  13.1k|    const __m128i res = _mm_add_epi8(src, alls);       \
  |  |  387|  13.1k|    out[i + (OUT)] = (uint32_t)_mm_cvtsi128_si32(res); \
  |  |  388|  13.1k|    L = _mm_unpacklo_epi8(res, zero);                  \
  |  |  389|  13.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (389:12): [Folded, False: 13.1k]
  |  |  ------------------
  ------------------
  422|  13.1k|  }
  423|  17.1k|  if (i != num_pixels) {
  ------------------
  |  Branch (423:7): [True: 10.3k, False: 6.79k]
  ------------------
  424|  10.3k|    VP8LPredictorsAdd_C[12](in + i, upper + i, num_pixels - i, out + i);
  425|  10.3k|  }
  426|  17.1k|}
lossless_sse2.c:AddGreenToBlueAndRed_SSE2:
  438|    156|                                      uint32_t* dst) {
  439|    156|  int i;
  440|    264|  for (i = 0; i + 4 <= num_pixels; i += 4) {
  ------------------
  |  Branch (440:15): [True: 108, False: 156]
  ------------------
  441|    108|    const __m128i in = _mm_loadu_si128((const __m128i*)&src[i]);  // argb
  442|    108|    const __m128i A = _mm_srli_epi16(in, 8);                      // 0 a 0 g
  443|    108|    const __m128i B = _mm_shufflelo_epi16(A, _MM_SHUFFLE(2, 2, 0, 0));
  444|    108|    const __m128i C = _mm_shufflehi_epi16(B, _MM_SHUFFLE(2, 2, 0, 0));  // 0g0g
  445|    108|    const __m128i out = _mm_add_epi8(in, C);
  446|    108|    _mm_storeu_si128((__m128i*)&dst[i], out);
  447|    108|  }
  448|       |  // fallthrough and finish off with plain-C
  449|    156|  if (i != num_pixels) {
  ------------------
  |  Branch (449:7): [True: 105, False: 51]
  ------------------
  450|    105|    VP8LAddGreenToBlueAndRed_C(src + i, num_pixels - i, dst + i);
  451|    105|  }
  452|    156|}
lossless_sse2.c:ConvertBGRAToRGBA_SSE2:
  531|   436k|                                   int num_pixels, uint8_t* WEBP_RESTRICT dst) {
  532|   436k|  const __m128i red_blue_mask = _mm_set1_epi32(0x00ff00ff);
  533|   436k|  const __m128i* in = (const __m128i*)src;
  534|   436k|  __m128i* out = (__m128i*)dst;
  535|   436k|  while (num_pixels >= 8) {
  ------------------
  |  Branch (535:10): [True: 0, False: 436k]
  ------------------
  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|   436k|  if (num_pixels > 0) {
  ------------------
  |  Branch (553:7): [True: 436k, False: 0]
  ------------------
  554|   436k|    VP8LConvertBGRAToRGBA_C((const uint32_t*)in, num_pixels, (uint8_t*)out);
  555|   436k|  }
  556|   436k|}

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|   206k|                                        int num_pixels, uint32_t* dst) {
   28|       |// sign-extended multiplying constants, pre-shifted by 5.
   29|   206k|#define CST(X) (((int16_t)(m->X << 8)) >> 5)  // sign-extend
   30|   206k|  const __m128i mults_rb = _mm_set1_epi32(
   31|   206k|      (int)((uint32_t)CST(green_to_red) << 16 | (CST(green_to_blue) & 0xffff)));
  ------------------
  |  |   29|   206k|#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|   206k|#define CST(X) (((int16_t)(m->X << 8)) >> 5)  // sign-extend
  ------------------
   32|   206k|  const __m128i mults_b2 = _mm_set1_epi32(CST(red_to_blue));
  ------------------
  |  |   29|   206k|#define CST(X) (((int16_t)(m->X << 8)) >> 5)  // sign-extend
  ------------------
   33|   206k|#undef CST
   34|   206k|  const __m128i mask_ag = _mm_set1_epi32((int)0xff00ff00);
   35|   206k|  const __m128i perm1 =
   36|   206k|      _mm_setr_epi8(-1, 1, -1, 1, -1, 5, -1, 5, -1, 9, -1, 9, -1, 13, -1, 13);
   37|   206k|  const __m128i perm2 = _mm_setr_epi8(-1, 2, -1, -1, -1, 6, -1, -1, -1, 10, -1,
   38|   206k|                                      -1, -1, 14, -1, -1);
   39|   206k|  int i;
   40|   392k|  for (i = 0; i + 4 <= num_pixels; i += 4) {
  ------------------
  |  Branch (40:15): [True: 185k, False: 206k]
  ------------------
   41|   185k|    const __m128i A = _mm_loadu_si128((const __m128i*)(src + i));
   42|   185k|    const __m128i B = _mm_shuffle_epi8(A, perm1);  // argb -> g0g0
   43|   185k|    const __m128i C = _mm_mulhi_epi16(B, mults_rb);
   44|   185k|    const __m128i D = _mm_add_epi8(A, C);
   45|   185k|    const __m128i E = _mm_shuffle_epi8(D, perm2);
   46|   185k|    const __m128i F = _mm_mulhi_epi16(E, mults_b2);
   47|   185k|    const __m128i G = _mm_add_epi8(D, F);
   48|   185k|    const __m128i out = _mm_blendv_epi8(G, A, mask_ag);
   49|   185k|    _mm_storeu_si128((__m128i*)&dst[i], out);
   50|   185k|  }
   51|       |  // Fall-back to C-version for left-overs.
   52|   206k|  if (i != num_pixels) {
  ------------------
  |  Branch (52:7): [True: 40.0k, False: 166k]
  ------------------
   53|  40.0k|    VP8LTransformColorInverse_C(m, src + i, num_pixels - i, dst + i);
   54|  40.0k|  }
   55|   206k|}

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

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|}

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|}

upsampling_sse2.c:VP8YuvToRgba:
  152|   480k|                                     uint8_t* const rgba) {
  153|   480k|  VP8YuvToRgb(y, u, v, rgba);
  154|   480k|  rgba[3] = 0xff;
  155|   480k|}
upsampling_sse2.c:VP8YuvToRgb:
   92|   480k|static WEBP_INLINE void VP8YuvToRgb(int y, int u, int v, uint8_t* const rgb) {
   93|   480k|  rgb[0] = VP8YUVToR(y, v);
   94|   480k|  rgb[1] = VP8YUVToG(y, u, v);
   95|   480k|  rgb[2] = VP8YUVToB(y, u);
   96|   480k|}
upsampling_sse2.c:VP8YUVToR:
   80|   480k|static WEBP_INLINE int VP8YUVToR(int y, int v) {
   81|   480k|  return VP8Clip8(MultHi(y, 19077) + MultHi(v, 26149) - 14234);
   82|   480k|}
upsampling_sse2.c:VP8Clip8:
   76|  1.44M|static WEBP_INLINE int VP8Clip8(int v) {
   77|  1.44M|  return ((v & ~YUV_MASK2) == 0) ? (v >> YUV_FIX2) : (v < 0) ? 0 : 255;
  ------------------
  |  Branch (77:10): [True: 1.33M, False: 102k]
  |  Branch (77:54): [True: 50.9k, False: 51.6k]
  ------------------
   78|  1.44M|}
upsampling_sse2.c:MultHi:
   72|  3.36M|static WEBP_INLINE int MultHi(int v, int coeff) {  // _mm_mulhi_epu16 emulation
   73|  3.36M|  return (v * coeff) >> 8;
   74|  3.36M|}
upsampling_sse2.c:VP8YUVToG:
   84|   480k|static WEBP_INLINE int VP8YUVToG(int y, int u, int v) {
   85|   480k|  return VP8Clip8(MultHi(y, 19077) - MultHi(u, 6419) - MultHi(v, 13320) + 8708);
   86|   480k|}
upsampling_sse2.c:VP8YUVToB:
   88|   480k|static WEBP_INLINE int VP8YUVToB(int y, int u) {
   89|   480k|  return VP8Clip8(MultHi(y, 19077) + MultHi(u, 33050) - 17685);
   90|   480k|}

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

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|}

vp8_dec.c:VP8LoadNewBytes:
   64|   535k|    VP8BitReader* WEBP_RESTRICT const br) {
   65|   535k|  assert(br != NULL && br->buf != NULL);
   66|       |  // Read 'BITS' bits at a time if possible.
   67|   535k|  if (br->buf < br->buf_max) {
  ------------------
  |  Branch (67:7): [True: 25.2k, False: 509k]
  ------------------
   68|       |    // convert memory type to register type (with some zero'ing!)
   69|  25.2k|    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|  25.2k|    lbit_t in_bits;
   85|  25.2k|    WEBP_UNSAFE_MEMCPY(&in_bits, br->buf, sizeof(in_bits));
  ------------------
  |  |  174|  25.2k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
   86|  25.2k|#endif
   87|  25.2k|    br->buf += BITS >> 3;
  ------------------
  |  |   70|  25.2k|#define BITS 56
  ------------------
   88|  25.2k|    WEBP_SELF_ASSIGN(br->buf_end);
  ------------------
  |  |  186|  25.2k|#define WEBP_SELF_ASSIGN(x) x = x
  ------------------
   89|  25.2k|#if !defined(WORDS_BIGENDIAN)
   90|  25.2k|#if (BITS > 32)
   91|  25.2k|    bits = BSwap64(in_bits);
   92|  25.2k|    bits >>= 64 - BITS;
  ------------------
  |  |   70|  25.2k|#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|  25.2k|    br->value = bits | (br->value << BITS);
  ------------------
  |  |   70|  25.2k|#define BITS 56
  ------------------
  106|  25.2k|    br->bits += BITS;
  ------------------
  |  |   70|  25.2k|#define BITS 56
  ------------------
  107|   509k|  } else {
  108|   509k|    VP8LoadFinalBytes(br);  // no need to be inlined
  109|   509k|  }
  110|   535k|}
vp8_dec.c:VP8GetBit:
  114|  2.11M|                                 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.11M|  range_t range = br->range;
  119|  2.11M|  if (br->bits < 0) {
  ------------------
  |  Branch (119:7): [True: 506k, False: 1.60M]
  ------------------
  120|   506k|    VP8LoadNewBytes(br);
  121|   506k|  }
  122|  2.11M|  {
  123|  2.11M|    const int pos = br->bits;
  124|  2.11M|    const range_t split = (range * prob) >> 8;
  125|  2.11M|    const range_t value = (range_t)(br->value >> pos);
  126|  2.11M|    const int bit = (value > split);
  127|  2.11M|    if (bit) {
  ------------------
  |  Branch (127:9): [True: 1.16M, False: 953k]
  ------------------
  128|  1.16M|      range -= split;
  129|  1.16M|      br->value -= (bit_t)(split + 1) << pos;
  130|  1.16M|    } else {
  131|   953k|      range = split + 1;
  132|   953k|    }
  133|  2.11M|    {
  134|  2.11M|      const int shift = 7 ^ BitsLog2Floor(range);
  135|  2.11M|      range <<= shift;
  136|  2.11M|      br->bits -= shift;
  137|  2.11M|    }
  138|  2.11M|    br->range = range - 1;
  139|  2.11M|    BT_TRACK(br);
  140|  2.11M|    return bit;
  141|  2.11M|  }
  142|  2.11M|}
vp8_dec.c:VP8GetSigned:
  146|   224k|    VP8BitReader* WEBP_RESTRICT const br, int v, const char label[]) {
  147|   224k|  if (br->bits < 0) {
  ------------------
  |  Branch (147:7): [True: 28.7k, False: 195k]
  ------------------
  148|  28.7k|    VP8LoadNewBytes(br);
  149|  28.7k|  }
  150|   224k|  {
  151|   224k|    const int pos = br->bits;
  152|   224k|    const range_t split = br->range >> 1;
  153|   224k|    const range_t value = (range_t)(br->value >> pos);
  154|   224k|    const int32_t mask = (int32_t)(split - value) >> 31;  // -1 or 0
  155|   224k|    br->bits -= 1;
  156|   224k|    br->range += (range_t)mask;
  157|   224k|    br->range |= 1;
  158|   224k|    br->value -= (bit_t)((split + 1) & (uint32_t)mask) << pos;
  159|   224k|    BT_TRACK(br);
  160|   224k|    return (v ^ mask) - mask;
  161|   224k|  }
  162|   224k|}
bit_reader_utils.c:VP8LoadNewBytes:
   64|   400k|    VP8BitReader* WEBP_RESTRICT const br) {
   65|   400k|  assert(br != NULL && br->buf != NULL);
   66|       |  // Read 'BITS' bits at a time if possible.
   67|   400k|  if (br->buf < br->buf_max) {
  ------------------
  |  Branch (67:7): [True: 7.27k, False: 393k]
  ------------------
   68|       |    // convert memory type to register type (with some zero'ing!)
   69|  7.27k|    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|  7.27k|    lbit_t in_bits;
   85|  7.27k|    WEBP_UNSAFE_MEMCPY(&in_bits, br->buf, sizeof(in_bits));
  ------------------
  |  |  174|  7.27k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
   86|  7.27k|#endif
   87|  7.27k|    br->buf += BITS >> 3;
  ------------------
  |  |   70|  7.27k|#define BITS 56
  ------------------
   88|  7.27k|    WEBP_SELF_ASSIGN(br->buf_end);
  ------------------
  |  |  186|  7.27k|#define WEBP_SELF_ASSIGN(x) x = x
  ------------------
   89|  7.27k|#if !defined(WORDS_BIGENDIAN)
   90|  7.27k|#if (BITS > 32)
   91|  7.27k|    bits = BSwap64(in_bits);
   92|  7.27k|    bits >>= 64 - BITS;
  ------------------
  |  |   70|  7.27k|#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|  7.27k|    br->value = bits | (br->value << BITS);
  ------------------
  |  |   70|  7.27k|#define BITS 56
  ------------------
  106|  7.27k|    br->bits += BITS;
  ------------------
  |  |   70|  7.27k|#define BITS 56
  ------------------
  107|   393k|  } else {
  108|   393k|    VP8LoadFinalBytes(br);  // no need to be inlined
  109|   393k|  }
  110|   400k|}
bit_reader_utils.c:VP8GetBit:
  114|   635k|                                 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|   635k|  range_t range = br->range;
  119|   635k|  if (br->bits < 0) {
  ------------------
  |  Branch (119:7): [True: 396k, False: 239k]
  ------------------
  120|   396k|    VP8LoadNewBytes(br);
  121|   396k|  }
  122|   635k|  {
  123|   635k|    const int pos = br->bits;
  124|   635k|    const range_t split = (range * prob) >> 8;
  125|   635k|    const range_t value = (range_t)(br->value >> pos);
  126|   635k|    const int bit = (value > split);
  127|   635k|    if (bit) {
  ------------------
  |  Branch (127:9): [True: 535k, False: 100k]
  ------------------
  128|   535k|      range -= split;
  129|   535k|      br->value -= (bit_t)(split + 1) << pos;
  130|   535k|    } else {
  131|   100k|      range = split + 1;
  132|   100k|    }
  133|   635k|    {
  134|   635k|      const int shift = 7 ^ BitsLog2Floor(range);
  135|   635k|      range <<= shift;
  136|   635k|      br->bits -= shift;
  137|   635k|    }
  138|   635k|    br->range = range - 1;
  139|   635k|    BT_TRACK(br);
  140|   635k|    return bit;
  141|   635k|  }
  142|   635k|}
tree_dec.c:VP8GetBit:
  114|  3.62M|                                 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|  3.62M|  range_t range = br->range;
  119|  3.62M|  if (br->bits < 0) {
  ------------------
  |  Branch (119:7): [True: 243k, False: 3.37M]
  ------------------
  120|   243k|    VP8LoadNewBytes(br);
  121|   243k|  }
  122|  3.62M|  {
  123|  3.62M|    const int pos = br->bits;
  124|  3.62M|    const range_t split = (range * prob) >> 8;
  125|  3.62M|    const range_t value = (range_t)(br->value >> pos);
  126|  3.62M|    const int bit = (value > split);
  127|  3.62M|    if (bit) {
  ------------------
  |  Branch (127:9): [True: 453k, False: 3.16M]
  ------------------
  128|   453k|      range -= split;
  129|   453k|      br->value -= (bit_t)(split + 1) << pos;
  130|  3.16M|    } else {
  131|  3.16M|      range = split + 1;
  132|  3.16M|    }
  133|  3.62M|    {
  134|  3.62M|      const int shift = 7 ^ BitsLog2Floor(range);
  135|  3.62M|      range <<= shift;
  136|  3.62M|      br->bits -= shift;
  137|  3.62M|    }
  138|  3.62M|    br->range = range - 1;
  139|  3.62M|    BT_TRACK(br);
  140|  3.62M|    return bit;
  141|  3.62M|  }
  142|  3.62M|}
tree_dec.c:VP8LoadNewBytes:
   64|   243k|    VP8BitReader* WEBP_RESTRICT const br) {
   65|   243k|  assert(br != NULL && br->buf != NULL);
   66|       |  // Read 'BITS' bits at a time if possible.
   67|   243k|  if (br->buf < br->buf_max) {
  ------------------
  |  Branch (67:7): [True: 10.7k, False: 232k]
  ------------------
   68|       |    // convert memory type to register type (with some zero'ing!)
   69|  10.7k|    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|  10.7k|    lbit_t in_bits;
   85|  10.7k|    WEBP_UNSAFE_MEMCPY(&in_bits, br->buf, sizeof(in_bits));
  ------------------
  |  |  174|  10.7k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
   86|  10.7k|#endif
   87|  10.7k|    br->buf += BITS >> 3;
  ------------------
  |  |   70|  10.7k|#define BITS 56
  ------------------
   88|  10.7k|    WEBP_SELF_ASSIGN(br->buf_end);
  ------------------
  |  |  186|  10.7k|#define WEBP_SELF_ASSIGN(x) x = x
  ------------------
   89|  10.7k|#if !defined(WORDS_BIGENDIAN)
   90|  10.7k|#if (BITS > 32)
   91|  10.7k|    bits = BSwap64(in_bits);
   92|  10.7k|    bits >>= 64 - BITS;
  ------------------
  |  |   70|  10.7k|#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|  10.7k|    br->value = bits | (br->value << BITS);
  ------------------
  |  |   70|  10.7k|#define BITS 56
  ------------------
  106|  10.7k|    br->bits += BITS;
  ------------------
  |  |   70|  10.7k|#define BITS 56
  ------------------
  107|   232k|  } else {
  108|   232k|    VP8LoadFinalBytes(br);  // no need to be inlined
  109|   232k|  }
  110|   243k|}

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

vp8l_dec.c:VP8LFillBitWindow:
  198|  4.07M|static WEBP_INLINE void VP8LFillBitWindow(VP8LBitReader* const br) {
  199|  4.07M|  if (br->bit_pos >= VP8L_WBITS) VP8LDoFillBitWindow(br);
  ------------------
  |  |  147|  4.07M|#define VP8L_WBITS 32  // Minimum number of bytes ready after VP8LFillBitWindow.
  ------------------
  |  Branch (199:7): [True: 548k, False: 3.52M]
  ------------------
  200|  4.07M|}
vp8l_dec.c:VP8LPrefetchBits:
  176|  5.13M|static WEBP_INLINE uint32_t VP8LPrefetchBits(VP8LBitReader* const br) {
  177|  5.13M|  return (uint32_t)(br->val >> (br->bit_pos & (VP8L_LBITS - 1)));
  ------------------
  |  |  146|  5.13M|#define VP8L_LBITS 64  // Number of bits prefetched (= bit-size of vp8l_val_t).
  ------------------
  178|  5.13M|}
vp8l_dec.c:VP8LSetBitPos:
  191|  5.13M|static WEBP_INLINE void VP8LSetBitPos(VP8LBitReader* const br, int val) {
  192|  5.13M|  br->bit_pos = val;
  193|  5.13M|}
vp8l_dec.c:VP8LIsEndOfStream:
  182|  3.47M|static WEBP_INLINE int VP8LIsEndOfStream(const VP8LBitReader* const br) {
  183|  3.47M|  assert(br->pos <= br->len);
  184|  3.47M|  return br->eos || ((br->pos == br->len) && (br->bit_pos > VP8L_LBITS));
  ------------------
  |  |  146|   495k|#define VP8L_LBITS 64  // Number of bits prefetched (= bit-size of vp8l_val_t).
  ------------------
  |  Branch (184:10): [True: 216, False: 3.47M]
  |  Branch (184:22): [True: 495k, False: 2.97M]
  |  Branch (184:46): [True: 472, False: 495k]
  ------------------
  185|  3.47M|}
bit_reader_utils.c:VP8LIsEndOfStream:
  182|  1.30M|static WEBP_INLINE int VP8LIsEndOfStream(const VP8LBitReader* const br) {
  183|  1.30M|  assert(br->pos <= br->len);
  184|  1.30M|  return br->eos || ((br->pos == br->len) && (br->bit_pos > VP8L_LBITS));
  ------------------
  |  |  146|   455k|#define VP8L_LBITS 64  // Number of bits prefetched (= bit-size of vp8l_val_t).
  ------------------
  |  Branch (184:10): [True: 246, False: 1.30M]
  |  Branch (184:22): [True: 455k, False: 846k]
  |  Branch (184:46): [True: 542, False: 454k]
  ------------------
  185|  1.30M|}
bit_reader_utils.c:VP8LPrefetchBits:
  176|   884k|static WEBP_INLINE uint32_t VP8LPrefetchBits(VP8LBitReader* const br) {
  177|   884k|  return (uint32_t)(br->val >> (br->bit_pos & (VP8L_LBITS - 1)));
  ------------------
  |  |  146|   884k|#define VP8L_LBITS 64  // Number of bits prefetched (= bit-size of vp8l_val_t).
  ------------------
  178|   884k|}

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

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

vp8_dec.c:BSwap64:
   78|  25.2k|static WEBP_INLINE uint64_t BSwap64(uint64_t x) {
   79|  25.2k|#if defined(HAVE_BUILTIN_BSWAP64)
   80|  25.2k|  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|  25.2k|}
bit_reader_utils.c:BSwap64:
   78|  7.27k|static WEBP_INLINE uint64_t BSwap64(uint64_t x) {
   79|  7.27k|#if defined(HAVE_BUILTIN_BSWAP64)
   80|  7.27k|  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|  7.27k|}
tree_dec.c:BSwap64:
   78|  10.7k|static WEBP_INLINE uint64_t BSwap64(uint64_t x) {
   79|  10.7k|#if defined(HAVE_BUILTIN_BSWAP64)
   80|  10.7k|  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|  10.7k|}

VP8LHtreeGroupsNew:
   31|  3.03k|HTreeGroup* VP8LHtreeGroupsNew(int num_htree_groups) {
   32|  3.03k|  HTreeGroup* const htree_groups =
   33|  3.03k|      (HTreeGroup*)WebPSafeMalloc(num_htree_groups, sizeof(*htree_groups));
   34|  3.03k|  if (htree_groups == NULL) {
  ------------------
  |  Branch (34:7): [True: 0, False: 3.03k]
  ------------------
   35|      0|    return NULL;
   36|      0|  }
   37|  3.03k|  assert(num_htree_groups <= MAX_HTREE_GROUPS);
   38|  3.03k|  return htree_groups;
   39|  3.03k|}
VP8LHtreeGroupsFree:
   41|  6.94k|void VP8LHtreeGroupsFree(HTreeGroup* const htree_groups) {
   42|  6.94k|  if (htree_groups != NULL) {
  ------------------
  |  Branch (42:7): [True: 3.03k, False: 3.90k]
  ------------------
   43|  3.03k|    WebPSafeFree(htree_groups);
   44|  3.03k|  }
   45|  6.94k|}
VP8LBuildHuffmanTable:
  238|   181k|                          int code_lengths_size) {
  239|   181k|  const int total_size =
  240|   181k|      BuildHuffmanTable(NULL, root_bits, code_lengths, code_lengths_size, NULL);
  241|   181k|  assert(code_lengths_size <= MAX_CODE_LENGTHS_SIZE);
  242|   181k|  if (total_size == 0 || root_table == NULL) return total_size;
  ------------------
  |  Branch (242:7): [True: 407, False: 180k]
  |  Branch (242:26): [True: 87.5k, False: 93.3k]
  ------------------
  243|       |
  244|  93.3k|  if (root_table->curr_segment->curr_table + total_size >=
  ------------------
  |  Branch (244:7): [True: 788, False: 92.5k]
  ------------------
  245|  93.3k|      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|    788|    const int segment_size = root_table->curr_segment->size;
  250|    788|    struct HuffmanTablesSegment* next =
  251|    788|        (HuffmanTablesSegment*)WebPSafeMalloc(1, sizeof(*next));
  252|    788|    if (next == NULL) return 0;
  ------------------
  |  Branch (252:9): [True: 0, False: 788]
  ------------------
  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|    788|    {
  258|    788|      const int next_size =
  259|    788|          total_size > segment_size ? total_size : segment_size;
  ------------------
  |  Branch (259:11): [True: 0, False: 788]
  ------------------
  260|    788|      HuffmanCode* WEBP_BIDI_INDEXABLE const next_start =
  261|    788|          (HuffmanCode*)WebPSafeMalloc(next_size, sizeof(*next_start));
  262|    788|      if (next_start == NULL) {
  ------------------
  |  Branch (262:11): [True: 0, False: 788]
  ------------------
  263|      0|        WebPSafeFree(next);
  264|      0|        return 0;
  265|      0|      }
  266|    788|      next->size = next_size;
  267|    788|      next->start = next_start;
  268|    788|    }
  269|      0|    next->curr_table = next->start;
  270|    788|    next->next = NULL;
  271|       |    // Point to the new segment.
  272|    788|    root_table->curr_segment->next = next;
  273|    788|    root_table->curr_segment = next;
  274|    788|  }
  275|  93.3k|  if (code_lengths_size <= SORTED_SIZE_CUTOFF) {
  ------------------
  |  |  234|  93.3k|#define SORTED_SIZE_CUTOFF 512
  ------------------
  |  Branch (275:7): [True: 91.1k, False: 2.23k]
  ------------------
  276|       |    // use local stack-allocated array.
  277|  91.1k|    uint16_t sorted[SORTED_SIZE_CUTOFF];
  278|  91.1k|    BuildHuffmanTable(
  279|  91.1k|        WEBP_UNSAFE_FORGE_BIDI_INDEXABLE(
  ------------------
  |  |  180|  91.1k|#define WEBP_UNSAFE_FORGE_BIDI_INDEXABLE(typ, ptr, size) ((typ)(ptr))
  ------------------
  280|  91.1k|            HuffmanCode*, root_table->curr_segment->curr_table,
  281|  91.1k|            total_size * sizeof(*root_table->curr_segment->curr_table)),
  282|  91.1k|        root_bits, code_lengths, code_lengths_size, sorted);
  283|  91.1k|  } else {  // rare case. Use heap allocation.
  284|  2.23k|    uint16_t* const sorted =
  285|  2.23k|        (uint16_t*)WebPSafeMalloc(code_lengths_size, sizeof(*sorted));
  286|  2.23k|    if (sorted == NULL) return 0;
  ------------------
  |  Branch (286:9): [True: 0, False: 2.23k]
  ------------------
  287|  2.23k|    BuildHuffmanTable(
  288|  2.23k|        WEBP_UNSAFE_FORGE_BIDI_INDEXABLE(
  ------------------
  |  |  180|  2.23k|#define WEBP_UNSAFE_FORGE_BIDI_INDEXABLE(typ, ptr, size) ((typ)(ptr))
  ------------------
  289|  2.23k|            HuffmanCode*, root_table->curr_segment->curr_table,
  290|  2.23k|            total_size * sizeof(*root_table->curr_segment->curr_table)),
  291|  2.23k|        root_bits, code_lengths, code_lengths_size,
  292|  2.23k|        WEBP_UNSAFE_FORGE_BIDI_INDEXABLE(
  ------------------
  |  |  180|  2.23k|#define WEBP_UNSAFE_FORGE_BIDI_INDEXABLE(typ, ptr, size) ((typ)(ptr))
  ------------------
  293|  2.23k|            uint16_t*, sorted, (size_t)code_lengths_size * sizeof(*sorted)));
  294|  2.23k|    WebPSafeFree(sorted);
  295|  2.23k|  }
  296|  93.3k|  return total_size;
  297|  93.3k|}
VP8LHuffmanTablesAllocate:
  299|  4.10k|int VP8LHuffmanTablesAllocate(int size, HuffmanTables* huffman_tables) {
  300|       |  // Have 'segment' point to the first segment for now, 'root'.
  301|  4.10k|  HuffmanTablesSegment* const root = &huffman_tables->root;
  302|  4.10k|  huffman_tables->curr_segment = root;
  303|  4.10k|  root->next = NULL;
  304|       |  // Allocate root.
  305|  4.10k|  {
  306|  4.10k|    HuffmanCode* WEBP_BIDI_INDEXABLE const start =
  307|  4.10k|        (HuffmanCode*)WebPSafeMalloc(size, sizeof(*root->start));
  308|  4.10k|    if (start == NULL) {
  ------------------
  |  Branch (308:9): [True: 0, False: 4.10k]
  ------------------
  309|      0|      root->start = NULL;
  310|      0|      root->size = 0;
  311|      0|      return 0;
  312|      0|    }
  313|  4.10k|    root->size = size;
  314|  4.10k|    root->start = start;
  315|  4.10k|  }
  316|      0|  root->curr_table = root->start;
  317|  4.10k|  return 1;
  318|  4.10k|}
VP8LHuffmanTablesDeallocate:
  320|  8.00k|void VP8LHuffmanTablesDeallocate(HuffmanTables* const huffman_tables) {
  321|  8.00k|  HuffmanTablesSegment *current, *next;
  322|  8.00k|  if (huffman_tables == NULL) return;
  ------------------
  |  Branch (322:7): [True: 0, False: 8.00k]
  ------------------
  323|       |  // Free the root node.
  324|  8.00k|  current = &huffman_tables->root;
  325|  8.00k|  next = current->next;
  326|  8.00k|  WebPSafeFree(current->start);
  327|  8.00k|  current->start = NULL;
  328|  8.00k|  current->size = 0;
  329|  8.00k|  current->next = NULL;
  330|  8.00k|  current = next;
  331|       |  // Free the following nodes.
  332|  8.79k|  while (current != NULL) {
  ------------------
  |  Branch (332:10): [True: 788, False: 8.00k]
  ------------------
  333|    788|    next = current->next;
  334|    788|    WebPSafeFree(current->start);
  335|    788|    WebPSafeFree(current);
  336|    788|    current = next;
  337|    788|  }
  338|  8.00k|}
huffman_utils.c:BuildHuffmanTable:
   92|   274k|                                 sorted[]) {
   93|       |  // next available space in table
   94|   274k|  HuffmanCode* WEBP_BIDI_INDEXABLE table = root_table;
   95|   274k|  int total_size = 1 << root_bits;  // total size root table + 2nd level table
   96|   274k|  int len;                          // current code length
   97|   274k|  int symbol;                       // symbol index in original or sorted table
   98|       |  // number of codes of each length:
   99|   274k|  int count[MAX_ALLOWED_CODE_LENGTH + 1] = {0};
  100|       |  // offsets in sorted table for each length:
  101|   274k|  int offset[MAX_ALLOWED_CODE_LENGTH + 1];
  102|       |
  103|   274k|  assert(code_lengths_size != 0);
  104|   274k|  assert(code_lengths != NULL);
  105|   274k|  assert((root_table != NULL && sorted != NULL) ||
  106|   274k|         (root_table == NULL && sorted == NULL));
  107|   274k|  assert(root_bits > 0);
  108|       |
  109|       |  // Build histogram of code lengths.
  110|  76.2M|  for (symbol = 0; symbol < code_lengths_size; ++symbol) {
  ------------------
  |  Branch (110:20): [True: 75.9M, False: 274k]
  ------------------
  111|  75.9M|    if (code_lengths[symbol] > MAX_ALLOWED_CODE_LENGTH) {
  ------------------
  |  |   41|  75.9M|#define MAX_ALLOWED_CODE_LENGTH 15
  ------------------
  |  Branch (111:9): [True: 0, False: 75.9M]
  ------------------
  112|      0|      return 0;
  113|      0|    }
  114|  75.9M|    ++count[code_lengths[symbol]];
  115|  75.9M|  }
  116|       |
  117|       |  // Error, all code lengths are zeros.
  118|   274k|  if (count[0] == code_lengths_size) {
  ------------------
  |  Branch (118:7): [True: 116, False: 274k]
  ------------------
  119|    116|    return 0;
  120|    116|  }
  121|       |
  122|       |  // Generate offsets into sorted symbol table by code length.
  123|   274k|  offset[1] = 0;
  124|  4.11M|  for (len = 1; len < MAX_ALLOWED_CODE_LENGTH; ++len) {
  ------------------
  |  |   41|  4.11M|#define MAX_ALLOWED_CODE_LENGTH 15
  ------------------
  |  Branch (124:17): [True: 3.84M, False: 274k]
  ------------------
  125|  3.84M|    if (count[len] > (1 << len)) {
  ------------------
  |  Branch (125:9): [True: 46, False: 3.84M]
  ------------------
  126|     46|      return 0;
  127|     46|    }
  128|  3.84M|    offset[len + 1] = offset[len] + count[len];
  129|  3.84M|  }
  130|       |
  131|       |  // Sort symbols by length, by symbol order within each length.
  132|  76.1M|  for (symbol = 0; symbol < code_lengths_size; ++symbol) {
  ------------------
  |  Branch (132:20): [True: 75.8M, False: 274k]
  ------------------
  133|  75.8M|    const int symbol_code_length = code_lengths[symbol];
  134|  75.8M|    if (code_lengths[symbol] > 0) {
  ------------------
  |  Branch (134:9): [True: 470k, False: 75.4M]
  ------------------
  135|   470k|      if (sorted != NULL) {
  ------------------
  |  Branch (135:11): [True: 150k, False: 320k]
  ------------------
  136|   150k|        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|   150k|        if (offset[symbol_code_length] >= code_lengths_size) {
  ------------------
  |  Branch (140:13): [True: 0, False: 150k]
  ------------------
  141|      0|          return 0;
  142|      0|        }
  143|   150k|        sorted[offset[symbol_code_length]++] = symbol;
  144|   320k|      } else {
  145|   320k|        offset[symbol_code_length]++;
  146|   320k|      }
  147|   470k|    }
  148|  75.8M|  }
  149|       |
  150|       |  // Special case code with only one value.
  151|   274k|  if (offset[MAX_ALLOWED_CODE_LENGTH] == 1) {
  ------------------
  |  |   41|   274k|#define MAX_ALLOWED_CODE_LENGTH 15
  ------------------
  |  Branch (151:7): [True: 216k, False: 57.8k]
  ------------------
  152|   216k|    if (sorted != NULL) {
  ------------------
  |  Branch (152:9): [True: 86.7k, False: 129k]
  ------------------
  153|  86.7k|      HuffmanCode code;
  154|  86.7k|      code.bits = 0;
  155|  86.7k|      code.value = (uint16_t)sorted[0];
  156|  86.7k|      ReplicateValue(table, 1, total_size, code);
  157|  86.7k|    }
  158|   216k|    return total_size;
  159|   216k|  }
  160|       |
  161|  57.8k|  {
  162|  57.8k|    int step;  // step size to replicate values in current table
  163|  57.8k|    uint32_t low = 0xffffffffu;      // low bits for current root entry
  164|  57.8k|    uint32_t mask = total_size - 1;  // mask for low bits
  165|  57.8k|    uint32_t key = 0;                // reversed prefix code
  166|  57.8k|    int num_nodes = 1;               // number of Huffman tree nodes
  167|  57.8k|    int num_open = 1;  // number of open branches in current tree level
  168|  57.8k|    int table_bits = root_bits;        // key length of current table
  169|  57.8k|    int table_size = 1 << table_bits;  // size of current table
  170|  57.8k|    symbol = 0;
  171|       |    // Fill in root table.
  172|   518k|    for (len = 1, step = 2; len <= root_bits; ++len, step <<= 1) {
  ------------------
  |  Branch (172:29): [True: 460k, False: 57.7k]
  ------------------
  173|   460k|      num_open <<= 1;
  174|   460k|      num_nodes += num_open;
  175|   460k|      num_open -= count[len];
  176|   460k|      if (num_open < 0) {
  ------------------
  |  Branch (176:11): [True: 89, False: 460k]
  ------------------
  177|     89|        return 0;
  178|     89|      }
  179|   460k|      if (root_table == NULL) continue;
  ------------------
  |  Branch (179:11): [True: 408k, False: 52.0k]
  ------------------
  180|  76.1k|      for (; count[len] > 0; --count[len]) {
  ------------------
  |  Branch (180:14): [True: 24.1k, False: 52.0k]
  ------------------
  181|  24.1k|        HuffmanCode code;
  182|  24.1k|        code.bits = (uint8_t)len;
  183|  24.1k|        code.value = (uint16_t)sorted[symbol++];
  184|  24.1k|        ReplicateValue(&table[key], step, table_size, code);
  185|  24.1k|        key = GetNextKey(key, len);
  186|  24.1k|      }
  187|  52.0k|    }
  188|       |
  189|       |    // Fill in 2nd level tables and add pointers to root table.
  190|   463k|    for (len = root_bits + 1, step = 2; len <= MAX_ALLOWED_CODE_LENGTH;
  ------------------
  |  |   41|   463k|#define MAX_ALLOWED_CODE_LENGTH 15
  ------------------
  |  Branch (190:41): [True: 405k, False: 57.7k]
  ------------------
  191|   405k|         ++len, step <<= 1) {
  192|   405k|      num_open <<= 1;
  193|   405k|      num_nodes += num_open;
  194|   405k|      num_open -= count[len];
  195|   405k|      if (num_open < 0) {
  ------------------
  |  Branch (195:11): [True: 16, False: 405k]
  ------------------
  196|     16|        return 0;
  197|     16|      }
  198|   497k|      for (; count[len] > 0; --count[len]) {
  ------------------
  |  Branch (198:14): [True: 91.8k, False: 405k]
  ------------------
  199|  91.8k|        HuffmanCode code;
  200|  91.8k|        if ((key & mask) != low) {
  ------------------
  |  Branch (200:13): [True: 12.5k, False: 79.2k]
  ------------------
  201|  12.5k|          if (root_table != NULL) table += table_size;
  ------------------
  |  Branch (201:15): [True: 5.45k, False: 7.11k]
  ------------------
  202|  12.5k|          table_bits = NextTableBitSize(count, len, root_bits);
  203|  12.5k|          table_size = 1 << table_bits;
  204|  12.5k|          total_size += table_size;
  205|  12.5k|          low = key & mask;
  206|  12.5k|          if (root_table != NULL) {
  ------------------
  |  Branch (206:15): [True: 5.45k, False: 7.11k]
  ------------------
  207|  5.45k|            root_table[low].bits = (uint8_t)(table_bits + root_bits);
  208|  5.45k|            root_table[low].value = (uint16_t)((table - root_table) - low);
  209|  5.45k|          }
  210|  12.5k|        }
  211|  91.8k|        if (root_table != NULL) {
  ------------------
  |  Branch (211:13): [True: 39.7k, False: 52.0k]
  ------------------
  212|  39.7k|          code.bits = (uint8_t)(len - root_bits);
  213|  39.7k|          code.value = (uint16_t)sorted[symbol++];
  214|  39.7k|          ReplicateValue(&table[key >> root_bits], step, table_size, code);
  215|  39.7k|        }
  216|  91.8k|        key = GetNextKey(key, len);
  217|  91.8k|      }
  218|   405k|    }
  219|       |
  220|       |    // Check if tree is full.
  221|  57.7k|    if (num_nodes != 2 * offset[MAX_ALLOWED_CODE_LENGTH] - 1) {
  ------------------
  |  |   41|  57.7k|#define MAX_ALLOWED_CODE_LENGTH 15
  ------------------
  |  Branch (221:9): [True: 140, False: 57.5k]
  ------------------
  222|    140|      return 0;
  223|    140|    }
  224|  57.7k|  }
  225|       |
  226|  57.5k|  return total_size;
  227|  57.7k|}
huffman_utils.c:ReplicateValue:
   61|   150k|                                       int step, int end, HuffmanCode code) {
   62|   150k|  int current_end = end;
   63|   150k|  assert(current_end % step == 0);
   64|  23.8M|  do {
   65|  23.8M|    current_end -= step;
   66|  23.8M|    table[current_end] = code;
   67|  23.8M|  } while (current_end > 0);
  ------------------
  |  Branch (67:12): [True: 23.6M, False: 150k]
  ------------------
   68|   150k|}
huffman_utils.c:GetNextKey:
   49|   115k|static WEBP_INLINE uint32_t GetNextKey(uint32_t key, int len) {
   50|   115k|  uint32_t step = 1 << (len - 1);
   51|   224k|  while (key & step) {
  ------------------
  |  Branch (51:10): [True: 108k, False: 115k]
  ------------------
   52|   108k|    step >>= 1;
   53|   108k|  }
   54|   115k|  return step ? (key & (step - 1)) + step : key;
  ------------------
  |  Branch (54:10): [True: 109k, False: 6.59k]
  ------------------
   55|   115k|}
huffman_utils.c:NextTableBitSize:
   75|  12.5k|    int len, int root_bits) {
   76|  12.5k|  int left = 1 << (len - root_bits);
   77|  12.9k|  while (len < MAX_ALLOWED_CODE_LENGTH) {
  ------------------
  |  |   41|  12.9k|#define MAX_ALLOWED_CODE_LENGTH 15
  ------------------
  |  Branch (77:10): [True: 12.8k, False: 163]
  ------------------
   78|  12.8k|    left -= count[len];
   79|  12.8k|    if (left <= 0) break;
  ------------------
  |  Branch (79:9): [True: 12.4k, False: 396]
  ------------------
   80|    396|    ++len;
   81|    396|    left <<= 1;
   82|    396|  }
   83|  12.5k|  return len - root_bits;
   84|  12.5k|}

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

WebPSafeMalloc:
  205|  25.4k|    WebPSafeMalloc(uint64_t nmemb, size_t size) {
  206|  25.4k|  void* ptr;
  207|  25.4k|  Increment(&num_malloc_calls);
  ------------------
  |  |  171|  25.4k|  do {               \
  |  |  172|  25.4k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (172:12): [Folded, False: 25.4k]
  |  |  ------------------
  ------------------
  208|  25.4k|  if (!CheckSizeArgumentsOverflow(nmemb, size)) return NULL;
  ------------------
  |  Branch (208:7): [True: 0, False: 25.4k]
  ------------------
  209|  25.4k|  assert(nmemb * size > 0);
  210|  25.4k|  ptr = malloc((size_t)(nmemb * size));
  211|  25.4k|  AddMem(ptr, (size_t)(nmemb * size));
  ------------------
  |  |  174|  25.4k|  do {               \
  |  |  175|  25.4k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (175:12): [Folded, False: 25.4k]
  |  |  ------------------
  ------------------
  212|  25.4k|  return WEBP_UNSAFE_FORGE_BIDI_INDEXABLE(void*, ptr, (size_t)(nmemb * size));
  ------------------
  |  |  180|  25.4k|#define WEBP_UNSAFE_FORGE_BIDI_INDEXABLE(typ, ptr, size) ((typ)(ptr))
  ------------------
  213|  25.4k|}
WebPSafeCalloc:
  216|  27.4k|    WebPSafeCalloc(uint64_t nmemb, size_t size) {
  217|  27.4k|  void* ptr;
  218|  27.4k|  Increment(&num_calloc_calls);
  ------------------
  |  |  171|  27.4k|  do {               \
  |  |  172|  27.4k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (172:12): [Folded, False: 27.4k]
  |  |  ------------------
  ------------------
  219|  27.4k|  if (!CheckSizeArgumentsOverflow(nmemb, size)) return NULL;
  ------------------
  |  Branch (219:7): [True: 0, False: 27.4k]
  ------------------
  220|  27.4k|  assert(nmemb * size > 0);
  221|  27.4k|  ptr = calloc((size_t)nmemb, size);
  222|  27.4k|  AddMem(ptr, (size_t)(nmemb * size));
  ------------------
  |  |  174|  27.4k|  do {               \
  |  |  175|  27.4k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (175:12): [Folded, False: 27.4k]
  |  |  ------------------
  ------------------
  223|  27.4k|  return WEBP_UNSAFE_FORGE_BIDI_INDEXABLE(void*, ptr, (size_t)(nmemb * size));
  ------------------
  |  |  180|  27.4k|#define WEBP_UNSAFE_FORGE_BIDI_INDEXABLE(typ, ptr, size) ((typ)(ptr))
  ------------------
  224|  27.4k|}
WebPSafeFree:
  226|  95.3k|void WebPSafeFree(void* const ptr) {
  227|  95.3k|  if (ptr != NULL) {
  ------------------
  |  Branch (227:7): [True: 52.9k, False: 42.4k]
  ------------------
  228|  52.9k|    Increment(&num_free_calls);
  ------------------
  |  |  171|  52.9k|  do {               \
  |  |  172|  52.9k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (172:12): [Folded, False: 52.9k]
  |  |  ------------------
  ------------------
  229|  52.9k|    SubMem(ptr);
  ------------------
  |  |  177|  52.9k|  do {            \
  |  |  178|  52.9k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (178:12): [Folded, False: 52.9k]
  |  |  ------------------
  ------------------
  230|  52.9k|  }
  231|  95.3k|  free(ptr);
  232|  95.3k|}
WebPMalloc:
  236|  7.74k|void* WEBP_SINGLE WebPMalloc(size_t size) {
  237|       |  // Currently WebPMalloc/WebPFree are declared in src/webp/types.h, which does
  238|       |  // not include bounds_safety.h. As such, the "default" annotation for the
  239|       |  // pointers they accept/return is __single.
  240|       |  //
  241|       |  // All callers will need to immediately cast the returned pointer to
  242|       |  // WEBP_BIDI_INDEXABLE or WEBP_INDEXABLE via
  243|       |  // WEBP_UNSAFE_FORGE_BIDI_INDEXABLE.
  244|       |  //
  245|       |  // TODO: https://issues.webmproject.org/432511225 - Remove this once we can
  246|       |  // annotate WebPMalloc/WebPFree.
  247|  7.74k|  return WEBP_UNSAFE_FORGE_SINGLE(void*, WebPSafeMalloc(1, size));
  ------------------
  |  |  179|  7.74k|#define WEBP_UNSAFE_FORGE_SINGLE(typ, ptr) ((typ)(ptr))
  ------------------
  248|  7.74k|}
WebPFree:
  250|  12.6k|void WebPFree(void* WEBP_SINGLE ptr) { WebPSafeFree(ptr); }
utils.c:CheckSizeArgumentsOverflow:
  182|  52.9k|static int CheckSizeArgumentsOverflow(uint64_t nmemb, size_t size) {
  183|  52.9k|  const uint64_t total_size = nmemb * size;
  184|  52.9k|  if (nmemb == 0) return 1;
  ------------------
  |  Branch (184:7): [True: 0, False: 52.9k]
  ------------------
  185|  52.9k|  if ((uint64_t)size > WEBP_MAX_ALLOCABLE_MEMORY / nmemb) return 0;
  ------------------
  |  |   40|  52.9k|#define WEBP_MAX_ALLOCABLE_MEMORY (1ULL << 34)
  ------------------
  |  Branch (185:7): [True: 0, False: 52.9k]
  ------------------
  186|  52.9k|  if (!CheckSizeOverflow(total_size)) return 0;
  ------------------
  |  Branch (186:7): [True: 0, False: 52.9k]
  ------------------
  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|  52.9k|  return 1;
  202|  52.9k|}

webp_dec.c:GetLE32:
  107|    902|                                        data) {
  108|    902|  return GetLE16(data) | ((uint32_t)GetLE16(data + 2) << 16);
  109|    902|}
webp_dec.c:GetLE16:
   98|  1.84k|static WEBP_INLINE int GetLE16(const uint8_t* const WEBP_COUNTED_BY(2) data) {
   99|  1.84k|  return (int)(data[0] << 0) | (data[1] << 8);
  100|  1.84k|}
webp_dec.c:GetLE24:
  102|     36|static WEBP_INLINE int GetLE24(const uint8_t* const WEBP_COUNTED_BY(3) data) {
  103|     36|  return GetLE16(data) | (data[2] << 16);
  104|     36|}
utils.c:CheckSizeOverflow:
   47|  52.9k|static WEBP_INLINE int CheckSizeOverflow(uint64_t size) {
   48|  52.9k|  return size == (size_t)size;
   49|  52.9k|}
frame_dec.c:CheckSizeOverflow:
   47|  2.03k|static WEBP_INLINE int CheckSizeOverflow(uint64_t size) {
   48|  2.03k|  return size == (size_t)size;
   49|  2.03k|}
vp8_dec.c:BitsLog2Floor:
  136|  2.11M|static WEBP_INLINE int BitsLog2Floor(uint32_t n) {
  137|  2.11M|  return 31 ^ __builtin_clz(n);
  138|  2.11M|}
dec.c:WebPUint32ToMem:
   86|  26.1k|static WEBP_INLINE void WebPUint32ToMem(uint8_t* const ptr, uint32_t val) {
   87|  26.1k|  WEBP_UNSAFE_MEMCPY(ptr, &val, sizeof(val));
  ------------------
  |  |  174|  26.1k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
   88|  26.1k|}
dec_sse41.c:WebPMemToInt32:
   82|  70.9k|static WEBP_INLINE int32_t WebPMemToInt32(const uint8_t* const ptr) {
   83|  70.9k|  return (int32_t)WebPMemToUint32(ptr);
   84|  70.9k|}
dec_sse41.c:WebPMemToUint32:
   76|  70.9k|static WEBP_INLINE uint32_t WebPMemToUint32(const uint8_t* const ptr) {
   77|  70.9k|  uint32_t A;
   78|  70.9k|  WEBP_UNSAFE_MEMCPY(&A, ptr, sizeof(A));
  ------------------
  |  |  174|  70.9k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
   79|  70.9k|  return A;
   80|  70.9k|}
dec_sse2.c:WebPMemToInt32:
   82|  2.03M|static WEBP_INLINE int32_t WebPMemToInt32(const uint8_t* const ptr) {
   83|  2.03M|  return (int32_t)WebPMemToUint32(ptr);
   84|  2.03M|}
dec_sse2.c:WebPMemToUint32:
   76|  2.03M|static WEBP_INLINE uint32_t WebPMemToUint32(const uint8_t* const ptr) {
   77|  2.03M|  uint32_t A;
   78|  2.03M|  WEBP_UNSAFE_MEMCPY(&A, ptr, sizeof(A));
  ------------------
  |  |  174|  2.03M|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
   79|  2.03M|  return A;
   80|  2.03M|}
dec_sse2.c:WebPInt32ToMem:
   90|  1.88M|static WEBP_INLINE void WebPInt32ToMem(uint8_t* const ptr, int val) {
   91|  1.88M|  WebPUint32ToMem(ptr, (uint32_t)val);
   92|  1.88M|}
dec_sse2.c:WebPUint32ToMem:
   86|  1.88M|static WEBP_INLINE void WebPUint32ToMem(uint8_t* const ptr, uint32_t val) {
   87|  1.88M|  WEBP_UNSAFE_MEMCPY(ptr, &val, sizeof(val));
  ------------------
  |  |  174|  1.88M|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
   88|  1.88M|}
bit_reader_utils.c:BitsLog2Floor:
  136|   635k|static WEBP_INLINE int BitsLog2Floor(uint32_t n) {
  137|   635k|  return 31 ^ __builtin_clz(n);
  138|   635k|}
bit_reader_utils.c:WebPMemToUint32:
   76|   130k|static WEBP_INLINE uint32_t WebPMemToUint32(const uint8_t* const ptr) {
   77|   130k|  uint32_t A;
   78|   130k|  WEBP_UNSAFE_MEMCPY(&A, ptr, sizeof(A));
  ------------------
  |  |  174|   130k|#define WEBP_UNSAFE_MEMCPY(dst, src, size) memcpy(dst, src, size)
  ------------------
   79|   130k|  return A;
   80|   130k|}
tree_dec.c:BitsLog2Floor:
  136|  3.62M|static WEBP_INLINE int BitsLog2Floor(uint32_t n) {
  137|  3.62M|  return 31 ^ __builtin_clz(n);
  138|  3.62M|}
anim_decode.c:CheckSizeOverflow:
   47|  4.61k|static WEBP_INLINE int CheckSizeOverflow(uint64_t size) {
   48|  4.61k|  return size == (size_t)size;
   49|  4.61k|}

webp_dec.c:WebPInitDecBuffer:
  250|  3.90k|WEBP_NODISCARD static WEBP_INLINE int WebPInitDecBuffer(WebPDecBuffer* buffer) {
  251|  3.90k|  return WebPInitDecBufferInternal(buffer, WEBP_DECODER_ABI_VERSION);
  ------------------
  |  |   27|  3.90k|#define WEBP_DECODER_ABI_VERSION 0x0210  // MAJOR(8b) + MINOR(8b)
  ------------------
  252|  3.90k|}
buffer_dec.c:WebPIsRGBMode:
  203|  2.82k|static WEBP_INLINE int WebPIsRGBMode(WEBP_CSP_MODE mode) {
  204|  2.82k|  return (mode < MODE_YUV);
  205|  2.82k|}
io_dec.c:WebPIsRGBMode:
  203|  2.03k|static WEBP_INLINE int WebPIsRGBMode(WEBP_CSP_MODE mode) {
  204|  2.03k|  return (mode < MODE_YUV);
  205|  2.03k|}
io_dec.c:WebPIsAlphaMode:
  197|  2.03k|static WEBP_INLINE int WebPIsAlphaMode(WEBP_CSP_MODE mode) {
  198|  2.03k|  return (mode == MODE_RGBA || mode == MODE_BGRA || mode == MODE_ARGB ||
  ------------------
  |  Branch (198:11): [True: 2.03k, False: 0]
  |  Branch (198:32): [True: 0, False: 0]
  |  Branch (198:53): [True: 0, False: 0]
  ------------------
  199|      0|          mode == MODE_RGBA_4444 || mode == MODE_YUVA ||
  ------------------
  |  Branch (199:11): [True: 0, False: 0]
  |  Branch (199:37): [True: 0, False: 0]
  ------------------
  200|      0|          WebPIsPremultipliedMode(mode));
  ------------------
  |  Branch (200:11): [True: 0, False: 0]
  ------------------
  201|  2.03k|}
io_dec.c:WebPIsPremultipliedMode:
  192|  2.03k|static WEBP_INLINE int WebPIsPremultipliedMode(WEBP_CSP_MODE mode) {
  193|  2.03k|  return (mode == MODE_rgbA || mode == MODE_bgrA || mode == MODE_Argb ||
  ------------------
  |  Branch (193:11): [True: 0, False: 2.03k]
  |  Branch (193:32): [True: 0, False: 2.03k]
  |  Branch (193:53): [True: 0, False: 2.03k]
  ------------------
  194|  2.03k|          mode == MODE_rgbA_4444);
  ------------------
  |  Branch (194:11): [True: 0, False: 2.03k]
  ------------------
  195|  2.03k|}
vp8l_dec.c:WebPIsPremultipliedMode:
  192|    787|static WEBP_INLINE int WebPIsPremultipliedMode(WEBP_CSP_MODE mode) {
  193|    787|  return (mode == MODE_rgbA || mode == MODE_bgrA || mode == MODE_Argb ||
  ------------------
  |  Branch (193:11): [True: 0, False: 787]
  |  Branch (193:32): [True: 0, False: 787]
  |  Branch (193:53): [True: 0, False: 787]
  ------------------
  194|    787|          mode == MODE_rgbA_4444);
  ------------------
  |  Branch (194:11): [True: 0, False: 787]
  ------------------
  195|    787|}
vp8l_dec.c:WebPIsRGBMode:
  203|   511k|static WEBP_INLINE int WebPIsRGBMode(WEBP_CSP_MODE mode) {
  204|   511k|  return (mode < MODE_YUV);
  205|   511k|}
anim_decode.c:WebPGetFeatures:
  476|  3.90k|                size_t data_size, WebPBitstreamFeatures* features) {
  477|  3.90k|  return WebPGetFeaturesInternal(data, data_size, features,
  478|  3.90k|                                 WEBP_DECODER_ABI_VERSION);
  ------------------
  |  |   27|  3.90k|#define WEBP_DECODER_ABI_VERSION 0x0210  // MAJOR(8b) + MINOR(8b)
  ------------------
  479|  3.90k|}
anim_decode.c:WebPInitDecoderConfig:
  516|  3.90k|    WebPDecoderConfig* config) {
  517|  3.90k|  return WebPInitDecoderConfigInternal(config, WEBP_DECODER_ABI_VERSION);
  ------------------
  |  |   27|  3.90k|#define WEBP_DECODER_ABI_VERSION 0x0210  // MAJOR(8b) + MINOR(8b)
  ------------------
  518|  3.90k|}
demux.c:WebPGetFeatures:
  476|  3.87k|                size_t data_size, WebPBitstreamFeatures* features) {
  477|  3.87k|  return WebPGetFeaturesInternal(data, data_size, features,
  478|  3.87k|                                 WEBP_DECODER_ABI_VERSION);
  ------------------
  |  |   27|  3.87k|#define WEBP_DECODER_ABI_VERSION 0x0210  // MAJOR(8b) + MINOR(8b)
  ------------------
  479|  3.87k|}

anim_util.c:WebPAnimDecoderNew:
  293|  3.90k|    const WebPData* webp_data, const WebPAnimDecoderOptions* dec_options) {
  294|  3.90k|  return WebPAnimDecoderNewInternal(webp_data, dec_options,
  295|  3.90k|                                    WEBP_DEMUX_ABI_VERSION);
  ------------------
  |  |   61|  3.90k|#define WEBP_DEMUX_ABI_VERSION 0x0107  // MAJOR(8b) + MINOR(8b)
  ------------------
  296|  3.90k|}
anim_decode.c:WebPDemux:
   97|  3.90k|WEBP_NODISCARD static WEBP_INLINE WebPDemuxer* WebPDemux(const WebPData* data) {
   98|  3.90k|  return WebPDemuxInternal(data, 0, NULL, WEBP_DEMUX_ABI_VERSION);
  ------------------
  |  |   61|  3.90k|#define WEBP_DEMUX_ABI_VERSION 0x0107  // MAJOR(8b) + MINOR(8b)
  ------------------
   99|  3.90k|}

anim_util_fuzzer.cc:_ZN12_GLOBAL__N_121ReadAnimatedImageTestENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE:
   28|  4.45k|void ReadAnimatedImageTest(std::string_view blob) {
   29|  4.45k|  const uint8_t* const data = reinterpret_cast<const uint8_t*>(blob.data());
   30|  4.45k|  const size_t size = blob.size();
   31|  4.45k|  if (fuzz_utils::IsImageTooBig(data, size)) return;
  ------------------
  |  Branch (31:7): [True: 72, False: 4.38k]
  ------------------
   32|       |
   33|  4.38k|  nalloc_init(nullptr);
   34|  4.38k|  nalloc_start(data, size);
   35|       |
   36|  4.38k|  AnimatedImage image;
   37|  4.38k|  if (ReadAnimatedImageFromMemory("random_file", data, size, &image,
  ------------------
  |  Branch (37:7): [True: 737, False: 3.64k]
  ------------------
   38|  4.38k|                                  /*dump_frames=*/0, /*dump_folder=*/nullptr)) {
   39|    737|    ClearAnimatedImage(&image);
   40|    737|  }
   41|       |
   42|  4.38k|  nalloc_end();
   43|  4.38k|}

_ZN10fuzz_utils13IsImageTooBigEPKhm:
  182|  4.45k|bool IsImageTooBig(const uint8_t* data, size_t size) {
  183|  4.45k|  int width, height, components;
  184|  4.45k|  if (SjpegDimensions(data, size, &width, &height, &components) ||
  ------------------
  |  Branch (184:7): [True: 160, False: 4.29k]
  ------------------
  185|  4.29k|      WebPGetInfo(data, size, &width, &height)) {
  ------------------
  |  Branch (185:7): [True: 3.84k, False: 447]
  ------------------
  186|       |    // Look at the number of 8x8px blocks rather than the overall pixel count
  187|       |    // when comparing to memory and duration thresholds.
  188|  4.00k|    const size_t ceiled_width = ((size_t)width + 7) / 8 * 8;
  189|  4.00k|    const size_t ceiled_height = ((size_t)height + 7) / 8 * 8;
  190|       |    // Threshold to avoid out-of-memory and timeout issues.
  191|       |    // The threshold is arbitrary but below the fuzzer limit of 2 GB.
  192|       |    // The value cannot be 2 GB because of the added memory by MSAN.
  193|  4.00k|    if (ceiled_width * ceiled_height > kFuzzPxLimit) return true;
  ------------------
  |  Branch (193:9): [True: 72, False: 3.93k]
  ------------------
  194|  4.00k|  }
  195|  4.38k|  return false;
  196|  4.45k|}
fuzz_utils.cc:_ZN10fuzz_utils12_GLOBAL__N_115SjpegDimensionsEPKhmPiS3_S3_:
  160|  4.45k|                     int* is_yuv420) {
  161|  4.45k|  if (width == NULL || height == NULL) return false;
  ------------------
  |  Branch (161:7): [True: 0, False: 4.45k]
  |  Branch (161:24): [True: 0, False: 4.45k]
  ------------------
  162|  4.45k|  const uint8_t* src = GetSOFData(src0, size);
  163|  4.45k|  const size_t left_over = size - (src - src0);
  164|  4.45k|  if (src == NULL || left_over < 8 + 3 * 1) return false;
  ------------------
  |  Branch (164:7): [True: 4.27k, False: 178]
  |  Branch (164:22): [True: 2, False: 176]
  ------------------
  165|    176|  if (height != NULL) *height = (src[5] << 8) | src[6];
  ------------------
  |  Branch (165:7): [True: 176, False: 0]
  ------------------
  166|    176|  if (width != NULL) *width = (src[7] << 8) | src[8];
  ------------------
  |  Branch (166:7): [True: 176, False: 0]
  ------------------
  167|    176|  if (is_yuv420 != NULL) {
  ------------------
  |  Branch (167:7): [True: 176, False: 0]
  ------------------
  168|    176|    const size_t nb_comps = src[9];
  169|    176|    *is_yuv420 = (nb_comps == 3);
  170|    176|    if (left_over < 11 + 3 * nb_comps) return false;
  ------------------
  |  Branch (170:9): [True: 16, False: 160]
  ------------------
  171|    161|    for (int c = 0; *is_yuv420 && c < 3; ++c) {
  ------------------
  |  Branch (171:21): [True: 1, False: 160]
  |  Branch (171:35): [True: 1, False: 0]
  ------------------
  172|      1|      const int expected_dim = (c == 0 ? 0x22 : 0x11);
  ------------------
  |  Branch (172:33): [True: 1, False: 0]
  ------------------
  173|      1|      *is_yuv420 &= (src[11 + c * 3] == expected_dim);
  174|      1|    }
  175|    160|  }
  176|    160|  return true;
  177|    176|}
fuzz_utils.cc:_ZN10fuzz_utils12_GLOBAL__N_110GetSOFDataEPKhi:
  144|  4.45k|const uint8_t* GetSOFData(const uint8_t* src, int size) {
  145|  4.45k|  if (src == NULL) return NULL;
  ------------------
  |  Branch (145:7): [True: 1, False: 4.45k]
  ------------------
  146|  4.45k|  const uint8_t* const end = src + size - 8;  // 8 bytes of safety, for marker
  147|  4.45k|  src += 2;                                   // skip M_SOI
  148|  4.12M|  for (; src < end && *src != 0xff; ++src) {  /* search first 0xff marker */
  ------------------
  |  Branch (148:10): [True: 4.11M, False: 3.33k]
  |  Branch (148:23): [True: 4.11M, False: 1.11k]
  ------------------
  149|  4.11M|  }
  150|  7.04k|  while (src < end) {
  ------------------
  |  Branch (150:10): [True: 2.76k, False: 4.27k]
  ------------------
  151|  2.76k|    const uint32_t marker = static_cast<uint32_t>((src[0] << 8) | src[1]);
  152|  2.76k|    if (marker == M_SOF0 || marker == M_SOF1) return src;
  ------------------
  |  |  141|  5.53k|#define M_SOF0 0xffc0
  ------------------
                  if (marker == M_SOF0 || marker == M_SOF1) return src;
  ------------------
  |  |  142|  2.65k|#define M_SOF1 0xffc1
  ------------------
  |  Branch (152:9): [True: 118, False: 2.65k]
  |  Branch (152:29): [True: 60, False: 2.59k]
  ------------------
  153|  2.59k|    const size_t s = 2 + ((src[2] << 8) | src[3]);
  154|  2.59k|    src += s;
  155|  2.59k|  }
  156|  4.27k|  return NULL;  // No SOF marker found
  157|  4.45k|}

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