LLVMFuzzerTestOneInput:
    7|  2.32k|{
    8|  2.32k|	std::string input(reinterpret_cast<const char*>(data), size);
    9|  2.32k|	try {
   10|  2.32k|        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.28k, False: 41]
  ------------------
   11|  2.28k|        {
   12|  2.28k|            bigint a("56654250564056135415631554531554513813");
   13|  2.28k|            bigint b(input);
   14|  2.28k|            bigint c = a % b;
   15|  2.28k|            bigint d = b % a;
   16|  2.28k|        }
   17|  2.32k|	}
   18|  2.32k|	catch (const std::runtime_error&) {}
   19|       |
   20|  2.32k|	return 0;
   21|  2.32k|}

_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2IcEEPKT_RKS3_:
  643|  2.28k|        : storage_(alloc)
  644|  2.28k|    {
  645|  2.28k|        auto r = jsoncons::to_bigint(s, std::char_traits<CharT>::length(s), *this, alloc);
  646|  2.28k|        if (r.ec != std::errc{})
  ------------------
  |  Branch (646:13): [True: 0, False: 2.28k]
  ------------------
  647|      0|        {
  648|      0|            JSONCONS_THROW(std::system_error((int)r.ec, std::system_category()));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  649|      0|        }
  650|  2.28k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2ERKS4_:
  293|  9.43k|        : word_allocator_type(alloc)
  294|  9.43k|    {
  295|  9.43k|        ::new (&inlined_) inlined_storage();
  296|  9.43k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2Ev:
  113|  9.43k|            : is_allocated_(false),
  114|  9.43k|            is_negative_(false),
  115|  9.43k|            size_(0),
  116|  9.43k|            values_{0, 0}
  117|  9.43k|        {
  118|  9.43k|        }
_ZN8jsoncons9to_bigintIcNSt3__19allocatorImEEEENS_16to_bigint_resultIT_EEPKS5_mRNS_12basic_bigintIT0_EERKSA_:
 2103|  2.28k|{
 2104|  2.28k|    if (JSONCONS_UNLIKELY(length == 0))
  ------------------
  |  |   78|  2.28k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 2.28k]
  |  |  ------------------
  ------------------
 2105|      0|    {
 2106|      0|        return to_bigint_result<CharT>(data, std::errc::invalid_argument);
 2107|      0|    }
 2108|       |
 2109|  2.28k|    if (*data == '-')
  ------------------
  |  Branch (2109:9): [True: 0, False: 2.28k]
  ------------------
 2110|      0|    {
 2111|      0|        return jsoncons::detail::to_bigint(data + 1, length - 1, true, value, alloc);
 2112|      0|    }
 2113|  2.28k|    else
 2114|  2.28k|    {
 2115|  2.28k|        return jsoncons::detail::to_bigint(data, length, false, value, alloc);
 2116|  2.28k|    }
 2117|  2.28k|}
_ZN8jsoncons16to_bigint_resultIcEC2EPKcNSt3__14errcE:
  562|  4.56k|        : ptr(ptr_), ec(ec_)
  563|  4.56k|    {
  564|  4.56k|    }
_ZN8jsoncons6detail9to_bigintIcNSt3__19allocatorImEEEENS_16to_bigint_resultIT_EEPKS6_mbRNS_12basic_bigintIT0_EERKSB_:
 2041|  4.56k|{
 2042|  4.56k|    if (JSONCONS_UNLIKELY(length == 0))
  ------------------
  |  |   78|  4.56k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1, False: 4.56k]
  |  |  ------------------
  ------------------
 2043|      1|    {
 2044|      1|        return to_bigint_result<CharT>(data, std::errc::invalid_argument);
 2045|      1|    }
 2046|       |
 2047|  4.56k|    using word_type = typename basic_bigint<Allocator>::word_type;
 2048|       |
 2049|  4.56k|    const CharT* last = data + length;
 2050|  4.56k|    const CharT* p = data;
 2051|       |
 2052|  11.9k|    while (p < last && *p == '0')
  ------------------
  |  Branch (2052:12): [True: 11.9k, False: 8]
  |  Branch (2052:24): [True: 7.39k, False: 4.55k]
  ------------------
 2053|  7.39k|    {
 2054|  7.39k|        ++p;
 2055|  7.39k|    }
 2056|  4.56k|    if (p == last)
  ------------------
  |  Branch (2056:9): [True: 8, False: 4.55k]
  ------------------
 2057|      8|    {
 2058|      8|        value = std::move(basic_bigint<Allocator>{0, alloc});
 2059|      8|        return to_bigint_result<CharT>(last, std::errc{});
 2060|      8|    }
 2061|  4.55k|    std::size_t num_digits = last - data;
 2062|  4.55k|    std::size_t num_words;
 2063|  4.55k|    if (length < 10)
  ------------------
  |  Branch (2063:9): [True: 146, False: 4.41k]
  ------------------
 2064|    146|    {
 2065|    146|        num_words = 1;
 2066|    146|    }
 2067|  4.41k|    else
 2068|  4.41k|    {
 2069|  4.41k|        std::size_t num_bits = (std::size_t)(((num_digits * detail::bits_per_digit[10]) >> 10) + 1);
 2070|  4.41k|        num_words = (num_bits + 63) >> 6;
 2071|  4.41k|    }
 2072|       |
 2073|  4.55k|    basic_bigint<Allocator> v(0, alloc);
 2074|  4.55k|    v.reserve(num_words);
 2075|   325k|    for (std::size_t i = 0; i < length; i++)
  ------------------
  |  Branch (2075:29): [True: 321k, False: 4.49k]
  ------------------
 2076|   321k|    {
 2077|   321k|        CharT c = data[i];
 2078|   321k|        if (JSONCONS_LIKELY(c >= '0' && c <= '9'))
  ------------------
  |  |   77|   642k|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 321k, False: 66]
  |  |  |  Branch (77:48): [True: 321k, False: 57]
  |  |  |  Branch (77:48): [True: 321k, False: 9]
  |  |  ------------------
  ------------------
 2079|   321k|        {
 2080|   321k|            v *= 10u;
 2081|   321k|            v += (word_type)(c - '0');
 2082|   321k|        }
 2083|     66|        else
 2084|     66|        {
 2085|     66|            return to_bigint_result<CharT>(data + i, std::errc::invalid_argument);
 2086|     66|        }
 2087|   321k|    }
 2088|       |
 2089|  4.49k|    if (neg)
  ------------------
  |  Branch (2089:9): [True: 7, False: 4.48k]
  ------------------
 2090|      7|    {
 2091|      7|        v.set_negative(true);
 2092|      7|    }
 2093|       |
 2094|  4.49k|    value = std::move(v);
 2095|  4.49k|    return to_bigint_result<CharT>(last, std::errc{});
 2096|  4.55k|}
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2IiEET_RKS3_PNS1_9enable_ifIXsr3std11is_integralIS6_EE5valueEvE4typeE:
  686|  4.56k|        : storage_(n, alloc)
  687|  4.56k|    {
  688|  4.56k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2IiEET_RKS4_PNS2_9enable_ifIXsr3std11is_integralIS7_EE5valueEvE4typeE:
  353|  4.56k|        : word_allocator_type(alloc)
  354|  4.56k|    {
  355|  4.56k|        ::new (&inlined_) inlined_storage(n);
  356|  4.56k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2IiEET_PNS2_9enable_ifIXaaaasr3std11is_integralIS8_EE5valuelestS8_Lm8Esr3std9is_signedIS8_EE5valueEvE4typeE:
  125|  4.56k|            : is_allocated_(false),
  126|  4.56k|            is_negative_(n < 0),
  127|  4.56k|            size_(n == 0 ? 0 : 1)
  ------------------
  |  Branch (127:19): [True: 4.56k, False: 0]
  ------------------
  128|  4.56k|        {
  129|  4.56k|            values_[0] = n < 0 ? (word_type(0) - static_cast<word_type>(n)) : static_cast<word_type>(n);
  ------------------
  |  Branch (129:26): [True: 0, False: 4.56k]
  ------------------
  130|  4.56k|            values_[1] = 0;
  131|  4.56k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEaSERKS4_:
  835|  11.5k|    {
  836|  11.5k|        storage_ = y.storage_;
  837|  11.5k|        return *this;
  838|  11.5k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEaSERKS5_:
  359|  11.5k|    {
  360|  11.5k|        if (this != &other)
  ------------------
  |  Branch (360:13): [True: 11.5k, False: 0]
  ------------------
  361|  11.5k|        {
  362|  11.5k|            auto other_view = other.get_storage_view();
  363|  11.5k|            resize(other_view.size());
  364|  11.5k|            auto this_view = get_storage_view();
  365|  11.5k|            if (other_view.size() > 0)
  ------------------
  |  Branch (365:17): [True: 9.35k, False: 2.21k]
  ------------------
  366|  9.35k|            {
  367|  9.35k|                common_.is_negative_ = other.common_.is_negative_;
  368|  9.35k|                std::memcpy(this_view.data(), other_view.data(), size_type(other_view.size()*sizeof(word_type)));
  369|  9.35k|            }
  370|  11.5k|        }
  371|  11.5k|        return *this;
  372|  11.5k|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE16get_storage_viewEv:
  520|  23.9k|    {
  521|  23.9k|        return common_.is_allocated_ ? 
  ------------------
  |  Branch (521:16): [True: 7.68k, False: 16.2k]
  ------------------
  522|  7.68k|            storage_view<const word_type>{allocated_.data_, allocated_.size_} :
  523|  23.9k|            storage_view<const word_type>{inlined_.values_, inlined_.size_};
  524|  23.9k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewIKmEC2EPS7_m:
   64|  23.9k|            : data_(data), size_(size)
   65|  23.9k|        {
   66|  23.9k|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE6resizeEm:
  527|   661k|    {
  528|   661k|        size_type old_length = common_.size_;
  529|   661k|        reserve(new_length);
  530|   661k|        common_.size_ = new_length;
  531|       |
  532|   661k|        if (old_length < new_length)
  ------------------
  |  Branch (532:13): [True: 655k, False: 5.92k]
  ------------------
  533|   655k|        {
  534|   655k|            if (is_allocated())
  ------------------
  |  Branch (534:17): [True: 500k, False: 155k]
  ------------------
  535|   500k|            {
  536|   500k|                std::memset(allocated_.data_+old_length, 0, size_type((new_length-old_length)*sizeof(word_type)));
  537|   500k|            }
  538|   155k|            else
  539|   155k|            {
  540|   155k|                JSONCONS_ASSERT(new_length <= inlined_capacity);
  ------------------
  |  |   45|   155k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 155k]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  541|   325k|                for (size_type i = old_length; i < inlined_capacity; ++i)
  ------------------
  |  Branch (541:48): [True: 170k, False: 155k]
  ------------------
  542|   170k|                {
  543|   170k|                    inlined_.values_[i] = 0;
  544|   170k|                }
  545|   155k|            }
  546|   655k|        }
  547|   661k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE7reserveEm:
  445|   666k|    {
  446|   666k|       if (capacity() < n)
  ------------------
  |  Branch (446:12): [True: 8.74k, False: 657k]
  ------------------
  447|  8.74k|       {
  448|  8.74k|           if (!is_allocated())
  ------------------
  |  Branch (448:16): [True: 8.74k, False: 0]
  ------------------
  449|  8.74k|           {
  450|  8.74k|               size_type size = inlined_.size_;
  451|  8.74k|               size_type is_neg = inlined_.is_negative_;
  452|  8.74k|               word_type values[inlined_capacity] = {inlined_.values_[0], inlined_.values_[1]};
  453|       |
  454|  8.74k|               ::new (&allocated_) allocated_storage();
  455|  8.74k|               allocated_.reserve(n, get_allocator());
  456|  8.74k|               allocated_.size_ = size;
  457|  8.74k|               allocated_.is_negative_ = is_neg;
  458|  8.74k|               if (n >= 1)
  ------------------
  |  Branch (458:20): [True: 8.74k, False: 0]
  ------------------
  459|  8.74k|               {
  460|  8.74k|                   allocated_.data_[0] = values[0];
  461|  8.74k|               }
  462|  8.74k|               if (n >= 2)
  ------------------
  |  Branch (462:20): [True: 8.74k, False: 0]
  ------------------
  463|  8.74k|               {
  464|  8.74k|                   allocated_.data_[1] = values[1];
  465|  8.74k|               }
  466|  8.74k|           }
  467|      0|           else
  468|      0|           {
  469|      0|               allocated_.reserve(n, get_allocator());
  470|      0|           }
  471|  8.74k|       }
  472|   666k|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE8capacityEv:
  498|   666k|    {
  499|   666k|        return is_allocated() ? allocated_.capacity_ : inlined_capacity;
  ------------------
  |  Branch (499:16): [True: 492k, False: 173k]
  ------------------
  500|   666k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storageC2Ev:
  203|  8.74k|            : is_allocated_(true),
  204|  8.74k|            is_negative_(false)
  205|  8.74k|        {
  206|  8.74k|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storage7reserveEmRKS4_:
  255|  8.74k|        {
  256|  8.74k|            JSONCONS_ASSERT(n < max_size);
  ------------------
  |  |   45|  8.74k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 8.74k]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  257|  8.74k|            size_type capacity_new = round_up(n);
  258|       |
  259|  8.74k|            real_allocator_type alloc(a);
  260|  8.74k|            word_type* data_new = std::allocator_traits<real_allocator_type>::allocate(alloc, capacity_new);
  261|  8.74k|            if (size_ > 0)
  ------------------
  |  Branch (261:17): [True: 0, False: 8.74k]
  ------------------
  262|      0|            {
  263|      0|                std::memcpy(data_new, data_, size_type(size_ * sizeof(word_type)));
  264|      0|            }
  265|  8.74k|            if (data_ != nullptr)
  ------------------
  |  Branch (265:17): [True: 0, False: 8.74k]
  ------------------
  266|      0|            {
  267|      0|                std::allocator_traits<real_allocator_type>::deallocate(alloc, data_, capacity_);
  268|      0|            }
  269|  8.74k|            capacity_ = capacity_new;
  270|  8.74k|            data_ = data_new;
  271|  8.74k|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storage8round_upEm:
  275|  8.74k|        {
  276|  8.74k|            size_type remainder = i % mem_unit;
  277|  8.74k|            size_type off = mem_unit - remainder;
  278|  8.74k|            bool testoff = i < max_size - off;
  279|  8.74k|            JSONCONS_ASSERT(testoff);
  ------------------
  |  |   45|  8.74k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 8.74k]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  280|       |
  281|  8.74k|            return i + off;
  282|  8.74k|        }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE13get_allocatorEv:
  475|  47.0k|    {
  476|  47.0k|        return static_cast<const word_allocator_type&>(*this);
  477|  47.0k|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12is_allocatedEv:
  493|  1.39M|    {
  494|  1.39M|        return common_.is_allocated_;
  495|  1.39M|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewIKmE4sizeEv:
   84|  52.7k|        {
   85|  52.7k|            return size_;
   86|  52.7k|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE16get_storage_viewEv:
  513|  1.98M|    {
  514|  1.98M|        return common_.is_allocated_ ? 
  ------------------
  |  Branch (514:16): [True: 1.50M, False: 483k]
  ------------------
  515|  1.50M|            storage_view<word_type>{allocated_.data_, allocated_.size_} :
  516|  1.98M|            storage_view<word_type>{inlined_.values_, inlined_.size_};
  517|  1.98M|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImEC2EPmm:
   64|  1.98M|            : data_(data), size_(size)
   65|  1.98M|        {
   66|  1.98M|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImE4dataEv:
   79|  32.9k|        {
   80|  32.9k|            return data_;
   81|  32.9k|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewIKmE4dataEv:
   79|  9.35k|        {
   80|  9.35k|            return data_;
   81|  9.35k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE7reserveEm:
  816|  4.55k|    {
  817|  4.55k|        storage_.reserve(n);
  818|  4.55k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEmLIjEENS1_9enable_ifIXsr10ext_traits19is_unsigned_integerIT_EE5valueERS4_E4typeES7_:
  991|   321k|    {
  992|   321k|        auto this_view = get_storage_view();
  993|   321k|        size_type len0 = this_view.size();
  994|   321k|        word_type dig = this_view[0];
  995|   321k|        word_type carry = 0;
  996|       |
  997|   321k|        resize(this_view.size() + 1);
  998|   321k|        this_view = get_storage_view();
  999|       |
 1000|   321k|        size_type i = 0;
 1001|  13.5M|        for (; i < len0; i++ )
  ------------------
  |  Branch (1001:16): [True: 13.2M, False: 321k]
  ------------------
 1002|  13.2M|        {
 1003|  13.2M|            word_type hi;
 1004|  13.2M|            word_type lo;
 1005|  13.2M|            DDproduct( dig, y, hi, lo );
 1006|  13.2M|            this_view[i] = lo + carry;
 1007|  13.2M|            dig = this_view[i+1];
 1008|  13.2M|            carry = hi + (this_view[i] < lo);
 1009|  13.2M|        }
 1010|   321k|        this_view[i] = carry;
 1011|   321k|        reduce();
 1012|   321k|        return *this;
 1013|   321k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE16get_storage_viewEv:
  711|  1.32M|    {
  712|  1.32M|        return storage_.get_storage_view();
  713|  1.32M|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImE4sizeEv:
   84|  1.32M|        {
   85|  1.32M|            return size_;
   86|  1.32M|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImEixEm:
   69|  41.4M|        {
   70|  41.4M|            return data_[i];
   71|  41.4M|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE6resizeEm:
  811|   649k|    {
  812|   649k|        storage_.resize(new_length);
  813|   649k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE9DDproductEmmRmS5_:
 1774|  13.2M|    {
 1775|  13.2M|        word_type hiA = A >> word_type_half_bits, loA = A & r_mask,
 1776|  13.2M|                   hiB = B >> word_type_half_bits, loB = B & r_mask;
 1777|       |
 1778|  13.2M|        lo = loA * loB;
 1779|  13.2M|        hi = hiA * hiB;
 1780|  13.2M|        word_type mid1 = loA * hiB;
 1781|  13.2M|        word_type mid2 = hiA * loB;
 1782|  13.2M|        word_type old = lo;
 1783|  13.2M|        lo += mid1 << word_type_half_bits;
 1784|  13.2M|            hi += (lo < old) + (mid1 >> word_type_half_bits);
 1785|  13.2M|        old = lo;
 1786|  13.2M|        lo += mid2 << word_type_half_bits;
 1787|  13.2M|            hi += (lo < old) + (mid2 >> word_type_half_bits);
 1788|  13.2M|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE6reduceEv:
 1910|   652k|    {
 1911|   652k|        storage_.reduce();
 1912|   652k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE6reduceEv:
  422|   652k|    {
  423|   652k|        if (common_.size_ > 0)
  ------------------
  |  Branch (423:13): [True: 652k, False: 0]
  ------------------
  424|   652k|        {
  425|   652k|            auto this_view = get_storage_view();
  426|   652k|            word_type* p = this_view.end() - 1;
  427|   652k|            word_type* first = this_view.begin();
  428|  1.29M|            while ( p >= first )
  ------------------
  |  Branch (428:21): [True: 1.27M, False: 18.9k]
  ------------------
  429|  1.27M|            {
  430|  1.27M|                if ( *p )
  ------------------
  |  Branch (430:22): [True: 633k, False: 638k]
  ------------------
  431|   633k|                {
  432|   633k|                    break;
  433|   633k|                }
  434|   638k|                --common_.size_;
  435|   638k|                --p;
  436|   638k|            }
  437|   652k|        }
  438|   652k|        if (common_.size_ == 0)
  ------------------
  |  Branch (438:13): [True: 18.9k, False: 633k]
  ------------------
  439|  18.9k|        {
  440|  18.9k|            common_.is_negative_ = false;
  441|  18.9k|        }
  442|   652k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImE3endEv:
   93|   652k|        {
   94|   652k|            return data_ + size_;
   95|   652k|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImE5beginEv:
   88|   652k|        {
   89|   652k|            return data_;
   90|   652k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEpLImEENS1_9enable_ifIXaasr10ext_traits19is_unsigned_integerIT_EE5valuelestS7_Lm8EERS4_E4typeES7_:
  882|   321k|    {
  883|   321k|        if ( is_negative())
  ------------------
  |  Branch (883:14): [True: 0, False: 321k]
  ------------------
  884|      0|            return *this -= -basic_bigint<Allocator>(y);
  885|       |
  886|   321k|        word_type d;
  887|   321k|        word_type carry = 0;
  888|       |
  889|   321k|        auto this_view = get_storage_view();
  890|   321k|        resize(this_view.size() + 1);
  891|       |
  892|   321k|        this_view = get_storage_view();
  893|   321k|        const size_type this_size = this_view.size();
  894|   321k|        size_type y_size = 1;
  895|       |
  896|   321k|        d = this_view[0] + carry;
  897|   321k|        carry = d < carry;
  898|   321k|        this_view[0] = d + y;
  899|   321k|        if (this_view[0] < d)
  ------------------
  |  Branch (899:13): [True: 361, False: 320k]
  ------------------
  900|    361|            carry = 1;
  901|       |
  902|   321k|        for (size_type i = y_size; i < this_size && carry != 0; ++i)
  ------------------
  |  Branch (902:36): [True: 309k, False: 11.7k]
  |  Branch (902:53): [True: 410, False: 309k]
  ------------------
  903|    410|        {
  904|    410|            d = this_view[i] + carry;
  905|    410|            carry = d < carry;
  906|    410|            this_view[i] = d;
  907|    410|        }
  908|   321k|        reduce();
  909|   321k|        return *this;
  910|   321k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE11is_negativeEv:
  721|   350k|    {
  722|   350k|        return storage_.is_negative();
  723|   350k|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE11is_negativeEv:
  503|   350k|    {
  504|   350k|        return common_.is_negative_;
  505|   350k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2ImEET_RKS3_PNS1_9enable_ifIXsr3std11is_integralIS6_EE5valueEvE4typeE:
  686|  2.82k|        : storage_(n, alloc)
  687|  2.82k|    {
  688|  2.82k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2ImEET_RKS4_PNS2_9enable_ifIXsr3std11is_integralIS7_EE5valueEvE4typeE:
  353|  2.82k|        : word_allocator_type(alloc)
  354|  2.82k|    {
  355|  2.82k|        ::new (&inlined_) inlined_storage(n);
  356|  2.82k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2ImEET_PNS2_9enable_ifIXaaaasr3std11is_integralIS8_EE5valuelestS8_Lm8Entsr3std9is_signedIS8_EE5valueEvE4typeE:
  138|  2.82k|            : is_allocated_(false),
  139|  2.82k|            is_negative_(false),
  140|  2.82k|            size_(n == 0 ? 0 : 1)
  ------------------
  |  Branch (140:19): [True: 2.20k, False: 619]
  ------------------
  141|  2.82k|        {
  142|  2.82k|            values_[0] = n;
  143|  2.82k|            values_[1] = 0;
  144|  2.82k|        }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE16get_storage_viewEv:
  716|  12.3k|    {
  717|  12.3k|        return storage_.get_storage_view();
  718|  12.3k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE7compareERKS4_:
 1634|  4.86k|    {
 1635|  4.86k|        auto this_view = get_storage_view();
 1636|  4.86k|        auto y_view = y.get_storage_view();
 1637|       |
 1638|  4.86k|        const size_type y_size = y_view.size();
 1639|  4.86k|        if ( this_view.size() == 0 && y_size == 0 )
  ------------------
  |  Branch (1639:14): [True: 0, False: 4.86k]
  |  Branch (1639:39): [True: 0, False: 0]
  ------------------
 1640|      0|            return 0;
 1641|  4.86k|        if ( is_negative() != y.is_negative())
  ------------------
  |  Branch (1641:14): [True: 0, False: 4.86k]
  ------------------
 1642|      0|            return y.is_negative() - is_negative();
 1643|  4.86k|        int code = 0;
 1644|  4.86k|        if ( this_view.size() < y_size)
  ------------------
  |  Branch (1644:14): [True: 1.32k, False: 3.53k]
  ------------------
 1645|  1.32k|            code = -1;
 1646|  3.53k|        else if ( this_view.size() > y_size)
  ------------------
  |  Branch (1646:19): [True: 1.77k, False: 1.75k]
  ------------------
 1647|  1.77k|            code = +1;
 1648|  1.75k|        else
 1649|  1.75k|        {
 1650|  1.78k|            for (size_type i = this_view.size(); i-- > 0; )
  ------------------
  |  Branch (1650:50): [True: 1.77k, False: 8]
  ------------------
 1651|  1.77k|            {
 1652|  1.77k|                if (this_view[i] > y_view[i])
  ------------------
  |  Branch (1652:21): [True: 875, False: 899]
  ------------------
 1653|    875|                {
 1654|    875|                    code = 1;
 1655|    875|                    break;
 1656|    875|                }
 1657|    899|                else if (this_view[i] < y_view[i])
  ------------------
  |  Branch (1657:26): [True: 875, False: 24]
  ------------------
 1658|    875|                {
 1659|    875|                    code = -1;
 1660|    875|                    break;
 1661|    875|                }
 1662|  1.77k|            }
 1663|  1.75k|        }
 1664|  4.86k|        return is_negative() ? -code : code;
  ------------------
  |  Branch (1664:16): [True: 0, False: 4.86k]
  ------------------
 1665|  4.86k|    }
_ZN8jsonconsltERKNS_12basic_bigintINSt3__19allocatorImEEEES6_:
 1469|  4.86k|    {
 1470|  4.86k|       return x.compare(y) < 0 ? true : false;
  ------------------
  |  Branch (1470:15): [True: 2.20k, False: 2.66k]
  ------------------
 1471|  4.86k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewIKmEixEm:
   69|  6.03k|        {
   70|  6.03k|            return data_[i];
   71|  6.03k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE12set_negativeEb:
  726|  19.0k|    {
  727|  19.0k|        storage_.set_negative(value);
  728|  19.0k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12set_negativeEb:
  508|  19.0k|    {
  509|  19.0k|        common_.is_negative_ = value;
  510|  19.0k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEED2Ev:
  701|  40.3k|    {
  702|  40.3k|        storage_.destroy();
  703|  40.3k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE7destroyEv:
  480|  40.3k|    {
  481|  40.3k|        if (is_allocated())
  ------------------
  |  Branch (481:13): [True: 12.6k, False: 27.6k]
  ------------------
  482|  12.6k|        {
  483|  12.6k|            allocated_.destroy(get_allocator());
  484|  12.6k|            allocated_.~allocated_storage();
  485|  12.6k|        }
  486|  27.6k|        else
  487|  27.6k|        {
  488|  27.6k|            inlined_.~inlined_storage();
  489|  27.6k|        }
  490|  40.3k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storage7destroyERKS4_:
  246|  12.6k|        {
  247|  12.6k|            if (data_ != nullptr)
  ------------------
  |  Branch (247:17): [True: 12.6k, False: 0]
  ------------------
  248|  12.6k|            {
  249|  12.6k|                real_allocator_type alloc(a);
  250|  12.6k|                std::allocator_traits<real_allocator_type>::deallocate(alloc, data_, capacity_);
  251|  12.6k|            }
  252|  12.6k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2INS1_12basic_stringIcNS1_11char_traitsIcEENS2_IcEEEEvEERKT_:
  692|  2.28k|    {
  693|  2.28k|        auto r = jsoncons::to_bigint(s.data(), s.size(), *this);
  694|  2.28k|        if (r.ec != std::errc{})
  ------------------
  |  Branch (694:13): [True: 67, False: 2.21k]
  ------------------
  695|     67|        {
  696|     67|            JSONCONS_THROW(std::system_error((int)r.ec, std::system_category()));
  ------------------
  |  |   35|     67|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  697|     67|        }
  698|  2.28k|    }
_ZN8jsoncons9to_bigintIcEENS_16to_bigint_resultIT_EEPKS2_mRNS_12basic_bigintINSt3__19allocatorImEEEE:
 2128|  2.28k|{
 2129|  2.28k|    if (JSONCONS_UNLIKELY(length == 0))
  ------------------
  |  |   78|  2.28k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 2.28k]
  |  |  ------------------
  ------------------
 2130|      0|    {
 2131|      0|        return to_bigint_result<CharT>(data, std::errc::invalid_argument);
 2132|      0|    }
 2133|       |
 2134|  2.28k|    if (*data == '-')
  ------------------
  |  Branch (2134:9): [True: 10, False: 2.27k]
  ------------------
 2135|     10|    {
 2136|     10|        return jsoncons::detail::to_bigint(data+1, length-1, true, value, std::allocator<uint64_t>{}); 
 2137|     10|    }
 2138|  2.27k|    else
 2139|  2.27k|    {
 2140|  2.27k|        return jsoncons::detail::to_bigint(data, length, false, value, std::allocator<uint64_t>{}); 
 2141|  2.27k|    }
 2142|  2.28k|}
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2ERKS4_:
  664|  8.84k|        : storage_(other.storage_)
  665|  8.84k|    {
  666|  8.84k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2ERKS5_:
  299|  8.84k|        : word_allocator_type(other.get_allocator())
  300|  8.84k|    {
  301|  8.84k|        if (!other.is_allocated())
  ------------------
  |  Branch (301:13): [True: 6.75k, False: 2.08k]
  ------------------
  302|  6.75k|        {
  303|  6.75k|            ::new (&inlined_) inlined_storage(other.inlined_);
  304|  6.75k|        }
  305|  2.08k|        else
  306|  2.08k|        {
  307|  2.08k|            ::new (&allocated_) allocated_storage(other.allocated_, get_allocator());
  308|  2.08k|        }
  309|  8.84k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2ERKS6_:
  178|  19.6k|            : is_allocated_(false),
  179|  19.6k|            is_negative_(stor.is_negative_),
  180|  19.6k|            size_(stor.size_)
  181|  19.6k|        {
  182|  19.6k|            values_[0] = stor.values_[0];
  183|  19.6k|            values_[1] = stor.values_[1];
  184|  19.6k|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storageC2ERKS6_RKS4_:
  209|  3.93k|            : is_allocated_(true),
  210|  3.93k|              is_negative_(stor.is_negative_),
  211|  3.93k|              size_(stor.size_),
  212|  3.93k|              capacity_(stor.capacity_)
  213|  3.93k|        {
  214|  3.93k|            real_allocator_type alloc(a);
  215|       |
  216|  3.93k|            data_ = std::allocator_traits<real_allocator_type>::allocate(alloc, capacity_);
  217|  3.93k|            JSONCONS_TRY
  ------------------
  |  |   37|  3.93k|    #define JSONCONS_TRY try
  ------------------
  218|  3.93k|            {
  219|  3.93k|                std::allocator_traits<real_allocator_type>::construct(alloc, ext_traits::to_plain_pointer(data_));
  220|  3.93k|            }
  221|  3.93k|            JSONCONS_CATCH(...)
  222|  3.93k|            {
  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|  3.93k|            JSONCONS_ASSERT(stor.data_ != nullptr);
  ------------------
  |  |   45|  3.93k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 3.93k]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  228|  3.93k|            std::memcpy(data_, stor.data_, size_type(stor.size_ * sizeof(word_type)));
  229|  3.93k|        }
_ZN8jsonconsrmENS_12basic_bigintINSt3__19allocatorImEEEERKS4_:
 1554|  4.42k|    {
 1555|  4.42k|        return x %= y;
 1556|  4.42k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEErMERKS4_:
 1103|  4.42k|    {
 1104|  4.42k|        basic_bigint<Allocator> q;
 1105|  4.42k|        divide( divisor, q, *this, true );
 1106|  4.42k|        return *this;
 1107|  4.42k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2Ev:
  634|  4.87k|    basic_bigint() = default;
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE6divideERKS4_RS4_S7_b:
 1668|  4.87k|    {
 1669|  4.87k|        basic_bigint<Allocator> denom(denom_, get_allocator());
 1670|  4.87k|        auto denom_view = denom.get_storage_view();
 1671|       |
 1672|  4.87k|        if (denom_view.size() == 0)
  ------------------
  |  Branch (1672:13): [True: 8, False: 4.86k]
  ------------------
 1673|      8|        {
 1674|      8|            JSONCONS_THROW(std::runtime_error( "Zero divide." ));
  ------------------
  |  |   35|      8|    #define JSONCONS_THROW(exception) throw exception
  ------------------
 1675|      8|        }
 1676|  4.86k|        bool quot_neg = is_negative() ^ denom.is_negative();
 1677|  4.86k|        bool rem_neg = is_negative();
 1678|  4.86k|        basic_bigint<Allocator> num(*this, get_allocator());
 1679|  4.86k|        num.set_negative(false);
 1680|  4.86k|        denom.set_negative(false);
 1681|  4.86k|        if ( num < denom )
  ------------------
  |  Branch (1681:14): [True: 2.20k, False: 2.66k]
  ------------------
 1682|  2.20k|        {
 1683|  2.20k|            quot = word_type(0);
 1684|  2.20k|            quot.set_negative(quot_neg);
 1685|  2.20k|            rem = num;
 1686|  2.20k|            rem.set_negative(rem_neg);
 1687|  2.20k|            return;
 1688|  2.20k|        }
 1689|       |
 1690|  2.66k|        auto num_view = num.get_storage_view();
 1691|  2.66k|        auto quot_view = quot.get_storage_view();
 1692|  2.66k|        auto this_view = get_storage_view();
 1693|       |
 1694|  2.66k|        if ( denom_view.size() == 1 && num_view.size() == 1 )
  ------------------
  |  Branch (1694:14): [True: 1.46k, False: 1.20k]
  |  Branch (1694:40): [True: 0, False: 1.46k]
  ------------------
 1695|      0|        {
 1696|      0|            quot = word_type( num_view[0]/denom_view[0] );
 1697|      0|            rem = word_type( num_view[0]%denom_view[0] );
 1698|      0|            quot.set_negative(quot_neg);
 1699|      0|            rem.set_negative(rem_neg);
 1700|      0|            return;
 1701|      0|        }
 1702|  2.66k|        if (denom_view.size() == 1 && (denom_view[0] & l_mask) == 0 )
  ------------------
  |  Branch (1702:13): [True: 1.46k, False: 1.20k]
  |  Branch (1702:39): [True: 173, False: 1.28k]
  ------------------
 1703|    173|        {
 1704|       |            // Denominator fits into a half word
 1705|    173|            word_type divisor = denom_view[0], dHi = 0, q1, r, q2, dividend;
 1706|    173|            quot.resize(this_view.size());
 1707|    173|            quot_view = quot.get_storage_view();
 1708|    519|            for (size_type i=this_view.size(); i-- > 0; )
  ------------------
  |  Branch (1708:48): [True: 346, False: 173]
  ------------------
 1709|    346|            {
 1710|    346|                dividend = (dHi << word_type_half_bits) | (this_view[i] >> word_type_half_bits);
 1711|    346|                q1 = dividend/divisor;
 1712|    346|                r = dividend % divisor;
 1713|    346|                dividend = (r << word_type_half_bits) | (this_view[i] & r_mask);
 1714|    346|                q2 = dividend/divisor;
 1715|    346|                dHi = dividend % divisor;
 1716|    346|                quot_view[i] = (q1 << word_type_half_bits) | q2;
 1717|    346|            }
 1718|    173|            quot.reduce();
 1719|    173|            rem = dHi;
 1720|    173|            quot.set_negative(quot_neg);
 1721|    173|            rem.set_negative(rem_neg);
 1722|    173|            return;
 1723|    173|        }
 1724|  2.48k|        basic_bigint<Allocator> num0(num, get_allocator());
 1725|  2.48k|        basic_bigint<Allocator> denom0(denom, get_allocator());
 1726|  2.48k|        int x = 0;
 1727|  2.48k|        bool second_done = normalize(denom, num, x);
 1728|  2.48k|        denom_view = denom.get_storage_view();
 1729|  2.48k|        num_view = num.get_storage_view();
 1730|       |
 1731|  2.48k|        size_type l = denom_view.size() - 1;
 1732|  2.48k|        size_type n = num_view.size() - 1;
 1733|  2.48k|        quot.resize(n - l);
 1734|  2.48k|        quot_view = quot.get_storage_view();
 1735|  14.1k|        for (size_type i = quot_view.size(); i-- > 0; )
  ------------------
  |  Branch (1735:46): [True: 11.6k, False: 2.48k]
  ------------------
 1736|  11.6k|        {
 1737|  11.6k|            quot_view[i] = 0;
 1738|  11.6k|        }
 1739|  2.48k|        rem = num;
 1740|  2.48k|        auto rem_view = rem.get_storage_view();
 1741|  2.48k|        if ( rem_view[n] >= denom_view[l] )
  ------------------
  |  Branch (1741:14): [True: 199, False: 2.28k]
  ------------------
 1742|    199|        {
 1743|    199|            rem.resize(rem_view.size() + 1);
 1744|    199|            rem_view = rem.get_storage_view();
 1745|    199|            n++;
 1746|    199|            quot.resize(quot_view.size() + 1);
 1747|    199|            quot_view = quot.get_storage_view();
 1748|    199|        }
 1749|  2.48k|        word_type d = denom_view[l];
 1750|       |
 1751|  14.3k|        for ( size_type k = n; k > l; k-- )
  ------------------
  |  Branch (1751:32): [True: 11.8k, False: 2.48k]
  ------------------
 1752|  11.8k|        {
 1753|  11.8k|            word_type q = DDquotient(rem_view[k], rem_view[k-1], d);
 1754|  11.8k|            subtractmul( rem_view.data() + (k - l - 1), denom_view.data(), l + 1, q );
 1755|  11.8k|            quot_view[k - l - 1] = q;
 1756|  11.8k|        }
 1757|  2.48k|        quot.reduce();
 1758|  2.48k|        quot.set_negative(quot_neg);
 1759|  2.48k|        if (remDesired)
  ------------------
  |  Branch (1759:13): [True: 2.03k, False: 448]
  ------------------
 1760|  2.03k|        {
 1761|  2.03k|            unnormalize(rem, x, second_done);
 1762|  2.03k|            rem.set_negative(rem_neg);
 1763|  2.03k|        }
 1764|  2.48k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE13get_allocatorEv:
  706|  14.7k|    {
  707|  14.7k|        return storage_.get_allocator();
  708|  14.7k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2ERKS4_RKS3_:
  669|  14.7k|        : storage_(other.storage_, alloc)
  670|  14.7k|    {
  671|  14.7k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2ERKS5_RKS4_:
  312|  14.7k|        : word_allocator_type(alloc)
  313|  14.7k|    {
  314|  14.7k|        if (!other.is_allocated())
  ------------------
  |  Branch (314:13): [True: 12.8k, False: 1.84k]
  ------------------
  315|  12.8k|        {
  316|  12.8k|            ::new (&inlined_) inlined_storage(other.inlined_);
  317|  12.8k|        }
  318|  1.84k|        else
  319|  1.84k|        {
  320|  1.84k|            ::new (&allocated_) allocated_storage(other.allocated_, alloc);
  321|  1.84k|        }
  322|  14.7k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE9normalizeERS4_S5_Ri:
 1865|  2.48k|    {
 1866|  2.48k|        auto denom_view = denom.get_storage_view();
 1867|  2.48k|        if (denom_view.size() == 0)
  ------------------
  |  Branch (1867:13): [True: 0, False: 2.48k]
  ------------------
 1868|      0|        {
 1869|      0|            return false;
 1870|      0|        }
 1871|  2.48k|        size_type r = denom_view.size() - 1;
 1872|  2.48k|        word_type y = denom_view[r];
 1873|       |
 1874|  2.48k|        x = 0;
 1875|  44.9k|        while ( (y & l_bit) == 0 )
  ------------------
  |  Branch (1875:17): [True: 42.4k, False: 2.48k]
  ------------------
 1876|  42.4k|        {
 1877|  42.4k|            y <<= 1;
 1878|  42.4k|            x++;
 1879|  42.4k|        }
 1880|  2.48k|        denom <<= x;
 1881|  2.48k|        num <<= x;
 1882|       |
 1883|  2.48k|        denom_view = denom.get_storage_view();
 1884|  2.48k|        if ( r > 0 && denom_view[r] < denom_view[r-1] )
  ------------------
  |  Branch (1884:14): [True: 1.20k, False: 1.28k]
  |  Branch (1884:23): [True: 448, False: 752]
  ------------------
 1885|    448|        {
 1886|    448|            denom *= max_word;
 1887|    448|            num *= max_word;
 1888|    448|            return true;
 1889|    448|        }
 1890|  2.03k|        return false;
 1891|  2.48k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEElSEm:
 1110|  4.97k|    {
 1111|  4.97k|        auto this_view = get_storage_view();
 1112|  4.97k|        size_type q = k / word_type_bits;
 1113|  4.97k|        if ( q ) // Increase storage_.size() by q:
  ------------------
  |  Branch (1113:14): [True: 0, False: 4.97k]
  ------------------
 1114|      0|        {
 1115|      0|            resize(this_view.size() + q);
 1116|      0|            this_view = get_storage_view();
 1117|      0|            for (size_type i = this_view.size(); i-- > 0; )
  ------------------
  |  Branch (1117:50): [True: 0, False: 0]
  ------------------
 1118|      0|                this_view[i] = ( i < q ? 0 : this_view[i - q]);
  ------------------
  |  Branch (1118:34): [True: 0, False: 0]
  ------------------
 1119|      0|            k %= word_type_bits;
 1120|      0|        }
 1121|  4.97k|        if ( k )  // 0 < k < word_type_bits:
  ------------------
  |  Branch (1121:14): [True: 3.79k, False: 1.18k]
  ------------------
 1122|  3.79k|        {
 1123|  3.79k|            size_type k1 = word_type_bits - k;
 1124|  3.79k|            word_type mask = (word_type(1) << k) - word_type(1);
 1125|  3.79k|            resize( this_view.size() + 1 );
 1126|  3.79k|            this_view = get_storage_view();
 1127|  23.0k|            for (size_type i = this_view.size(); i-- > 0; )
  ------------------
  |  Branch (1127:50): [True: 19.2k, False: 3.79k]
  ------------------
 1128|  19.2k|            {
 1129|  19.2k|                this_view[i] <<= k;
 1130|  19.2k|                if ( i > 0 )
  ------------------
  |  Branch (1130:22): [True: 15.4k, False: 3.79k]
  ------------------
 1131|  15.4k|                    this_view[i] |= (this_view[i-1] >> k1) & mask;
 1132|  19.2k|            }
 1133|  3.79k|        }
 1134|  4.97k|        reduce();
 1135|  4.97k|        return *this;
 1136|  4.97k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEmLImEENS1_9enable_ifIXsr10ext_traits19is_unsigned_integerIT_EE5valueERS4_E4typeES7_:
  991|    896|    {
  992|    896|        auto this_view = get_storage_view();
  993|    896|        size_type len0 = this_view.size();
  994|    896|        word_type dig = this_view[0];
  995|    896|        word_type carry = 0;
  996|       |
  997|    896|        resize(this_view.size() + 1);
  998|    896|        this_view = get_storage_view();
  999|       |
 1000|    896|        size_type i = 0;
 1001|  3.10k|        for (; i < len0; i++ )
  ------------------
  |  Branch (1001:16): [True: 2.21k, False: 896]
  ------------------
 1002|  2.21k|        {
 1003|  2.21k|            word_type hi;
 1004|  2.21k|            word_type lo;
 1005|  2.21k|            DDproduct( dig, y, hi, lo );
 1006|  2.21k|            this_view[i] = lo + carry;
 1007|  2.21k|            dig = this_view[i+1];
 1008|  2.21k|            carry = hi + (this_view[i] < lo);
 1009|  2.21k|        }
 1010|    896|        this_view[i] = carry;
 1011|    896|        reduce();
 1012|    896|        return *this;
 1013|    896|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE10DDquotientEmmm:
 1792|  11.8k|    {
 1793|  11.8k|        word_type left, middle, right, qHi, qLo, x, dLo1,
 1794|  11.8k|                   dHi = d >> word_type_half_bits, dLo = d & r_mask;
 1795|  11.8k|        qHi = A/(dHi + 1);
 1796|       |        // This initial guess of qHi may be too small.
 1797|  11.8k|        middle = qHi * dLo;
 1798|  11.8k|        left = qHi * dHi;
 1799|  11.8k|        x = B - (middle << word_type_half_bits);
 1800|  11.8k|        A -= (middle >> word_type_half_bits) + left + (x > B);
 1801|  11.8k|        B = x;
 1802|  11.8k|        dLo1 = dLo << word_type_half_bits;
 1803|       |        // Increase qHi if necessary:
 1804|  14.9k|        while ( A > dHi || (A == dHi && B >= dLo1) )
  ------------------
  |  Branch (1804:17): [True: 2.89k, False: 12.1k]
  |  Branch (1804:29): [True: 326, False: 11.7k]
  |  Branch (1804:41): [True: 285, False: 41]
  ------------------
 1805|  3.17k|        {
 1806|  3.17k|            x = B - dLo1;
 1807|  3.17k|            A -= dHi + (x > B);
 1808|  3.17k|            B = x;
 1809|  3.17k|            qHi++;
 1810|  3.17k|        }
 1811|  11.8k|        qLo = ((A << word_type_half_bits) | (B >> word_type_half_bits))/(dHi + 1);
 1812|       |        // This initial guess of qLo may be too small.
 1813|  11.8k|        right = qLo * dLo;
 1814|  11.8k|        middle = qLo * dHi;
 1815|  11.8k|        x = B - right;
 1816|  11.8k|        A -= (x > B);
 1817|  11.8k|        B = x;
 1818|  11.8k|        x = B - (middle << word_type_half_bits);
 1819|  11.8k|            A -= (middle >> word_type_half_bits) + (x > B);
 1820|  11.8k|        B = x;
 1821|       |        // Increase qLo if necessary:
 1822|  15.6k|        while ( A || B >= d )
  ------------------
  |  Branch (1822:17): [True: 256, False: 15.4k]
  |  Branch (1822:22): [True: 3.60k, False: 11.8k]
  ------------------
 1823|  3.86k|        {
 1824|  3.86k|            x = B - d;
 1825|  3.86k|            A -= (x > B);
 1826|  3.86k|            B = x;
 1827|  3.86k|            qLo++;
 1828|  3.86k|        }
 1829|  11.8k|        return (qHi << word_type_half_bits) + qLo;
 1830|  11.8k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE11subtractmulEPmS5_mRm:
 1834|  11.8k|    {
 1835|  11.8k|        word_type hi, lo, d, carry = 0;
 1836|  11.8k|        size_type i;
 1837|  33.6k|        for ( i = 0; i < n; i++ )
  ------------------
  |  Branch (1837:22): [True: 21.7k, False: 11.8k]
  ------------------
 1838|  21.7k|        {
 1839|  21.7k|            DDproduct( b[i], q, hi, lo );
 1840|  21.7k|            d = a[i];
 1841|  21.7k|            a[i] -= lo;
 1842|  21.7k|            if ( a[i] > d )
  ------------------
  |  Branch (1842:18): [True: 10.0k, False: 11.7k]
  ------------------
 1843|  10.0k|                carry++;
 1844|  21.7k|            d = a[i + 1];
 1845|  21.7k|            a[i + 1] -= hi + carry;
 1846|  21.7k|            carry = a[i + 1] > d;
 1847|  21.7k|        }
 1848|  11.8k|        if ( carry ) // q was too large
  ------------------
  |  Branch (1848:14): [True: 2.76k, False: 9.05k]
  ------------------
 1849|  2.76k|        {
 1850|  2.76k|            q--;
 1851|  2.76k|            carry = 0;
 1852|  8.42k|            for ( i = 0; i < n; i++ )
  ------------------
  |  Branch (1852:26): [True: 5.65k, False: 2.76k]
  ------------------
 1853|  5.65k|            {
 1854|  5.65k|                d = a[i] + carry;
 1855|  5.65k|                carry = d < carry;
 1856|  5.65k|                a[i] = d + b[i];
 1857|  5.65k|                if ( a[i] < d )
  ------------------
  |  Branch (1857:22): [True: 3.79k, False: 1.85k]
  ------------------
 1858|  3.79k|                    carry = 1;
 1859|  5.65k|            }
 1860|  2.76k|            a[n] = 0;
 1861|  2.76k|        }
 1862|  11.8k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE11unnormalizeERS4_ib:
 1894|  2.03k|    {
 1895|  2.03k|        if (secondDone)
  ------------------
  |  Branch (1895:13): [True: 448, False: 1.59k]
  ------------------
 1896|    448|        {
 1897|    448|            rem /= max_word;
 1898|    448|        }
 1899|  2.03k|        if ( x > 0 )
  ------------------
  |  Branch (1899:14): [True: 1.89k, False: 144]
  ------------------
 1900|  1.89k|        {
 1901|  1.89k|            rem >>= x;
 1902|  1.89k|        }
 1903|    144|        else
 1904|    144|        {
 1905|    144|            rem.reduce();
 1906|    144|        }
 1907|  2.03k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEdVERKS4_:
 1096|    448|    {
 1097|    448|        basic_bigint<Allocator> r;
 1098|    448|        divide( divisor, *this, r, false );
 1099|    448|        return *this;
 1100|    448|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEErSEm:
 1139|  1.89k|    {
 1140|  1.89k|        auto this_view = get_storage_view();
 1141|  1.89k|        size_type q = k / word_type_bits;
 1142|  1.89k|        if ( q >= this_view.size())
  ------------------
  |  Branch (1142:14): [True: 0, False: 1.89k]
  ------------------
 1143|      0|        {
 1144|      0|            resize( 0 );
 1145|      0|            return *this;
 1146|      0|        }
 1147|  1.89k|        if (q > 0)
  ------------------
  |  Branch (1147:13): [True: 0, False: 1.89k]
  ------------------
 1148|      0|        {
 1149|      0|            memmove( this_view.data(), this_view.data()+q, size_type((this_view.size() - q)*sizeof(word_type)) );
 1150|      0|            resize( size_type(this_view.size() - q) );
 1151|      0|            k %= word_type_bits;
 1152|      0|            if ( k == 0 )
  ------------------
  |  Branch (1152:18): [True: 0, False: 0]
  ------------------
 1153|      0|            {
 1154|      0|                reduce();
 1155|      0|                return *this;
 1156|      0|            }
 1157|      0|        }
 1158|       |
 1159|  1.89k|        this_view = get_storage_view();
 1160|  1.89k|        size_type n = size_type(this_view.size() - 1);
 1161|  1.89k|        ssize_type k1 = word_type_bits - k;
 1162|  1.89k|        word_type mask = (word_type(1) << k) - 1;
 1163|  15.3k|        for (size_type i = 0; i <= n; i++)
  ------------------
  |  Branch (1163:31): [True: 13.4k, False: 1.89k]
  ------------------
 1164|  13.4k|        {
 1165|  13.4k|            this_view[i] >>= k;
 1166|  13.4k|            if ( i < n )
  ------------------
  |  Branch (1166:18): [True: 11.5k, False: 1.89k]
  ------------------
 1167|  11.5k|                this_view[i] |= ((this_view[i+1] & mask) << k1);
 1168|  13.4k|        }
 1169|  1.89k|        reduce();
 1170|  1.89k|        return *this;
 1171|  1.89k|    }

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