LLVMFuzzerTestOneInput:
    7|  2.41k|{
    8|  2.41k|	std::string input(reinterpret_cast<const char*>(data), size);
    9|  2.41k|	try {
   10|  2.41k|        if (size < 5000) // Tests show that it will compute for very large size, but size 316737 taxes Google fuzz patience
  ------------------
  |  Branch (10:13): [True: 2.37k, False: 40]
  ------------------
   11|  2.37k|        {
   12|  2.37k|            bigint a("56654250564056135415631554531554513813");
   13|  2.37k|            bigint b(input);
   14|  2.37k|            bigint c = a % b;
   15|  2.37k|            bigint d = b % a;
   16|  2.37k|        }
   17|  2.41k|	}
   18|  2.41k|	catch (const std::runtime_error&) {}
   19|       |
   20|  2.41k|	return 0;
   21|  2.41k|}

_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2IcEEPKT_RKS3_:
  650|  2.37k|        : storage_(alloc)
  651|  2.37k|    {
  652|  2.37k|        auto r = jsoncons::to_bigint(s, std::char_traits<CharT>::length(s), *this, alloc);
  653|  2.37k|        if (r.ec != std::errc{})
  ------------------
  |  Branch (653:13): [True: 0, False: 2.37k]
  ------------------
  654|      0|        {
  655|      0|            JSONCONS_THROW(std::system_error((int)r.ec, std::system_category()));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  656|      0|        }
  657|  2.37k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2ERKS4_:
  293|  9.88k|        : word_allocator_type(alloc)
  294|  9.88k|    {
  295|  9.88k|        ::new (&inlined_) inlined_storage();
  296|  9.88k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2Ev:
  113|  9.88k|            : is_allocated_(false),
  114|  9.88k|            is_negative_(false),
  115|  9.88k|            size_(0),
  116|  9.88k|            values_{0, 0}
  117|  9.88k|        {
  118|  9.88k|        }
_ZN8jsoncons9to_bigintIcNSt3__19allocatorImEEEENS_16to_bigint_resultIT_EEPKS5_mRNS_12basic_bigintIT0_EERKSA_:
 2110|  2.37k|{
 2111|  2.37k|    if (JSONCONS_UNLIKELY(length == 0))
  ------------------
  |  |   78|  2.37k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 2.37k]
  |  |  ------------------
  ------------------
 2112|      0|    {
 2113|      0|        return to_bigint_result<CharT>(data, std::errc::invalid_argument);
 2114|      0|    }
 2115|       |
 2116|  2.37k|    if (*data == '-')
  ------------------
  |  Branch (2116:9): [True: 0, False: 2.37k]
  ------------------
 2117|      0|    {
 2118|      0|        return jsoncons::detail::to_bigint(data + 1, length - 1, true, value, alloc);
 2119|      0|    }
 2120|  2.37k|    else
 2121|  2.37k|    {
 2122|  2.37k|        return jsoncons::detail::to_bigint(data, length, false, value, alloc);
 2123|  2.37k|    }
 2124|  2.37k|}
_ZN8jsoncons16to_bigint_resultIcEC2EPKcNSt3__14errcE:
  569|  4.74k|        : ptr(ptr_), ec(ec_)
  570|  4.74k|    {
  571|  4.74k|    }
_ZN8jsoncons6detail9to_bigintIcNSt3__19allocatorImEEEENS_16to_bigint_resultIT_EEPKS6_mbRNS_12basic_bigintIT0_EERKSB_:
 2048|  4.74k|{
 2049|  4.74k|    if (JSONCONS_UNLIKELY(length == 0))
  ------------------
  |  |   78|  4.74k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1, False: 4.74k]
  |  |  ------------------
  ------------------
 2050|      1|    {
 2051|      1|        return to_bigint_result<CharT>(data, std::errc::invalid_argument);
 2052|      1|    }
 2053|       |
 2054|  4.74k|    using word_type = typename basic_bigint<Allocator>::word_type;
 2055|       |
 2056|  4.74k|    const CharT* last = data + length;
 2057|  4.74k|    const CharT* p = data;
 2058|       |
 2059|  7.31k|    while (p < last && *p == '0')
  ------------------
  |  Branch (2059:12): [True: 7.30k, False: 10]
  |  Branch (2059:24): [True: 2.56k, False: 4.73k]
  ------------------
 2060|  2.56k|    {
 2061|  2.56k|        ++p;
 2062|  2.56k|    }
 2063|  4.74k|    if (p == last)
  ------------------
  |  Branch (2063:9): [True: 10, False: 4.73k]
  ------------------
 2064|     10|    {
 2065|     10|        value = std::move(basic_bigint<Allocator>{0, alloc});
 2066|     10|        return to_bigint_result<CharT>(last, std::errc{});
 2067|     10|    }
 2068|  4.73k|    std::size_t num_digits = last - data;
 2069|  4.73k|    std::size_t num_words;
 2070|  4.73k|    if (length < 10)
  ------------------
  |  Branch (2070:9): [True: 131, False: 4.60k]
  ------------------
 2071|    131|    {
 2072|    131|        num_words = 1;
 2073|    131|    }
 2074|  4.60k|    else
 2075|  4.60k|    {
 2076|  4.60k|        std::size_t num_bits = (std::size_t)(((num_digits * detail::bits_per_digit[10]) >> 10) + 1);
 2077|  4.60k|        num_words = (num_bits + 63) >> 6;
 2078|  4.60k|    }
 2079|       |
 2080|  4.73k|    basic_bigint<Allocator> v(0, alloc);
 2081|  4.73k|    v.reserve(num_words);
 2082|   343k|    for (std::size_t i = 0; i < length; i++)
  ------------------
  |  Branch (2082:29): [True: 339k, False: 4.66k]
  ------------------
 2083|   339k|    {
 2084|   339k|        CharT c = data[i];
 2085|   339k|        if (JSONCONS_LIKELY(c >= '0' && c <= '9'))
  ------------------
  |  |   77|   678k|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 339k, False: 73]
  |  |  |  Branch (77:48): [True: 339k, False: 60]
  |  |  |  Branch (77:48): [True: 339k, False: 13]
  |  |  ------------------
  ------------------
 2086|   339k|        {
 2087|   339k|            v *= 10u;
 2088|   339k|            v += (word_type)(c - '0');
 2089|   339k|        }
 2090|     73|        else
 2091|     73|        {
 2092|     73|            return to_bigint_result<CharT>(data + i, std::errc::invalid_argument);
 2093|     73|        }
 2094|   339k|    }
 2095|       |
 2096|  4.66k|    if (neg)
  ------------------
  |  Branch (2096:9): [True: 4, False: 4.65k]
  ------------------
 2097|      4|    {
 2098|      4|        v.set_negative(true);
 2099|      4|    }
 2100|       |
 2101|  4.66k|    value = std::move(v);
 2102|  4.66k|    return to_bigint_result<CharT>(last, std::errc{});
 2103|  4.73k|}
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2IiEET_RKS3_PNS1_9enable_ifIXsr3std11is_integralIS6_EE5valueEvE4typeE:
  693|  4.74k|        : storage_(n, alloc)
  694|  4.74k|    {
  695|  4.74k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2IiEET_RKS4_PNS2_9enable_ifIXsr3std11is_integralIS7_EE5valueEvE4typeE:
  360|  4.74k|        : word_allocator_type(alloc)
  361|  4.74k|    {
  362|  4.74k|        ::new (&inlined_) inlined_storage(n);
  363|  4.74k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2IiEET_PNS2_9enable_ifIXaaaasr3std11is_integralIS8_EE5valuelestS8_Lm8Esr3std9is_signedIS8_EE5valueEvE4typeE:
  125|  4.74k|            : is_allocated_(false),
  126|  4.74k|            is_negative_(n < 0),
  127|  4.74k|            size_(n == 0 ? 0 : 1)
  ------------------
  |  Branch (127:19): [True: 4.74k, False: 0]
  ------------------
  128|  4.74k|        {
  129|  4.74k|            values_[0] = n < 0 ? (word_type(0) - static_cast<word_type>(n)) : static_cast<word_type>(n);
  ------------------
  |  Branch (129:26): [True: 0, False: 4.74k]
  ------------------
  130|  4.74k|            values_[1] = 0;
  131|  4.74k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEaSERKS4_:
  842|  12.0k|    {
  843|  12.0k|        storage_ = y.storage_;
  844|  12.0k|        return *this;
  845|  12.0k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEaSERKS5_:
  366|  12.0k|    {
  367|  12.0k|        if (this != &other)
  ------------------
  |  Branch (367:13): [True: 12.0k, False: 0]
  ------------------
  368|  12.0k|        {
  369|  12.0k|            auto other_view = other.get_storage_view();
  370|  12.0k|            resize(other_view.size());
  371|  12.0k|            auto this_view = get_storage_view();
  372|  12.0k|            if (other_view.size() > 0)
  ------------------
  |  Branch (372:17): [True: 9.78k, False: 2.30k]
  ------------------
  373|  9.78k|            {
  374|  9.78k|                common_.is_negative_ = other.common_.is_negative_;
  375|  9.78k|                std::memcpy(this_view.data(), other_view.data(), size_type(other_view.size()*sizeof(word_type)));
  376|  9.78k|            }
  377|  12.0k|        }
  378|  12.0k|        return *this;
  379|  12.0k|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE16get_storage_viewEv:
  527|  25.1k|    {
  528|  25.1k|        return common_.is_allocated_ ? 
  ------------------
  |  Branch (528:16): [True: 8.54k, False: 16.6k]
  ------------------
  529|  8.54k|            storage_view<const word_type>{allocated_.data_, allocated_.size_} :
  530|  25.1k|            storage_view<const word_type>{inlined_.values_, inlined_.size_};
  531|  25.1k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewIKmEC2EPS7_m:
   64|  25.1k|            : data_(data), size_(size)
   65|  25.1k|        {
   66|  25.1k|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE6resizeEm:
  534|   698k|    {
  535|   698k|        size_type old_length = common_.size_;
  536|   698k|        reserve(new_length);
  537|   698k|        common_.size_ = new_length;
  538|       |
  539|   698k|        if (old_length < new_length)
  ------------------
  |  Branch (539:13): [True: 692k, False: 6.17k]
  ------------------
  540|   692k|        {
  541|   692k|            if (is_allocated())
  ------------------
  |  Branch (541:17): [True: 530k, False: 162k]
  ------------------
  542|   530k|            {
  543|   530k|                std::memset(allocated_.data_+old_length, 0, size_type((new_length-old_length)*sizeof(word_type)));
  544|   530k|            }
  545|   162k|            else
  546|   162k|            {
  547|   162k|                JSONCONS_ASSERT(new_length <= inlined_capacity);
  ------------------
  |  |   49|   162k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 162k]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  548|   339k|                for (size_type i = old_length; i < inlined_capacity; ++i)
  ------------------
  |  Branch (548:48): [True: 177k, False: 162k]
  ------------------
  549|   177k|                {
  550|   177k|                    inlined_.values_[i] = 0;
  551|   177k|                }
  552|   162k|            }
  553|   692k|        }
  554|   698k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE7reserveEm:
  452|   703k|    {
  453|   703k|       if (capacity() < n)
  ------------------
  |  Branch (453:12): [True: 9.46k, False: 693k]
  ------------------
  454|  9.46k|       {
  455|  9.46k|           if (!is_allocated())
  ------------------
  |  Branch (455:16): [True: 9.46k, False: 0]
  ------------------
  456|  9.46k|           {
  457|  9.46k|               size_type size = inlined_.size_;
  458|  9.46k|               size_type is_neg = inlined_.is_negative_;
  459|  9.46k|               word_type values[inlined_capacity] = {inlined_.values_[0], inlined_.values_[1]};
  460|       |
  461|  9.46k|               ::new (&allocated_) allocated_storage();
  462|  9.46k|               allocated_.reserve(n, get_allocator());
  463|  9.46k|               allocated_.size_ = size;
  464|  9.46k|               allocated_.is_negative_ = is_neg;
  465|  9.46k|               if (n >= 1)
  ------------------
  |  Branch (465:20): [True: 9.46k, False: 0]
  ------------------
  466|  9.46k|               {
  467|  9.46k|                   allocated_.data_[0] = values[0];
  468|  9.46k|               }
  469|  9.46k|               if (n >= 2)
  ------------------
  |  Branch (469:20): [True: 9.46k, False: 0]
  ------------------
  470|  9.46k|               {
  471|  9.46k|                   allocated_.data_[1] = values[1];
  472|  9.46k|               }
  473|  9.46k|           }
  474|      0|           else
  475|      0|           {
  476|      0|               allocated_.reserve(n, get_allocator());
  477|      0|           }
  478|  9.46k|       }
  479|   703k|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE8capacityEv:
  505|   703k|    {
  506|   703k|        return is_allocated() ? allocated_.capacity_ : inlined_capacity;
  ------------------
  |  Branch (506:16): [True: 521k, False: 181k]
  ------------------
  507|   703k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storageC2Ev:
  203|  9.46k|            : is_allocated_(true),
  204|  9.46k|            is_negative_(false)
  205|  9.46k|        {
  206|  9.46k|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storage7reserveEmRKS4_:
  255|  9.46k|        {
  256|  9.46k|            JSONCONS_ASSERT(n < max_size);
  ------------------
  |  |   49|  9.46k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 9.46k]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  257|  9.46k|            size_type capacity_new = round_up(n);
  258|       |
  259|  9.46k|            real_allocator_type alloc(a);
  260|  9.46k|            word_type* data_new = std::allocator_traits<real_allocator_type>::allocate(alloc, capacity_new);
  261|  9.46k|            if (size_ > 0)
  ------------------
  |  Branch (261:17): [True: 0, False: 9.46k]
  ------------------
  262|      0|            {
  263|      0|                std::memcpy(data_new, data_, size_type(size_ * sizeof(word_type)));
  264|      0|            }
  265|  9.46k|            if (data_ != nullptr)
  ------------------
  |  Branch (265:17): [True: 0, False: 9.46k]
  ------------------
  266|      0|            {
  267|      0|                std::allocator_traits<real_allocator_type>::deallocate(alloc, data_, capacity_);
  268|      0|            }
  269|  9.46k|            capacity_ = capacity_new;
  270|  9.46k|            data_ = data_new;
  271|  9.46k|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storage8round_upEm:
  275|  9.46k|        {
  276|  9.46k|            size_type remainder = i % mem_unit;
  277|  9.46k|            size_type off = mem_unit - remainder;
  278|  9.46k|            bool testoff = i < max_size - off;
  279|  9.46k|            JSONCONS_ASSERT(testoff);
  ------------------
  |  |   49|  9.46k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 9.46k]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  280|       |
  281|  9.46k|            return i + off;
  282|  9.46k|        }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE13get_allocatorEv:
  482|  50.4k|    {
  483|  50.4k|        return static_cast<const word_allocator_type&>(*this);
  484|  50.4k|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12is_allocatedEv:
  500|  1.47M|    {
  501|  1.47M|        return common_.is_allocated_;
  502|  1.47M|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewIKmE4sizeEv:
   84|  55.4k|        {
   85|  55.4k|            return size_;
   86|  55.4k|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE16get_storage_viewEv:
  520|  2.10M|    {
  521|  2.10M|        return common_.is_allocated_ ? 
  ------------------
  |  Branch (521:16): [True: 1.59M, False: 505k]
  ------------------
  522|  1.59M|            storage_view<word_type>{allocated_.data_, allocated_.size_} :
  523|  2.10M|            storage_view<word_type>{inlined_.values_, inlined_.size_};
  524|  2.10M|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImEC2EPmm:
   64|  2.10M|            : data_(data), size_(size)
   65|  2.10M|        {
   66|  2.10M|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImE4dataEv:
   79|  34.4k|        {
   80|  34.4k|            return data_;
   81|  34.4k|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewIKmE4dataEv:
   79|  9.78k|        {
   80|  9.78k|            return data_;
   81|  9.78k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE7reserveEm:
  823|  4.73k|    {
  824|  4.73k|        storage_.reserve(n);
  825|  4.73k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEmLIjEENS1_9enable_ifIXsr10ext_traits19is_unsigned_integerIT_EE5valueERS4_E4typeES7_:
  998|   339k|    {
  999|   339k|        auto this_view = get_storage_view();
 1000|   339k|        size_type len0 = this_view.size();
 1001|   339k|        word_type dig = this_view[0];
 1002|   339k|        word_type carry = 0;
 1003|       |
 1004|   339k|        resize(this_view.size() + 1);
 1005|   339k|        this_view = get_storage_view();
 1006|       |
 1007|   339k|        size_type i = 0;
 1008|  14.0M|        for (; i < len0; i++ )
  ------------------
  |  Branch (1008:16): [True: 13.7M, False: 339k]
  ------------------
 1009|  13.7M|        {
 1010|  13.7M|            word_type hi;
 1011|  13.7M|            word_type lo;
 1012|  13.7M|            DDproduct( dig, y, hi, lo );
 1013|  13.7M|            this_view[i] = lo + carry;
 1014|  13.7M|            dig = this_view[i+1];
 1015|  13.7M|            carry = hi + (this_view[i] < lo);
 1016|  13.7M|        }
 1017|   339k|        this_view[i] = carry;
 1018|   339k|        reduce();
 1019|   339k|        return *this;
 1020|   339k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE16get_storage_viewEv:
  718|  1.39M|    {
  719|  1.39M|        return storage_.get_storage_view();
  720|  1.39M|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImE4sizeEv:
   84|  1.39M|        {
   85|  1.39M|            return size_;
   86|  1.39M|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImEixEm:
   69|  43.0M|        {
   70|  43.0M|            return data_[i];
   71|  43.0M|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE6resizeEm:
  818|   686k|    {
  819|   686k|        storage_.resize(new_length);
  820|   686k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE9DDproductEmmRmS5_:
 1781|  13.7M|    {
 1782|  13.7M|        word_type hiA = A >> word_type_half_bits, loA = A & r_mask,
 1783|  13.7M|                   hiB = B >> word_type_half_bits, loB = B & r_mask;
 1784|       |
 1785|  13.7M|        lo = loA * loB;
 1786|  13.7M|        hi = hiA * hiB;
 1787|  13.7M|        word_type mid1 = loA * hiB;
 1788|  13.7M|        word_type mid2 = hiA * loB;
 1789|  13.7M|        word_type old = lo;
 1790|  13.7M|        lo += mid1 << word_type_half_bits;
 1791|  13.7M|            hi += (lo < old) + (mid1 >> word_type_half_bits);
 1792|  13.7M|        old = lo;
 1793|  13.7M|        lo += mid2 << word_type_half_bits;
 1794|  13.7M|            hi += (lo < old) + (mid2 >> word_type_half_bits);
 1795|  13.7M|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE6reduceEv:
 1917|   689k|    {
 1918|   689k|        storage_.reduce();
 1919|   689k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE6reduceEv:
  429|   689k|    {
  430|   689k|        if (common_.size_ > 0)
  ------------------
  |  Branch (430:13): [True: 689k, False: 0]
  ------------------
  431|   689k|        {
  432|   689k|            auto this_view = get_storage_view();
  433|   689k|            word_type* p = this_view.end() - 1;
  434|   689k|            word_type* first = this_view.begin();
  435|  1.36M|            while ( p >= first )
  ------------------
  |  Branch (435:21): [True: 1.35M, False: 9.38k]
  ------------------
  436|  1.35M|            {
  437|  1.35M|                if ( *p )
  ------------------
  |  Branch (437:22): [True: 680k, False: 673k]
  ------------------
  438|   680k|                {
  439|   680k|                    break;
  440|   680k|                }
  441|   673k|                --common_.size_;
  442|   673k|                --p;
  443|   673k|            }
  444|   689k|        }
  445|   689k|        if (common_.size_ == 0)
  ------------------
  |  Branch (445:13): [True: 9.38k, False: 680k]
  ------------------
  446|  9.38k|        {
  447|  9.38k|            common_.is_negative_ = false;
  448|  9.38k|        }
  449|   689k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImE3endEv:
   93|   689k|        {
   94|   689k|            return data_ + size_;
   95|   689k|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImE5beginEv:
   88|   689k|        {
   89|   689k|            return data_;
   90|   689k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEpLImEENS1_9enable_ifIXaasr10ext_traits19is_unsigned_integerIT_EE5valuelestS7_Lm8EERS4_E4typeES7_:
  889|   339k|    {
  890|   339k|        if ( is_negative())
  ------------------
  |  Branch (890:14): [True: 0, False: 339k]
  ------------------
  891|      0|            return *this -= -basic_bigint<Allocator>(y);
  892|       |
  893|   339k|        word_type d;
  894|   339k|        word_type carry = 0;
  895|       |
  896|   339k|        auto this_view = get_storage_view();
  897|   339k|        resize(this_view.size() + 1);
  898|       |
  899|   339k|        this_view = get_storage_view();
  900|   339k|        const size_type this_size = this_view.size();
  901|   339k|        size_type y_size = 1;
  902|       |
  903|   339k|        d = this_view[0] + carry;
  904|   339k|        carry = d < carry;
  905|   339k|        this_view[0] = d + y;
  906|   339k|        if (this_view[0] < d)
  ------------------
  |  Branch (906:13): [True: 508, False: 338k]
  ------------------
  907|    508|            carry = 1;
  908|       |
  909|   339k|        for (size_type i = y_size; i < this_size && carry != 0; ++i)
  ------------------
  |  Branch (909:36): [True: 332k, False: 7.08k]
  |  Branch (909:53): [True: 687, False: 332k]
  ------------------
  910|    687|        {
  911|    687|            d = this_view[i] + carry;
  912|    687|            carry = d < carry;
  913|    687|            this_view[i] = d;
  914|    687|        }
  915|   339k|        reduce();
  916|   339k|        return *this;
  917|   339k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE11is_negativeEv:
  728|   369k|    {
  729|   369k|        return storage_.is_negative();
  730|   369k|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE11is_negativeEv:
  510|   369k|    {
  511|   369k|        return common_.is_negative_;
  512|   369k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2ImEET_RKS3_PNS1_9enable_ifIXsr3std11is_integralIS6_EE5valueEvE4typeE:
  693|  2.98k|        : storage_(n, alloc)
  694|  2.98k|    {
  695|  2.98k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2ImEET_RKS4_PNS2_9enable_ifIXsr3std11is_integralIS7_EE5valueEvE4typeE:
  360|  2.98k|        : word_allocator_type(alloc)
  361|  2.98k|    {
  362|  2.98k|        ::new (&inlined_) inlined_storage(n);
  363|  2.98k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2ImEET_PNS2_9enable_ifIXaaaasr3std11is_integralIS8_EE5valuelestS8_Lm8Entsr3std9is_signedIS8_EE5valueEvE4typeE:
  138|  2.98k|            : is_allocated_(false),
  139|  2.98k|            is_negative_(false),
  140|  2.98k|            size_(n == 0 ? 0 : 1)
  ------------------
  |  Branch (140:19): [True: 2.29k, False: 696]
  ------------------
  141|  2.98k|        {
  142|  2.98k|            values_[0] = n;
  143|  2.98k|            values_[1] = 0;
  144|  2.98k|        }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE16get_storage_viewEv:
  723|  13.0k|    {
  724|  13.0k|        return storage_.get_storage_view();
  725|  13.0k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE7compareERKS4_:
 1641|  5.12k|    {
 1642|  5.12k|        auto this_view = get_storage_view();
 1643|  5.12k|        auto y_view = y.get_storage_view();
 1644|       |
 1645|  5.12k|        const size_type y_size = y_view.size();
 1646|  5.12k|        if ( this_view.size() == 0 && y_size == 0 )
  ------------------
  |  Branch (1646:14): [True: 0, False: 5.12k]
  |  Branch (1646:39): [True: 0, False: 0]
  ------------------
 1647|      0|            return 0;
 1648|  5.12k|        if ( is_negative() != y.is_negative())
  ------------------
  |  Branch (1648:14): [True: 0, False: 5.12k]
  ------------------
 1649|      0|            return y.is_negative() - is_negative();
 1650|  5.12k|        int code = 0;
 1651|  5.12k|        if ( this_view.size() < y_size)
  ------------------
  |  Branch (1651:14): [True: 1.29k, False: 3.83k]
  ------------------
 1652|  1.29k|            code = -1;
 1653|  3.83k|        else if ( this_view.size() > y_size)
  ------------------
  |  Branch (1653:19): [True: 1.83k, False: 1.99k]
  ------------------
 1654|  1.83k|            code = +1;
 1655|  1.99k|        else
 1656|  1.99k|        {
 1657|  2.00k|            for (size_type i = this_view.size(); i-- > 0; )
  ------------------
  |  Branch (1657:50): [True: 2.00k, False: 2]
  ------------------
 1658|  2.00k|            {
 1659|  2.00k|                if (this_view[i] > y_view[i])
  ------------------
  |  Branch (1659:21): [True: 995, False: 1.00k]
  ------------------
 1660|    995|                {
 1661|    995|                    code = 1;
 1662|    995|                    break;
 1663|    995|                }
 1664|  1.00k|                else if (this_view[i] < y_view[i])
  ------------------
  |  Branch (1664:26): [True: 995, False: 10]
  ------------------
 1665|    995|                {
 1666|    995|                    code = -1;
 1667|    995|                    break;
 1668|    995|                }
 1669|  2.00k|            }
 1670|  1.99k|        }
 1671|  5.12k|        return is_negative() ? -code : code;
  ------------------
  |  Branch (1671:16): [True: 0, False: 5.12k]
  ------------------
 1672|  5.12k|    }
_ZN8jsonconsltERKNS_12basic_bigintINSt3__19allocatorImEEEES6_:
 1476|  5.12k|    {
 1477|  5.12k|       return x.compare(y) < 0 ? true : false;
  ------------------
  |  Branch (1477:15): [True: 2.28k, False: 2.83k]
  ------------------
 1478|  5.12k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewIKmEixEm:
   69|  6.62k|        {
   70|  6.62k|            return data_[i];
   71|  6.62k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE12set_negativeEb:
  733|  19.9k|    {
  734|  19.9k|        storage_.set_negative(value);
  735|  19.9k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12set_negativeEb:
  515|  19.9k|    {
  516|  19.9k|        common_.is_negative_ = value;
  517|  19.9k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEED2Ev:
  708|  42.3k|    {
  709|  42.3k|        storage_.destroy();
  710|  42.3k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE7destroyEv:
  487|  42.3k|    {
  488|  42.3k|        if (is_allocated())
  ------------------
  |  Branch (488:13): [True: 13.9k, False: 28.3k]
  ------------------
  489|  13.9k|        {
  490|  13.9k|            allocated_.destroy(get_allocator());
  491|  13.9k|            allocated_.~allocated_storage();
  492|  13.9k|        }
  493|  28.3k|        else
  494|  28.3k|        {
  495|  28.3k|            inlined_.~inlined_storage();
  496|  28.3k|        }
  497|  42.3k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storage7destroyERKS4_:
  246|  13.9k|        {
  247|  13.9k|            if (data_ != nullptr)
  ------------------
  |  Branch (247:17): [True: 13.9k, False: 0]
  ------------------
  248|  13.9k|            {
  249|  13.9k|                real_allocator_type alloc(a);
  250|  13.9k|                std::allocator_traits<real_allocator_type>::deallocate(alloc, data_, capacity_);
  251|  13.9k|            }
  252|  13.9k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2INS1_12basic_stringIcNS1_11char_traitsIcEENS2_IcEEEEvEERKT_:
  699|  2.37k|    {
  700|  2.37k|        auto r = jsoncons::to_bigint(s.data(), s.size(), *this);
  701|  2.37k|        if (r.ec != std::errc{})
  ------------------
  |  Branch (701:13): [True: 74, False: 2.29k]
  ------------------
  702|     74|        {
  703|     74|            JSONCONS_THROW(std::system_error((int)r.ec, std::system_category()));
  ------------------
  |  |   35|     74|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  704|     74|        }
  705|  2.37k|    }
_ZN8jsoncons9to_bigintIcEENS_16to_bigint_resultIT_EEPKS2_mRNS_12basic_bigintINSt3__19allocatorImEEEE:
 2135|  2.37k|{
 2136|  2.37k|    if (JSONCONS_UNLIKELY(length == 0))
  ------------------
  |  |   78|  2.37k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 2.37k]
  |  |  ------------------
  ------------------
 2137|      0|    {
 2138|      0|        return to_bigint_result<CharT>(data, std::errc::invalid_argument);
 2139|      0|    }
 2140|       |
 2141|  2.37k|    if (*data == '-')
  ------------------
  |  Branch (2141:9): [True: 5, False: 2.36k]
  ------------------
 2142|      5|    {
 2143|      5|        return jsoncons::detail::to_bigint(data+1, length-1, true, value, std::allocator<uint64_t>{}); 
 2144|      5|    }
 2145|  2.36k|    else
 2146|  2.36k|    {
 2147|  2.36k|        return jsoncons::detail::to_bigint(data, length, false, value, std::allocator<uint64_t>{}); 
 2148|  2.36k|    }
 2149|  2.37k|}
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2ERKS4_:
  671|  9.16k|        : storage_(other.storage_)
  672|  9.16k|    {
  673|  9.16k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2ERKS5_:
  299|  9.16k|        : word_allocator_type(other.get_allocator())
  300|  9.16k|    {
  301|       |#if defined(__GNUC__) && JSONCONS_GCC_AVAILABLE(12,0,0)
  302|       |# pragma GCC diagnostic push
  303|       |# pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
  304|       |#endif
  305|  9.16k|        if (!other.is_allocated())
  ------------------
  |  Branch (305:13): [True: 6.91k, False: 2.25k]
  ------------------
  306|  6.91k|        {
  307|  6.91k|            ::new (&inlined_) inlined_storage(other.inlined_);
  308|  6.91k|        }
  309|  2.25k|        else
  310|  2.25k|        {
  311|  2.25k|            ::new (&allocated_) allocated_storage(other.allocated_, get_allocator());
  312|  2.25k|        }
  313|       |#if defined(__GNUC__) && JSONCONS_GCC_AVAILABLE(12,0,0)
  314|       |# pragma GCC diagnostic pop
  315|       |#endif
  316|  9.16k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2ERKS6_:
  178|  20.2k|            : is_allocated_(false),
  179|  20.2k|            is_negative_(stor.is_negative_),
  180|  20.2k|            size_(stor.size_)
  181|  20.2k|        {
  182|  20.2k|            values_[0] = stor.values_[0];
  183|  20.2k|            values_[1] = stor.values_[1];
  184|  20.2k|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storageC2ERKS6_RKS4_:
  209|  4.49k|            : is_allocated_(true),
  210|  4.49k|              is_negative_(stor.is_negative_),
  211|  4.49k|              size_(stor.size_),
  212|  4.49k|              capacity_(stor.capacity_)
  213|  4.49k|        {
  214|  4.49k|            real_allocator_type alloc(a);
  215|       |
  216|  4.49k|            data_ = std::allocator_traits<real_allocator_type>::allocate(alloc, capacity_);
  217|  4.49k|            JSONCONS_TRY
  ------------------
  |  |   37|  4.49k|    #define JSONCONS_TRY try
  ------------------
  218|  4.49k|            {
  219|  4.49k|                std::allocator_traits<real_allocator_type>::construct(alloc, ext_traits::to_plain_pointer(data_));
  220|  4.49k|            }
  221|  4.49k|            JSONCONS_CATCH(...)
  222|  4.49k|            {
  223|      0|                std::allocator_traits<real_allocator_type>::deallocate(alloc, data_, capacity_);
  224|      0|                data_ = nullptr;
  225|      0|                JSONCONS_RETHROW;
  ------------------
  |  |   36|      0|    #define JSONCONS_RETHROW throw
  ------------------
  226|      0|            }
  227|  4.49k|            JSONCONS_ASSERT(stor.data_ != nullptr);
  ------------------
  |  |   49|  4.49k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 4.49k]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  228|  4.49k|            std::memcpy(data_, stor.data_, size_type(stor.size_ * sizeof(word_type)));
  229|  4.49k|        }
_ZN8jsonconsrmENS_12basic_bigintINSt3__19allocatorImEEEERKS4_:
 1561|  4.58k|    {
 1562|  4.58k|        return x %= y;
 1563|  4.58k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEErMERKS4_:
 1110|  4.58k|    {
 1111|  4.58k|        basic_bigint<Allocator> q;
 1112|  4.58k|        divide( divisor, q, *this, true );
 1113|  4.58k|        return *this;
 1114|  4.58k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2Ev:
  641|  5.13k|    basic_bigint() = default;
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE6divideERKS4_RS4_S7_b:
 1675|  5.13k|    {
 1676|  5.13k|        basic_bigint<Allocator> denom(denom_, get_allocator());
 1677|  5.13k|        auto denom_view = denom.get_storage_view();
 1678|       |
 1679|  5.13k|        if (denom_view.size() == 0)
  ------------------
  |  Branch (1679:13): [True: 10, False: 5.12k]
  ------------------
 1680|     10|        {
 1681|     10|            JSONCONS_THROW(std::runtime_error( "Zero divide." ));
  ------------------
  |  |   35|     10|    #define JSONCONS_THROW(exception) throw exception
  ------------------
 1682|     10|        }
 1683|  5.12k|        bool quot_neg = is_negative() ^ denom.is_negative();
 1684|  5.12k|        bool rem_neg = is_negative();
 1685|  5.12k|        basic_bigint<Allocator> num(*this, get_allocator());
 1686|  5.12k|        num.set_negative(false);
 1687|  5.12k|        denom.set_negative(false);
 1688|  5.12k|        if ( num < denom )
  ------------------
  |  Branch (1688:14): [True: 2.28k, False: 2.83k]
  ------------------
 1689|  2.28k|        {
 1690|  2.28k|            quot = word_type(0);
 1691|  2.28k|            quot.set_negative(quot_neg);
 1692|  2.28k|            rem = num;
 1693|  2.28k|            rem.set_negative(rem_neg);
 1694|  2.28k|            return;
 1695|  2.28k|        }
 1696|       |
 1697|  2.83k|        auto num_view = num.get_storage_view();
 1698|  2.83k|        auto quot_view = quot.get_storage_view();
 1699|  2.83k|        auto this_view = get_storage_view();
 1700|       |
 1701|  2.83k|        if ( denom_view.size() == 1 && num_view.size() == 1 )
  ------------------
  |  Branch (1701:14): [True: 1.45k, False: 1.37k]
  |  Branch (1701:40): [True: 0, False: 1.45k]
  ------------------
 1702|      0|        {
 1703|      0|            quot = word_type( num_view[0]/denom_view[0] );
 1704|      0|            rem = word_type( num_view[0]%denom_view[0] );
 1705|      0|            quot.set_negative(quot_neg);
 1706|      0|            rem.set_negative(rem_neg);
 1707|      0|            return;
 1708|      0|        }
 1709|  2.83k|        if (denom_view.size() == 1 && (denom_view[0] & l_mask) == 0 )
  ------------------
  |  Branch (1709:13): [True: 1.45k, False: 1.37k]
  |  Branch (1709:39): [True: 153, False: 1.30k]
  ------------------
 1710|    153|        {
 1711|       |            // Denominator fits into a half word
 1712|    153|            word_type divisor = denom_view[0], dHi = 0, q1, r, q2, dividend;
 1713|    153|            quot.resize(this_view.size());
 1714|    153|            quot_view = quot.get_storage_view();
 1715|    459|            for (size_type i=this_view.size(); i-- > 0; )
  ------------------
  |  Branch (1715:48): [True: 306, False: 153]
  ------------------
 1716|    306|            {
 1717|    306|                dividend = (dHi << word_type_half_bits) | (this_view[i] >> word_type_half_bits);
 1718|    306|                q1 = dividend/divisor;
 1719|    306|                r = dividend % divisor;
 1720|    306|                dividend = (r << word_type_half_bits) | (this_view[i] & r_mask);
 1721|    306|                q2 = dividend/divisor;
 1722|    306|                dHi = dividend % divisor;
 1723|    306|                quot_view[i] = (q1 << word_type_half_bits) | q2;
 1724|    306|            }
 1725|    153|            quot.reduce();
 1726|    153|            rem = dHi;
 1727|    153|            quot.set_negative(quot_neg);
 1728|    153|            rem.set_negative(rem_neg);
 1729|    153|            return;
 1730|    153|        }
 1731|  2.68k|        basic_bigint<Allocator> num0(num, get_allocator());
 1732|  2.68k|        basic_bigint<Allocator> denom0(denom, get_allocator());
 1733|  2.68k|        int x = 0;
 1734|  2.68k|        bool second_done = normalize(denom, num, x);
 1735|  2.68k|        denom_view = denom.get_storage_view();
 1736|  2.68k|        num_view = num.get_storage_view();
 1737|       |
 1738|  2.68k|        size_type l = denom_view.size() - 1;
 1739|  2.68k|        size_type n = num_view.size() - 1;
 1740|  2.68k|        quot.resize(n - l);
 1741|  2.68k|        quot_view = quot.get_storage_view();
 1742|  14.8k|        for (size_type i = quot_view.size(); i-- > 0; )
  ------------------
  |  Branch (1742:46): [True: 12.1k, False: 2.68k]
  ------------------
 1743|  12.1k|        {
 1744|  12.1k|            quot_view[i] = 0;
 1745|  12.1k|        }
 1746|  2.68k|        rem = num;
 1747|  2.68k|        auto rem_view = rem.get_storage_view();
 1748|  2.68k|        if ( rem_view[n] >= denom_view[l] )
  ------------------
  |  Branch (1748:14): [True: 171, False: 2.51k]
  ------------------
 1749|    171|        {
 1750|    171|            rem.resize(rem_view.size() + 1);
 1751|    171|            rem_view = rem.get_storage_view();
 1752|    171|            n++;
 1753|    171|            quot.resize(quot_view.size() + 1);
 1754|    171|            quot_view = quot.get_storage_view();
 1755|    171|        }
 1756|  2.68k|        word_type d = denom_view[l];
 1757|       |
 1758|  15.0k|        for ( size_type k = n; k > l; k-- )
  ------------------
  |  Branch (1758:32): [True: 12.3k, False: 2.68k]
  ------------------
 1759|  12.3k|        {
 1760|  12.3k|            word_type q = DDquotient(rem_view[k], rem_view[k-1], d);
 1761|  12.3k|            subtractmul( rem_view.data() + (k - l - 1), denom_view.data(), l + 1, q );
 1762|  12.3k|            quot_view[k - l - 1] = q;
 1763|  12.3k|        }
 1764|  2.68k|        quot.reduce();
 1765|  2.68k|        quot.set_negative(quot_neg);
 1766|  2.68k|        if (remDesired)
  ------------------
  |  Branch (1766:13): [True: 2.13k, False: 546]
  ------------------
 1767|  2.13k|        {
 1768|  2.13k|            unnormalize(rem, x, second_done);
 1769|  2.13k|            rem.set_negative(rem_neg);
 1770|  2.13k|        }
 1771|  2.68k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE13get_allocatorEv:
  713|  15.6k|    {
  714|  15.6k|        return storage_.get_allocator();
  715|  15.6k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2ERKS4_RKS3_:
  676|  15.6k|        : storage_(other.storage_, alloc)
  677|  15.6k|    {
  678|  15.6k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2ERKS5_RKS4_:
  319|  15.6k|        : word_allocator_type(alloc)
  320|  15.6k|    {
  321|  15.6k|        if (!other.is_allocated())
  ------------------
  |  Branch (321:13): [True: 13.3k, False: 2.23k]
  ------------------
  322|  13.3k|        {
  323|  13.3k|            ::new (&inlined_) inlined_storage(other.inlined_);
  324|  13.3k|        }
  325|  2.23k|        else
  326|  2.23k|        {
  327|  2.23k|            ::new (&allocated_) allocated_storage(other.allocated_, alloc);
  328|  2.23k|        }
  329|  15.6k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE9normalizeERS4_S5_Ri:
 1872|  2.68k|    {
 1873|  2.68k|        auto denom_view = denom.get_storage_view();
 1874|  2.68k|        if (denom_view.size() == 0)
  ------------------
  |  Branch (1874:13): [True: 0, False: 2.68k]
  ------------------
 1875|      0|        {
 1876|      0|            return false;
 1877|      0|        }
 1878|  2.68k|        size_type r = denom_view.size() - 1;
 1879|  2.68k|        word_type y = denom_view[r];
 1880|       |
 1881|  2.68k|        x = 0;
 1882|  49.4k|        while ( (y & l_bit) == 0 )
  ------------------
  |  Branch (1882:17): [True: 46.7k, False: 2.68k]
  ------------------
 1883|  46.7k|        {
 1884|  46.7k|            y <<= 1;
 1885|  46.7k|            x++;
 1886|  46.7k|        }
 1887|  2.68k|        denom <<= x;
 1888|  2.68k|        num <<= x;
 1889|       |
 1890|  2.68k|        denom_view = denom.get_storage_view();
 1891|  2.68k|        if ( r > 0 && denom_view[r] < denom_view[r-1] )
  ------------------
  |  Branch (1891:14): [True: 1.37k, False: 1.30k]
  |  Branch (1891:23): [True: 546, False: 833]
  ------------------
 1892|    546|        {
 1893|    546|            denom *= max_word;
 1894|    546|            num *= max_word;
 1895|    546|            return true;
 1896|    546|        }
 1897|  2.13k|        return false;
 1898|  2.68k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEElSEm:
 1117|  5.36k|    {
 1118|  5.36k|        auto this_view = get_storage_view();
 1119|  5.36k|        size_type q = k / word_type_bits;
 1120|  5.36k|        if ( q ) // Increase storage_.size() by q:
  ------------------
  |  Branch (1120:14): [True: 0, False: 5.36k]
  ------------------
 1121|      0|        {
 1122|      0|            resize(this_view.size() + q);
 1123|      0|            this_view = get_storage_view();
 1124|      0|            for (size_type i = this_view.size(); i-- > 0; )
  ------------------
  |  Branch (1124:50): [True: 0, False: 0]
  ------------------
 1125|      0|                this_view[i] = ( i < q ? 0 : this_view[i - q]);
  ------------------
  |  Branch (1125:34): [True: 0, False: 0]
  ------------------
 1126|      0|            k %= word_type_bits;
 1127|      0|        }
 1128|  5.36k|        if ( k )  // 0 < k < word_type_bits:
  ------------------
  |  Branch (1128:14): [True: 4.00k, False: 1.36k]
  ------------------
 1129|  4.00k|        {
 1130|  4.00k|            size_type k1 = word_type_bits - k;
 1131|  4.00k|            word_type mask = (word_type(1) << k) - word_type(1);
 1132|  4.00k|            resize( this_view.size() + 1 );
 1133|  4.00k|            this_view = get_storage_view();
 1134|  24.3k|            for (size_type i = this_view.size(); i-- > 0; )
  ------------------
  |  Branch (1134:50): [True: 20.3k, False: 4.00k]
  ------------------
 1135|  20.3k|            {
 1136|  20.3k|                this_view[i] <<= k;
 1137|  20.3k|                if ( i > 0 )
  ------------------
  |  Branch (1137:22): [True: 16.3k, False: 4.00k]
  ------------------
 1138|  16.3k|                    this_view[i] |= (this_view[i-1] >> k1) & mask;
 1139|  20.3k|            }
 1140|  4.00k|        }
 1141|  5.36k|        reduce();
 1142|  5.36k|        return *this;
 1143|  5.36k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEmLImEENS1_9enable_ifIXsr10ext_traits19is_unsigned_integerIT_EE5valueERS4_E4typeES7_:
  998|  1.09k|    {
  999|  1.09k|        auto this_view = get_storage_view();
 1000|  1.09k|        size_type len0 = this_view.size();
 1001|  1.09k|        word_type dig = this_view[0];
 1002|  1.09k|        word_type carry = 0;
 1003|       |
 1004|  1.09k|        resize(this_view.size() + 1);
 1005|  1.09k|        this_view = get_storage_view();
 1006|       |
 1007|  1.09k|        size_type i = 0;
 1008|  3.79k|        for (; i < len0; i++ )
  ------------------
  |  Branch (1008:16): [True: 2.70k, False: 1.09k]
  ------------------
 1009|  2.70k|        {
 1010|  2.70k|            word_type hi;
 1011|  2.70k|            word_type lo;
 1012|  2.70k|            DDproduct( dig, y, hi, lo );
 1013|  2.70k|            this_view[i] = lo + carry;
 1014|  2.70k|            dig = this_view[i+1];
 1015|  2.70k|            carry = hi + (this_view[i] < lo);
 1016|  2.70k|        }
 1017|  1.09k|        this_view[i] = carry;
 1018|  1.09k|        reduce();
 1019|  1.09k|        return *this;
 1020|  1.09k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE10DDquotientEmmm:
 1799|  12.3k|    {
 1800|  12.3k|        word_type left, middle, right, qHi, qLo, x, dLo1,
 1801|  12.3k|                   dHi = d >> word_type_half_bits, dLo = d & r_mask;
 1802|  12.3k|        qHi = A/(dHi + 1);
 1803|       |        // This initial guess of qHi may be too small.
 1804|  12.3k|        middle = qHi * dLo;
 1805|  12.3k|        left = qHi * dHi;
 1806|  12.3k|        x = B - (middle << word_type_half_bits);
 1807|  12.3k|        A -= (middle >> word_type_half_bits) + left + (x > B);
 1808|  12.3k|        B = x;
 1809|  12.3k|        dLo1 = dLo << word_type_half_bits;
 1810|       |        // Increase qHi if necessary:
 1811|  15.6k|        while ( A > dHi || (A == dHi && B >= dLo1) )
  ------------------
  |  Branch (1811:17): [True: 2.92k, False: 12.7k]
  |  Branch (1811:29): [True: 426, False: 12.3k]
  |  Branch (1811:41): [True: 400, False: 26]
  ------------------
 1812|  3.32k|        {
 1813|  3.32k|            x = B - dLo1;
 1814|  3.32k|            A -= dHi + (x > B);
 1815|  3.32k|            B = x;
 1816|  3.32k|            qHi++;
 1817|  3.32k|        }
 1818|  12.3k|        qLo = ((A << word_type_half_bits) | (B >> word_type_half_bits))/(dHi + 1);
 1819|       |        // This initial guess of qLo may be too small.
 1820|  12.3k|        right = qLo * dLo;
 1821|  12.3k|        middle = qLo * dHi;
 1822|  12.3k|        x = B - right;
 1823|  12.3k|        A -= (x > B);
 1824|  12.3k|        B = x;
 1825|  12.3k|        x = B - (middle << word_type_half_bits);
 1826|  12.3k|            A -= (middle >> word_type_half_bits) + (x > B);
 1827|  12.3k|        B = x;
 1828|       |        // Increase qLo if necessary:
 1829|  16.3k|        while ( A || B >= d )
  ------------------
  |  Branch (1829:17): [True: 289, False: 16.0k]
  |  Branch (1829:22): [True: 3.67k, False: 12.3k]
  ------------------
 1830|  3.96k|        {
 1831|  3.96k|            x = B - d;
 1832|  3.96k|            A -= (x > B);
 1833|  3.96k|            B = x;
 1834|  3.96k|            qLo++;
 1835|  3.96k|        }
 1836|  12.3k|        return (qHi << word_type_half_bits) + qLo;
 1837|  12.3k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE11subtractmulEPmS5_mRm:
 1841|  12.3k|    {
 1842|  12.3k|        word_type hi, lo, d, carry = 0;
 1843|  12.3k|        size_type i;
 1844|  35.2k|        for ( i = 0; i < n; i++ )
  ------------------
  |  Branch (1844:22): [True: 22.9k, False: 12.3k]
  ------------------
 1845|  22.9k|        {
 1846|  22.9k|            DDproduct( b[i], q, hi, lo );
 1847|  22.9k|            d = a[i];
 1848|  22.9k|            a[i] -= lo;
 1849|  22.9k|            if ( a[i] > d )
  ------------------
  |  Branch (1849:18): [True: 10.4k, False: 12.4k]
  ------------------
 1850|  10.4k|                carry++;
 1851|  22.9k|            d = a[i + 1];
 1852|  22.9k|            a[i + 1] -= hi + carry;
 1853|  22.9k|            carry = a[i + 1] > d;
 1854|  22.9k|        }
 1855|  12.3k|        if ( carry ) // q was too large
  ------------------
  |  Branch (1855:14): [True: 2.80k, False: 9.54k]
  ------------------
 1856|  2.80k|        {
 1857|  2.80k|            q--;
 1858|  2.80k|            carry = 0;
 1859|  8.53k|            for ( i = 0; i < n; i++ )
  ------------------
  |  Branch (1859:26): [True: 5.73k, False: 2.80k]
  ------------------
 1860|  5.73k|            {
 1861|  5.73k|                d = a[i] + carry;
 1862|  5.73k|                carry = d < carry;
 1863|  5.73k|                a[i] = d + b[i];
 1864|  5.73k|                if ( a[i] < d )
  ------------------
  |  Branch (1864:22): [True: 3.80k, False: 1.92k]
  ------------------
 1865|  3.80k|                    carry = 1;
 1866|  5.73k|            }
 1867|  2.80k|            a[n] = 0;
 1868|  2.80k|        }
 1869|  12.3k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE11unnormalizeERS4_ib:
 1901|  2.13k|    {
 1902|  2.13k|        if (secondDone)
  ------------------
  |  Branch (1902:13): [True: 546, False: 1.59k]
  ------------------
 1903|    546|        {
 1904|    546|            rem /= max_word;
 1905|    546|        }
 1906|  2.13k|        if ( x > 0 )
  ------------------
  |  Branch (1906:14): [True: 2.00k, False: 136]
  ------------------
 1907|  2.00k|        {
 1908|  2.00k|            rem >>= x;
 1909|  2.00k|        }
 1910|    136|        else
 1911|    136|        {
 1912|    136|            rem.reduce();
 1913|    136|        }
 1914|  2.13k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEdVERKS4_:
 1103|    546|    {
 1104|    546|        basic_bigint<Allocator> r;
 1105|    546|        divide( divisor, *this, r, false );
 1106|    546|        return *this;
 1107|    546|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEErSEm:
 1146|  2.00k|    {
 1147|  2.00k|        auto this_view = get_storage_view();
 1148|  2.00k|        size_type q = k / word_type_bits;
 1149|  2.00k|        if ( q >= this_view.size())
  ------------------
  |  Branch (1149:14): [True: 0, False: 2.00k]
  ------------------
 1150|      0|        {
 1151|      0|            resize( 0 );
 1152|      0|            return *this;
 1153|      0|        }
 1154|  2.00k|        if (q > 0)
  ------------------
  |  Branch (1154:13): [True: 0, False: 2.00k]
  ------------------
 1155|      0|        {
 1156|      0|            memmove( this_view.data(), this_view.data()+q, size_type((this_view.size() - q)*sizeof(word_type)) );
 1157|      0|            resize( size_type(this_view.size() - q) );
 1158|      0|            k %= word_type_bits;
 1159|      0|            if ( k == 0 )
  ------------------
  |  Branch (1159:18): [True: 0, False: 0]
  ------------------
 1160|      0|            {
 1161|      0|                reduce();
 1162|      0|                return *this;
 1163|      0|            }
 1164|      0|        }
 1165|       |
 1166|  2.00k|        this_view = get_storage_view();
 1167|  2.00k|        size_type n = size_type(this_view.size() - 1);
 1168|  2.00k|        ssize_type k1 = word_type_bits - k;
 1169|  2.00k|        word_type mask = (word_type(1) << k) - 1;
 1170|  15.9k|        for (size_type i = 0; i <= n; i++)
  ------------------
  |  Branch (1170:31): [True: 13.9k, False: 2.00k]
  ------------------
 1171|  13.9k|        {
 1172|  13.9k|            this_view[i] >>= k;
 1173|  13.9k|            if ( i < n )
  ------------------
  |  Branch (1173:18): [True: 11.9k, False: 2.00k]
  ------------------
 1174|  11.9k|                this_view[i] |= ((this_view[i+1] & mask) << k1);
 1175|  13.9k|        }
 1176|  2.00k|        reduce();
 1177|  2.00k|        return *this;
 1178|  2.00k|    }

_ZN8jsoncons10ext_traits16to_plain_pointerImEEPT_S3_:
  241|  4.49k|    {       
  242|  4.49k|        return (ptr);
  243|  4.49k|    }