float.cpp:_ZN8memusageL12DynamicUsageERKd:
   40|    310|static inline size_t DynamicUsage(const double& v) { return 0; }

_ZN18FuzzedDataProviderC2EPKhm:
   37|    310|      : data_ptr_(data), remaining_bytes_(size) {}
_ZN18FuzzedDataProvider15ConsumeIntegralImEET_v:
  195|    276|template <typename T> T FuzzedDataProvider::ConsumeIntegral() {
  196|    276|  return ConsumeIntegralInRange(std::numeric_limits<T>::min(),
  197|    276|                                std::numeric_limits<T>::max());
  198|    276|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeImEET_S1_S1_:
  205|    620|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|    620|  static_assert(std::is_integral<T>::value, "An integral type is required.");
  207|    620|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|    620|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 620]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|    620|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|    620|  uint64_t result = 0;
  215|    620|  size_t offset = 0;
  216|       |
  217|  2.60k|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 2.46k, False: 146]
  |  Branch (217:43): [True: 2.11k, False: 343]
  ------------------
  218|  2.60k|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 1.98k, False: 131]
  ------------------
  219|       |    // Pull bytes off the end of the seed data. Experimentally, this seems to
  220|       |    // allow the fuzzer to more easily explore the input space. This makes
  221|       |    // sense, since it works by modifying inputs that caused new code to run,
  222|       |    // and this data is often used to encode length of data read by
  223|       |    // |ConsumeBytes|. Separating out read lengths makes it easier modify the
  224|       |    // contents of the data that is actually read.
  225|  1.98k|    --remaining_bytes_;
  226|  1.98k|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|  1.98k|    offset += CHAR_BIT;
  228|  1.98k|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|    620|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 344, False: 276]
  ------------------
  232|    344|    result = result % (range + 1);
  233|       |
  234|    620|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|    620|}
_ZN18FuzzedDataProvider15ConsumeIntegralIhEET_v:
  195|    118|template <typename T> T FuzzedDataProvider::ConsumeIntegral() {
  196|    118|  return ConsumeIntegralInRange(std::numeric_limits<T>::min(),
  197|    118|                                std::numeric_limits<T>::max());
  198|    118|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeIhEET_S1_S1_:
  205|    118|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|    118|  static_assert(std::is_integral<T>::value, "An integral type is required.");
  207|    118|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|    118|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 118]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|    118|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|    118|  uint64_t result = 0;
  215|    118|  size_t offset = 0;
  216|       |
  217|    235|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 118, False: 117]
  |  Branch (217:43): [True: 118, False: 0]
  ------------------
  218|    235|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 117, False: 1]
  ------------------
  219|       |    // Pull bytes off the end of the seed data. Experimentally, this seems to
  220|       |    // allow the fuzzer to more easily explore the input space. This makes
  221|       |    // sense, since it works by modifying inputs that caused new code to run,
  222|       |    // and this data is often used to encode length of data read by
  223|       |    // |ConsumeBytes|. Separating out read lengths makes it easier modify the
  224|       |    // contents of the data that is actually read.
  225|    117|    --remaining_bytes_;
  226|    117|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|    117|    offset += CHAR_BIT;
  228|    117|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|    118|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 118, False: 0]
  ------------------
  232|    118|    result = result % (range + 1);
  233|       |
  234|    118|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|    118|}
_ZN18FuzzedDataProvider11ConsumeBoolEv:
  289|    118|inline bool FuzzedDataProvider::ConsumeBool() {
  290|    118|  return 1 & ConsumeIntegral<uint8_t>();
  291|    118|}
_ZN18FuzzedDataProvider20ConsumeFloatingPointIdEET_v:
  240|    118|template <typename T> T FuzzedDataProvider::ConsumeFloatingPoint() {
  241|    118|  return ConsumeFloatingPointInRange<T>(std::numeric_limits<T>::lowest(),
  242|    118|                                        std::numeric_limits<T>::max());
  243|    118|}
_ZN18FuzzedDataProvider27ConsumeFloatingPointInRangeIdEET_S1_S1_:
  249|    118|T FuzzedDataProvider::ConsumeFloatingPointInRange(T min, T max) {
  250|    118|  if (min > max)
  ------------------
  |  Branch (250:7): [True: 0, False: 118]
  ------------------
  251|      0|    abort();
  252|       |
  253|    118|  T range = .0;
  254|    118|  T result = min;
  255|    118|  constexpr T zero(.0);
  256|    118|  if (max > zero && min < zero && max > min + std::numeric_limits<T>::max()) {
  ------------------
  |  Branch (256:7): [True: 118, False: 0]
  |  Branch (256:21): [True: 118, False: 0]
  |  Branch (256:35): [True: 118, False: 0]
  ------------------
  257|       |    // The diff |max - min| would overflow the given floating point type. Use
  258|       |    // the half of the diff as the range and consume a bool to decide whether
  259|       |    // the result is in the first of the second part of the diff.
  260|    118|    range = (max / 2.0) - (min / 2.0);
  261|    118|    if (ConsumeBool()) {
  ------------------
  |  Branch (261:9): [True: 46, False: 72]
  ------------------
  262|     46|      result += range;
  263|     46|    }
  264|    118|  } else {
  265|      0|    range = max - min;
  266|      0|  }
  267|       |
  268|    118|  return result + range * ConsumeProbability<T>();
  269|    118|}
_ZN18FuzzedDataProvider18ConsumeProbabilityIdEET_v:
  273|    118|template <typename T> T FuzzedDataProvider::ConsumeProbability() {
  274|    118|  static_assert(std::is_floating_point<T>::value,
  275|    118|                "A floating point type is required.");
  276|       |
  277|       |  // Use different integral types for different floating point types in order
  278|       |  // to provide better density of the resulting values.
  279|    118|  using IntegralType =
  280|    118|      typename std::conditional<(sizeof(T) <= sizeof(uint32_t)), uint32_t,
  281|    118|                                uint64_t>::type;
  282|       |
  283|    118|  T result = static_cast<T>(ConsumeIntegral<IntegralType>());
  284|    118|  result /= static_cast<T>(std::numeric_limits<IntegralType>::max());
  285|    118|  return result;
  286|    118|}
_ZN18FuzzedDataProvider16PickValueInArrayIdEET_St16initializer_listIKS1_E:
  316|     34|T FuzzedDataProvider::PickValueInArray(std::initializer_list<const T> list) {
  317|       |  // TODO(Dor1s): switch to static_assert once C++14 is allowed.
  318|     34|  if (!list.size())
  ------------------
  |  Branch (318:7): [True: 0, False: 34]
  ------------------
  319|      0|    abort();
  320|       |
  321|     34|  return *(list.begin() + ConsumeIntegralInRange<size_t>(0, list.size() - 1));
  322|     34|}

_Z17float_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEE:
   17|    310|{
   18|    310|    FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
   19|       |
   20|    310|    {
   21|    310|        const double d{[&] {
   22|    310|            std::optional<double> tmp;
   23|    310|            CallOneOf(
   24|    310|                fuzzed_data_provider,
   25|       |                // an actual number
   26|    310|                [&] { tmp = fuzzed_data_provider.ConsumeFloatingPoint<double>(); },
   27|       |                // special numbers and NANs
   28|    310|                [&] { tmp = fuzzed_data_provider.PickValueInArray({
   29|    310|                          std::numeric_limits<double>::infinity(),
   30|    310|                          -std::numeric_limits<double>::infinity(),
   31|    310|                          std::numeric_limits<double>::min(),
   32|    310|                          -std::numeric_limits<double>::min(),
   33|    310|                          std::numeric_limits<double>::max(),
   34|    310|                          -std::numeric_limits<double>::max(),
   35|    310|                          std::numeric_limits<double>::lowest(),
   36|    310|                          -std::numeric_limits<double>::lowest(),
   37|    310|                          std::numeric_limits<double>::quiet_NaN(),
   38|    310|                          -std::numeric_limits<double>::quiet_NaN(),
   39|    310|                          std::numeric_limits<double>::signaling_NaN(),
   40|    310|                          -std::numeric_limits<double>::signaling_NaN(),
   41|    310|                          std::numeric_limits<double>::denorm_min(),
   42|    310|                          -std::numeric_limits<double>::denorm_min(),
   43|    310|                      }); },
   44|       |                // Anything from raw memory (also checks that DecodeDouble doesn't crash on any input)
   45|    310|                [&] { tmp = DecodeDouble(fuzzed_data_provider.ConsumeIntegral<uint64_t>()); });
   46|    310|            return *tmp;
   47|    310|        }()};
   48|    310|        (void)memusage::DynamicUsage(d);
   49|       |
   50|    310|        uint64_t encoded = EncodeDouble(d);
   51|    310|        if constexpr (std::numeric_limits<double>::is_iec559) {
   52|    310|            if (!std::isnan(d)) {
  ------------------
  |  Branch (52:17): [True: 254, False: 56]
  ------------------
   53|    254|                uint64_t encoded_in_memory;
   54|    254|                std::copy((const unsigned char*)&d, (const unsigned char*)(&d + 1), (unsigned char*)&encoded_in_memory);
   55|    254|                assert(encoded_in_memory == encoded);
   56|    254|            }
   57|    310|        }
   58|    310|        double d_deserialized = DecodeDouble(encoded);
   59|    310|        assert(std::isnan(d) == std::isnan(d_deserialized));
   60|    310|        assert(std::isnan(d) || d == d_deserialized);
   61|    310|    }
   62|    310|}
float.cpp:_ZZ17float_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_0clEv:
   21|    310|        const double d{[&] {
   22|    310|            std::optional<double> tmp;
   23|    310|            CallOneOf(
   24|    310|                fuzzed_data_provider,
   25|       |                // an actual number
   26|    310|                [&] { tmp = fuzzed_data_provider.ConsumeFloatingPoint<double>(); },
   27|       |                // special numbers and NANs
   28|    310|                [&] { tmp = fuzzed_data_provider.PickValueInArray({
   29|    310|                          std::numeric_limits<double>::infinity(),
   30|    310|                          -std::numeric_limits<double>::infinity(),
   31|    310|                          std::numeric_limits<double>::min(),
   32|    310|                          -std::numeric_limits<double>::min(),
   33|    310|                          std::numeric_limits<double>::max(),
   34|    310|                          -std::numeric_limits<double>::max(),
   35|    310|                          std::numeric_limits<double>::lowest(),
   36|    310|                          -std::numeric_limits<double>::lowest(),
   37|    310|                          std::numeric_limits<double>::quiet_NaN(),
   38|    310|                          -std::numeric_limits<double>::quiet_NaN(),
   39|    310|                          std::numeric_limits<double>::signaling_NaN(),
   40|    310|                          -std::numeric_limits<double>::signaling_NaN(),
   41|    310|                          std::numeric_limits<double>::denorm_min(),
   42|    310|                          -std::numeric_limits<double>::denorm_min(),
   43|    310|                      }); },
   44|       |                // Anything from raw memory (also checks that DecodeDouble doesn't crash on any input)
   45|    310|                [&] { tmp = DecodeDouble(fuzzed_data_provider.ConsumeIntegral<uint64_t>()); });
   46|    310|            return *tmp;
   47|    310|        }()};
float.cpp:_ZZZ17float_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_0clEvENKUlvE_clEv:
   26|    118|                [&] { tmp = fuzzed_data_provider.ConsumeFloatingPoint<double>(); },
float.cpp:_ZZZ17float_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_0clEvENKUlvE0_clEv:
   28|     34|                [&] { tmp = fuzzed_data_provider.PickValueInArray({
   29|     34|                          std::numeric_limits<double>::infinity(),
   30|     34|                          -std::numeric_limits<double>::infinity(),
   31|     34|                          std::numeric_limits<double>::min(),
   32|     34|                          -std::numeric_limits<double>::min(),
   33|     34|                          std::numeric_limits<double>::max(),
   34|     34|                          -std::numeric_limits<double>::max(),
   35|     34|                          std::numeric_limits<double>::lowest(),
   36|     34|                          -std::numeric_limits<double>::lowest(),
   37|     34|                          std::numeric_limits<double>::quiet_NaN(),
   38|     34|                          -std::numeric_limits<double>::quiet_NaN(),
   39|     34|                          std::numeric_limits<double>::signaling_NaN(),
   40|     34|                          -std::numeric_limits<double>::signaling_NaN(),
   41|     34|                          std::numeric_limits<double>::denorm_min(),
   42|     34|                          -std::numeric_limits<double>::denorm_min(),
   43|     34|                      }); },
float.cpp:_ZZZ17float_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_0clEvENKUlvE1_clEv:
   45|    158|                [&] { tmp = DecodeDouble(fuzzed_data_provider.ConsumeIntegral<uint64_t>()); });

LLVMFuzzerTestOneInput:
  222|    310|{
  223|    310|    test_one_input({data, size});
  224|    310|    return 0;
  225|    310|}
fuzz.cpp:_ZL14test_one_inputNSt3__14spanIKhLm18446744073709551615EEE:
   83|    310|{
   84|    310|    CheckGlobals check{};
   85|    310|    (*Assert(g_test_one_input))(buffer);
  ------------------
  |  |   85|    310|#define Assert(val) inline_assertion_check<true>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
   86|    310|}

float.cpp:_Z9CallOneOfIJZZ17float_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_0clEvEUlvE_ZZ17float_fuzz_targetS3_ENKS4_clEvEUlvE0_ZZ17float_fuzz_targetS3_ENKS4_clEvEUlvE1_EEmR18FuzzedDataProviderDpT_:
   36|    310|{
   37|    310|    constexpr size_t call_size{sizeof...(callables)};
   38|    310|    static_assert(call_size >= 1);
   39|    310|    const size_t call_index{fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, call_size - 1)};
   40|       |
   41|    310|    size_t i{0};
   42|    930|    ((i++ == call_index ? callables() : void()), ...);
  ------------------
  |  Branch (42:7): [True: 118, False: 192]
  |  Branch (42:7): [True: 34, False: 276]
  |  Branch (42:7): [True: 158, False: 152]
  ------------------
   43|    310|    return call_size;
   44|    310|}

_ZN12CheckGlobalsC2Ev:
   56|    310|CheckGlobals::CheckGlobals() : m_impl(std::make_unique<CheckGlobalsImpl>()) {}
_ZN12CheckGlobalsD2Ev:
   57|    310|CheckGlobals::~CheckGlobals() = default;
_ZN16CheckGlobalsImplC2Ev:
   17|    310|    {
   18|    310|        g_used_g_prng = false;
   19|    310|        g_seeded_g_prng_zero = false;
   20|    310|        g_used_system_time = false;
   21|    310|        SetMockTime(0s);
   22|    310|    }
_ZN16CheckGlobalsImplD2Ev:
   24|    310|    {
   25|    310|        if (g_used_g_prng && !g_seeded_g_prng_zero) {
  ------------------
  |  Branch (25:13): [True: 0, False: 310]
  |  Branch (25:30): [True: 0, False: 0]
  ------------------
   26|      0|            std::cerr << "\n\n"
   27|      0|                         "The current fuzz target used the global random state.\n\n"
   28|       |
   29|      0|                         "This is acceptable, but requires the fuzz target to call \n"
   30|      0|                         "SeedRandomStateForTest(SeedRand::ZEROS) in the first line \n"
   31|      0|                         "of the FUZZ_TARGET function.\n\n"
   32|       |
   33|      0|                         "An alternative solution would be to avoid any use of globals.\n\n"
   34|       |
   35|      0|                         "Without a solution, fuzz instability and non-determinism can lead \n"
   36|      0|                         "to non-reproducible bugs or inefficient fuzzing.\n\n"
   37|      0|                      << std::endl;
   38|      0|            std::abort(); // Abort, because AFL may try to recover from a std::exit
   39|      0|        }
   40|       |
   41|    310|        if (g_used_system_time) {
  ------------------
  |  Branch (41:13): [True: 0, False: 310]
  ------------------
   42|      0|            std::cerr << "\n\n"
   43|      0|                         "The current fuzz target accessed system time.\n\n"
   44|       |
   45|      0|                         "This is acceptable, but requires the fuzz target to call \n"
   46|      0|                         "SetMockTime() at the beginning of processing the fuzz input.\n\n"
   47|       |
   48|      0|                         "Without setting mock time, time-dependent behavior can lead \n"
   49|      0|                         "to non-reproducible bugs or inefficient fuzzing.\n\n"
   50|      0|                      << std::endl;
   51|      0|            std::abort();
   52|      0|        }
   53|    310|    }

_Z22inline_assertion_checkILb1EbEOT0_S1_PKciS3_S3_:
   52|    310|{
   53|    310|    if (IS_ASSERT || std::is_constant_evaluated() || G_FUZZING
  ------------------
  |  Branch (53:9): [Folded - Ignored]
  |  Branch (53:22): [Folded - Ignored]
  |  Branch (53:54): [Folded - Ignored]
  ------------------
   54|       |#ifdef ABORT_ON_FAILED_ASSUME
   55|       |        || true
   56|       |#endif
   57|    310|    ) {
   58|    310|        if (!val) {
  ------------------
  |  Branch (58:13): [True: 0, False: 310]
  ------------------
   59|      0|            assertion_fail(file, line, func, assertion);
   60|      0|        }
   61|    310|    }
   62|    310|    return std::forward<T>(val);
   63|    310|}
_Z22inline_assertion_checkILb1ERPKNSt3__18functionIFvNS0_4spanIKhLm18446744073709551615EEEEEEEOT0_SB_PKciSD_SD_:
   52|    310|{
   53|    310|    if (IS_ASSERT || std::is_constant_evaluated() || G_FUZZING
  ------------------
  |  Branch (53:9): [Folded - Ignored]
  |  Branch (53:22): [Folded - Ignored]
  |  Branch (53:54): [Folded - Ignored]
  ------------------
   54|       |#ifdef ABORT_ON_FAILED_ASSUME
   55|       |        || true
   56|       |#endif
   57|    310|    ) {
   58|    310|        if (!val) {
  ------------------
  |  Branch (58:13): [True: 0, False: 310]
  ------------------
   59|      0|            assertion_fail(file, line, func, assertion);
   60|      0|        }
   61|    310|    }
   62|    310|    return std::forward<T>(val);
   63|    310|}

_Z12DecodeDoublem:
   10|    468|double DecodeDouble(uint64_t v) noexcept {
   11|    468|    static constexpr double NANVAL = std::numeric_limits<double>::quiet_NaN();
   12|    468|    static constexpr double INFVAL = std::numeric_limits<double>::infinity();
   13|    468|    double sign = 1.0;
   14|    468|    if (v & 0x8000000000000000) {
  ------------------
  |  Branch (14:9): [True: 206, False: 262]
  ------------------
   15|    206|        sign = -1.0;
   16|    206|        v ^= 0x8000000000000000;
   17|    206|    }
   18|       |    // Zero
   19|    468|    if (v == 0) return copysign(0.0, sign);
  ------------------
  |  Branch (19:9): [True: 22, False: 446]
  ------------------
   20|       |    // Infinity
   21|    446|    if (v == 0x7ff0000000000000) return copysign(INFVAL, sign);
  ------------------
  |  Branch (21:9): [True: 12, False: 434]
  ------------------
   22|       |    // Other numbers
   23|    434|    int exp = (v & 0x7FF0000000000000) >> 52;
   24|    434|    uint64_t man = v & 0xFFFFFFFFFFFFF;
   25|    434|    if (exp == 2047) {
  ------------------
  |  Branch (25:9): [True: 109, False: 325]
  ------------------
   26|       |        // NaN
   27|    109|        return NANVAL;
   28|    325|    } else if (exp == 0) {
  ------------------
  |  Branch (28:16): [True: 90, False: 235]
  ------------------
   29|       |        // Subnormal
   30|     90|        return copysign(ldexp((double)man, -1074), sign);
   31|    235|    } else {
   32|       |        // Normal
   33|    235|        return copysign(ldexp((double)(man + 0x10000000000000), -1075 + exp), sign);
   34|    235|    }
   35|    434|}
_Z12EncodeDoubled:
   37|    310|uint64_t EncodeDouble(double f) noexcept {
   38|    310|    int cls = std::fpclassify(f);
   39|    310|    uint64_t sign = 0;
   40|    310|    if (copysign(1.0, f) == -1.0) {
  ------------------
  |  Branch (40:9): [True: 123, False: 187]
  ------------------
   41|    123|        f = -f;
   42|    123|        sign = 0x8000000000000000;
   43|    123|    }
   44|       |    // Zero
   45|    310|    if (cls == FP_ZERO) return sign;
  ------------------
  |  Branch (45:9): [True: 13, False: 297]
  ------------------
   46|       |    // Infinity
   47|    297|    if (cls == FP_INFINITE) return sign | 0x7ff0000000000000;
  ------------------
  |  Branch (47:9): [True: 11, False: 286]
  ------------------
   48|       |    // NaN
   49|    286|    if (cls == FP_NAN) return 0x7ff8000000000000;
  ------------------
  |  Branch (49:9): [True: 56, False: 230]
  ------------------
   50|       |    // Other numbers
   51|    230|    int exp;
   52|    230|    uint64_t man = std::round(std::frexp(f, &exp) * 9007199254740992.0);
   53|    230|    if (exp < -1021) {
  ------------------
  |  Branch (53:9): [True: 46, False: 184]
  ------------------
   54|       |        // Too small to represent, encode 0
   55|     46|        if (exp < -1084) return sign;
  ------------------
  |  Branch (55:13): [True: 0, False: 46]
  ------------------
   56|       |        // Subnormal numbers
   57|     46|        return sign | (man >> (-1021 - exp));
   58|    184|    } else {
   59|       |        // Too big to represent, encode infinity
   60|    184|        if (exp > 1024) return sign | 0x7ff0000000000000;
  ------------------
  |  Branch (60:13): [True: 0, False: 184]
  ------------------
   61|       |        // Normal numbers
   62|    184|        return sign | (((uint64_t)(1022 + exp)) << 52) | (man & 0xFFFFFFFFFFFFF);
   63|    184|    }
   64|    230|}

_Z11SetMockTimeNSt3__16chrono8durationIxNS_5ratioILl1ELl1EEEEE:
   42|    310|{
   43|    310|    Assert(mock_time_in >= 0s);
  ------------------
  |  |   85|    310|#define Assert(val) inline_assertion_check<true>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
   44|    310|    g_mock_time.store(mock_time_in, std::memory_order_relaxed);
   45|    310|}