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_:
  635|  2.28k|        : storage_(alloc)
  636|  2.28k|    {
  637|  2.28k|        auto r = jsoncons::to_bigint(s, std::char_traits<CharT>::length(s), *this, alloc);
  638|  2.28k|        if (r.ec != std::errc{})
  ------------------
  |  Branch (638:13): [True: 0, False: 2.28k]
  ------------------
  639|      0|        {
  640|      0|            JSONCONS_THROW(std::system_error((int)r.ec, std::system_category()));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  641|      0|        }
  642|  2.28k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2ERKS4_:
  285|  9.43k|        : word_allocator_type(alloc)
  286|  9.43k|    {
  287|  9.43k|        ::new (&inlined_) inlined_storage();
  288|  9.43k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2Ev:
  112|  9.43k|            : is_allocated_(false),
  113|  9.43k|            is_negative_(false),
  114|  9.43k|            size_(0),
  115|  9.43k|            values_{0, 0}
  116|  9.43k|        {
  117|  9.43k|        }
_ZN8jsoncons9to_bigintIcNSt3__19allocatorImEEEENS_16to_bigint_resultIT_EEPKS5_mRNS_12basic_bigintIT0_EERKSA_:
 2042|  2.28k|{
 2043|  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]
  |  |  ------------------
  ------------------
 2044|      0|    {
 2045|      0|        return to_bigint_result<CharT>(data, std::errc::invalid_argument);
 2046|      0|    }
 2047|       |
 2048|  2.28k|    if (*data == '-')
  ------------------
  |  Branch (2048:9): [True: 0, False: 2.28k]
  ------------------
 2049|      0|    {
 2050|      0|        return jsoncons::detail::to_bigint(data + 1, length - 1, true, value, alloc);
 2051|      0|    }
 2052|  2.28k|    else
 2053|  2.28k|    {
 2054|  2.28k|        return jsoncons::detail::to_bigint(data, length, false, value, alloc);
 2055|  2.28k|    }
 2056|  2.28k|}
_ZN8jsoncons16to_bigint_resultIcEC2EPKcNSt3__14errcE:
  554|  4.56k|        : ptr(ptr_), ec(ec_)
  555|  4.56k|    {
  556|  4.56k|    }
_ZN8jsoncons6detail9to_bigintIcNSt3__19allocatorImEEEENS_16to_bigint_resultIT_EEPKS6_mbRNS_12basic_bigintIT0_EERKSB_:
 1975|  4.56k|{
 1976|  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]
  |  |  ------------------
  ------------------
 1977|      1|    {
 1978|      1|        return to_bigint_result<CharT>(data, std::errc::invalid_argument);
 1979|      1|    }
 1980|       |
 1981|  4.56k|    using word_type = typename basic_bigint<Allocator>::word_type;
 1982|       |
 1983|  4.56k|    const CharT* last = data + length;
 1984|  4.56k|    const CharT* p = data;
 1985|       |
 1986|  11.9k|    while (p < last && *p == '0')
  ------------------
  |  Branch (1986:12): [True: 11.9k, False: 8]
  |  Branch (1986:24): [True: 7.39k, False: 4.55k]
  ------------------
 1987|  7.39k|    {
 1988|  7.39k|        ++p;
 1989|  7.39k|    }
 1990|  4.56k|    if (p == last)
  ------------------
  |  Branch (1990:9): [True: 8, False: 4.55k]
  ------------------
 1991|      8|    {
 1992|      8|        value = std::move(basic_bigint<Allocator>{0, alloc});
 1993|      8|        return to_bigint_result<CharT>(last, std::errc{});
 1994|      8|    }
 1995|  4.55k|    std::size_t num_digits = last - data;
 1996|  4.55k|    std::size_t num_words;
 1997|  4.55k|    if (length < 10)
  ------------------
  |  Branch (1997:9): [True: 146, False: 4.41k]
  ------------------
 1998|    146|    {
 1999|    146|        num_words = 1;
 2000|    146|    }
 2001|  4.41k|    else
 2002|  4.41k|    {
 2003|  4.41k|        std::size_t num_bits = (std::size_t)(((num_digits * detail::bits_per_digit[10]) >> 10) + 1);
 2004|  4.41k|        num_words = (num_bits + 63) >> 6;
 2005|  4.41k|    }
 2006|       |
 2007|  4.55k|    basic_bigint<Allocator> v(0, alloc);
 2008|  4.55k|    v.reserve(num_words);
 2009|   325k|    for (std::size_t i = 0; i < length; i++)
  ------------------
  |  Branch (2009:29): [True: 321k, False: 4.49k]
  ------------------
 2010|   321k|    {
 2011|   321k|        CharT c = data[i];
 2012|   321k|        switch (c)
 2013|   321k|        {
 2014|   321k|            case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8': case '9':
  ------------------
  |  Branch (2014:13): [True: 125k, False: 195k]
  |  Branch (2014:22): [True: 24.2k, False: 296k]
  |  Branch (2014:31): [True: 12.0k, False: 309k]
  |  Branch (2014:40): [True: 22.3k, False: 298k]
  |  Branch (2014:49): [True: 25.1k, False: 296k]
  |  Branch (2014:58): [True: 42.9k, False: 278k]
  |  Branch (2014:67): [True: 24.0k, False: 297k]
  |  Branch (2014:76): [True: 9.18k, False: 311k]
  |  Branch (2014:85): [True: 11.9k, False: 309k]
  |  Branch (2014:95): [True: 23.6k, False: 297k]
  ------------------
 2015|   321k|                v = (v * 10u) + (word_type)(c - '0');
 2016|   321k|                break;
 2017|     66|            default:
  ------------------
  |  Branch (2017:13): [True: 66, False: 321k]
  ------------------
 2018|     66|                return to_bigint_result<CharT>(data + i, std::errc::invalid_argument);
 2019|   321k|        }
 2020|   321k|    }
 2021|       |
 2022|       |    //auto view = v.get_storage_view();
 2023|       |    //if (num_words != view.size())
 2024|       |    //{
 2025|       |    //    std::cout << "Unexpected num_words! num_words: " << num_words << ", " << num_words << ", size: " << view.size() << "\n";
 2026|       |    //}
 2027|       |
 2028|  4.49k|    if (neg)
  ------------------
  |  Branch (2028:9): [True: 7, False: 4.48k]
  ------------------
 2029|      7|    {
 2030|      7|        v.set_negative(true);
 2031|      7|    }
 2032|       |
 2033|  4.49k|    value = std::move(v);
 2034|  4.49k|    return to_bigint_result<CharT>(last, std::errc{});
 2035|  4.55k|}
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2IiEET_RKS3_PNS1_9enable_ifIXsr3std11is_integralIS6_EE5valueEvE4typeE:
  678|  4.56k|        : storage_(n, alloc)
  679|  4.56k|    {
  680|  4.56k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2IiEET_RKS4_PNS2_9enable_ifIXsr3std11is_integralIS7_EE5valueEvE4typeE:
  345|  4.56k|        : word_allocator_type(alloc)
  346|  4.56k|    {
  347|  4.56k|        ::new (&inlined_) inlined_storage(n);
  348|  4.56k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2IiEET_PNS2_9enable_ifIXaaaasr3std11is_integralIS8_EE5valuelestS8_Lm8Esr3std9is_signedIS8_EE5valueEvE4typeE:
  124|  4.56k|            : is_allocated_(false),
  125|  4.56k|            is_negative_(n < 0),
  126|  4.56k|            size_(n == 0 ? 0 : 1)
  ------------------
  |  Branch (126:19): [True: 4.56k, False: 0]
  ------------------
  127|  4.56k|        {
  128|  4.56k|            values_[0] = n < 0 ? (word_type(0) - static_cast<word_type>(n)) : static_cast<word_type>(n);
  ------------------
  |  Branch (128:26): [True: 0, False: 4.56k]
  ------------------
  129|  4.56k|            values_[1] = 0;
  130|  4.56k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEaSERKS4_:
  844|   332k|    {
  845|   332k|        storage_ = y.storage_;
  846|   332k|        return *this;
  847|   332k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEaSERKS5_:
  351|   332k|    {
  352|   332k|        if (this != &other)
  ------------------
  |  Branch (352:13): [True: 332k, False: 0]
  ------------------
  353|   332k|        {
  354|   332k|            auto other_view = other.get_storage_view();
  355|   332k|            resize(other_view.size());
  356|   332k|            auto this_view = get_storage_view();
  357|   332k|            if (other_view.size() > 0)
  ------------------
  |  Branch (357:17): [True: 323k, False: 9.41k]
  ------------------
  358|   323k|            {
  359|   323k|                common_.is_negative_ = other.common_.is_negative_;
  360|   323k|                std::memcpy(this_view.data(), other_view.data(), size_type(other_view.size()*sizeof(word_type)));
  361|   323k|            }
  362|   332k|        }
  363|   332k|        return *this;
  364|   332k|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE16get_storage_viewEv:
  512|   666k|    {
  513|   666k|        return common_.is_allocated_ ? 
  ------------------
  |  Branch (513:16): [True: 252k, False: 413k]
  ------------------
  514|   252k|            storage_view<const word_type>{allocated_.data_, allocated_.size_} :
  515|   666k|            storage_view<const word_type>{inlined_.values_, inlined_.size_};
  516|   666k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewIKmEC2EPS7_m:
   63|   666k|            : data_(data), size_(size)
   64|   666k|        {
   65|   666k|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE6resizeEm:
  519|   982k|    {
  520|   982k|        size_type old_length = common_.size_;
  521|   982k|        reserve(new_length);
  522|   982k|        common_.size_ = new_length;
  523|       |
  524|   982k|        if (old_length < new_length)
  ------------------
  |  Branch (524:13): [True: 672k, False: 309k]
  ------------------
  525|   672k|        {
  526|   672k|            if (is_allocated())
  ------------------
  |  Branch (526:17): [True: 510k, False: 162k]
  ------------------
  527|   510k|            {
  528|   510k|                std::memset(allocated_.data_+old_length, 0, size_type((new_length-old_length)*sizeof(word_type)));
  529|   510k|            }
  530|   162k|            else
  531|   162k|            {
  532|   162k|                JSONCONS_ASSERT(new_length <= inlined_capacity);
  ------------------
  |  |   45|   162k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 162k]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  533|   344k|                for (size_type i = old_length; i < inlined_capacity; ++i)
  ------------------
  |  Branch (533:48): [True: 181k, False: 162k]
  ------------------
  534|   181k|                {
  535|   181k|                    inlined_.values_[i] = 0;
  536|   181k|                }
  537|   162k|            }
  538|   672k|        }
  539|   982k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE7reserveEm:
  437|   987k|    {
  438|   987k|       if (capacity() < n)
  ------------------
  |  Branch (438:12): [True: 56.4k, False: 930k]
  ------------------
  439|  56.4k|       {
  440|  56.4k|           if (!is_allocated())
  ------------------
  |  Branch (440:16): [True: 56.4k, False: 0]
  ------------------
  441|  56.4k|           {
  442|  56.4k|               size_type size = inlined_.size_;
  443|  56.4k|               size_type is_neg = inlined_.is_negative_;
  444|  56.4k|               word_type values[inlined_capacity] = {inlined_.values_[0], inlined_.values_[1]};
  445|       |
  446|  56.4k|               ::new (&allocated_) allocated_storage();
  447|  56.4k|               allocated_.reserve(n, get_allocator());
  448|  56.4k|               allocated_.size_ = size;
  449|  56.4k|               allocated_.is_negative_ = is_neg;
  450|  56.4k|               if (n >= 1)
  ------------------
  |  Branch (450:20): [True: 56.4k, False: 0]
  ------------------
  451|  56.4k|               {
  452|  56.4k|                   allocated_.data_[0] = values[0];
  453|  56.4k|               }
  454|  56.4k|               if (n >= 2)
  ------------------
  |  Branch (454:20): [True: 56.4k, False: 0]
  ------------------
  455|  56.4k|               {
  456|  56.4k|                   allocated_.data_[1] = values[1];
  457|  56.4k|               }
  458|  56.4k|           }
  459|      0|           else
  460|      0|           {
  461|      0|               allocated_.reserve(n, get_allocator());
  462|      0|           }
  463|  56.4k|       }
  464|   987k|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE8capacityEv:
  490|   987k|    {
  491|   987k|        return is_allocated() ? allocated_.capacity_ : inlined_capacity;
  ------------------
  |  Branch (491:16): [True: 642k, False: 345k]
  ------------------
  492|   987k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storageC2Ev:
  201|  56.4k|            : is_allocated_(true),
  202|  56.4k|            is_negative_(false)
  203|  56.4k|        {
  204|  56.4k|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storage7reserveEmRKS4_:
  253|  56.4k|        {
  254|  56.4k|            size_type capacity_new = round_up(n);
  255|       |
  256|  56.4k|            real_allocator_type alloc(a);
  257|  56.4k|            word_type* data_new = std::allocator_traits<real_allocator_type>::allocate(alloc, capacity_new);
  258|  56.4k|            if (size_ > 0)
  ------------------
  |  Branch (258:17): [True: 0, False: 56.4k]
  ------------------
  259|      0|            {
  260|      0|                std::memcpy(data_new, data_, size_type(size_ * sizeof(word_type)));
  261|      0|            }
  262|  56.4k|            if (data_ != nullptr)
  ------------------
  |  Branch (262:17): [True: 0, False: 56.4k]
  ------------------
  263|      0|            {
  264|      0|                std::allocator_traits<real_allocator_type>::deallocate(alloc, data_, capacity_);
  265|      0|            }
  266|  56.4k|            capacity_ = capacity_new;
  267|  56.4k|            data_ = data_new;
  268|  56.4k|        }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storage8round_upEm:
  272|   751k|        {
  273|   751k|            return ((i + 1/3) / mem_unit + 1) * mem_unit;
  274|   751k|        }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE13get_allocatorEv:
  467|  2.48M|    {
  468|  2.48M|        return static_cast<const word_allocator_type&>(*this);
  469|  2.48M|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12is_allocatedEv:
  485|  4.02M|    {
  486|  4.02M|        return common_.is_allocated_;
  487|  4.02M|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewIKmE4sizeEv:
   83|  2.04M|        {
   84|  2.04M|            return size_;
   85|  2.04M|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE16get_storage_viewEv:
  505|  2.30M|    {
  506|  2.30M|        return common_.is_allocated_ ? 
  ------------------
  |  Branch (506:16): [True: 1.65M, False: 655k]
  ------------------
  507|  1.65M|            storage_view<word_type>{allocated_.data_, allocated_.size_} :
  508|  2.30M|            storage_view<word_type>{inlined_.values_, inlined_.size_};
  509|  2.30M|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImEC2EPmm:
   63|  2.30M|            : data_(data), size_(size)
   64|  2.30M|        {
   65|  2.30M|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImE4dataEv:
   78|   346k|        {
   79|   346k|            return data_;
   80|   346k|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewIKmE4dataEv:
   78|   323k|        {
   79|   323k|            return data_;
   80|   323k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE7reserveEm:
  825|  4.55k|    {
  826|  4.55k|        storage_.reserve(n);
  827|  4.55k|    }
_ZN8jsonconsplENS_12basic_bigintINSt3__19allocatorImEEEEl:
 1450|   321k|    {
 1451|   321k|        return x += y;
 1452|   321k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2IlEET_RKS3_PNS1_9enable_ifIXsr3std11is_integralIS6_EE5valueEvE4typeE:
  678|   321k|        : storage_(n, alloc)
  679|   321k|    {
  680|   321k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2IlEET_RKS4_PNS2_9enable_ifIXsr3std11is_integralIS7_EE5valueEvE4typeE:
  345|   321k|        : word_allocator_type(alloc)
  346|   321k|    {
  347|   321k|        ::new (&inlined_) inlined_storage(n);
  348|   321k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2IlEET_PNS2_9enable_ifIXaaaasr3std11is_integralIS8_EE5valuelestS8_Lm8Esr3std9is_signedIS8_EE5valueEvE4typeE:
  124|   321k|            : is_allocated_(false),
  125|   321k|            is_negative_(n < 0),
  126|   321k|            size_(n == 0 ? 0 : 1)
  ------------------
  |  Branch (126:19): [True: 125k, False: 195k]
  ------------------
  127|   321k|        {
  128|   321k|            values_[0] = n < 0 ? (word_type(0) - static_cast<word_type>(n)) : static_cast<word_type>(n);
  ------------------
  |  Branch (128:26): [True: 0, False: 321k]
  ------------------
  129|   321k|            values_[1] = 0;
  130|   321k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEpLERKS4_:
  850|   321k|    {
  851|   321k|        auto y_view = y.get_storage_view();
  852|       |        
  853|   321k|        if ( is_negative() != y.is_negative())
  ------------------
  |  Branch (853:14): [True: 0, False: 321k]
  ------------------
  854|      0|            return *this -= -y;
  855|   321k|        word_type d;
  856|   321k|        word_type carry = 0;
  857|       |
  858|   321k|        auto this_view = get_storage_view();
  859|   321k|        resize( (std::max)(y_view.size(), this_view.size()) + 1 );
  860|   321k|        this_view = get_storage_view();
  861|       |
  862|   517k|        for (size_type i = 0; i < this_view.size(); i++ )
  ------------------
  |  Branch (862:31): [True: 517k, False: 29]
  ------------------
  863|   517k|        {
  864|   517k|            if ( i >= y_view.size() && carry == 0 )
  ------------------
  |  Branch (864:18): [True: 321k, False: 195k]
  |  Branch (864:40): [True: 321k, False: 410]
  ------------------
  865|   321k|                break;
  866|   196k|            d = this_view[i] + carry;
  867|   196k|            carry = d < carry;
  868|   196k|            if ( i < y_view.size())
  ------------------
  |  Branch (868:18): [True: 195k, False: 410]
  ------------------
  869|   195k|            {
  870|   195k|                this_view[i] = d + y_view[i];
  871|   195k|                if (this_view[i] < d)
  ------------------
  |  Branch (871:21): [True: 361, False: 195k]
  ------------------
  872|    361|                    carry = 1;
  873|   195k|            }
  874|    410|            else
  875|    410|            {
  876|    410|                this_view[i] = d;
  877|    410|            }
  878|   196k|        }
  879|   321k|        reduce();
  880|   321k|        return *this;
  881|   321k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE16get_storage_viewEv:
  708|   333k|    {
  709|   333k|        return storage_.get_storage_view();
  710|   333k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE11is_negativeEv:
  713|   671k|    {
  714|   671k|        return storage_.is_negative();
  715|   671k|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE11is_negativeEv:
  495|   671k|    {
  496|   671k|        return common_.is_negative_;
  497|   671k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE7compareERKS4_:
 1570|  4.86k|    {
 1571|  4.86k|        auto this_view = get_storage_view();
 1572|  4.86k|        auto y_view = y.get_storage_view();
 1573|       |
 1574|  4.86k|        if ( this_view.size() == 0 && y_view.size() == 0 )
  ------------------
  |  Branch (1574:14): [True: 0, False: 4.86k]
  |  Branch (1574:39): [True: 0, False: 0]
  ------------------
 1575|      0|            return 0;
 1576|  4.86k|        if ( is_negative() != y.is_negative())
  ------------------
  |  Branch (1576:14): [True: 0, False: 4.86k]
  ------------------
 1577|      0|            return y.is_negative() - is_negative();
 1578|  4.86k|        int code = 0;
 1579|  4.86k|        if ( this_view.size() < y_view.size())
  ------------------
  |  Branch (1579:14): [True: 1.32k, False: 3.53k]
  ------------------
 1580|  1.32k|            code = -1;
 1581|  3.53k|        else if ( this_view.size() > y_view.size())
  ------------------
  |  Branch (1581:19): [True: 1.77k, False: 1.75k]
  ------------------
 1582|  1.77k|            code = +1;
 1583|  1.75k|        else
 1584|  1.75k|        {
 1585|  1.78k|            for (size_type i = this_view.size(); i-- > 0; )
  ------------------
  |  Branch (1585:50): [True: 1.77k, False: 8]
  ------------------
 1586|  1.77k|            {
 1587|  1.77k|                if (this_view[i] > y_view[i])
  ------------------
  |  Branch (1587:21): [True: 875, False: 899]
  ------------------
 1588|    875|                {
 1589|    875|                    code = 1;
 1590|    875|                    break;
 1591|    875|                }
 1592|    899|                else if (this_view[i] < y_view[i])
  ------------------
  |  Branch (1592:26): [True: 875, False: 24]
  ------------------
 1593|    875|                {
 1594|    875|                    code = -1;
 1595|    875|                    break;
 1596|    875|                }
 1597|  1.77k|            }
 1598|  1.75k|        }
 1599|  4.86k|        return is_negative() ? -code : code;
  ------------------
  |  Branch (1599:16): [True: 0, False: 4.86k]
  ------------------
 1600|  4.86k|    }
_ZN8jsonconsltERKNS_12basic_bigintINSt3__19allocatorImEEEES6_:
 1405|  4.86k|    {
 1406|  4.86k|       return x.compare(y) < 0 ? true : false;
  ------------------
  |  Branch (1406:15): [True: 2.20k, False: 2.66k]
  ------------------
 1407|  4.86k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE16get_storage_viewEv:
  703|  1.32M|    {
  704|  1.32M|        return storage_.get_storage_view();
  705|  1.32M|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE6resizeEm:
  820|   649k|    {
  821|   649k|        storage_.resize(new_length);
  822|   649k|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImE4sizeEv:
   83|  1.51M|        {
   84|  1.51M|            return size_;
   85|  1.51M|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImEixEm:
   68|  41.0M|        {
   69|  41.0M|            return data_[i];
   70|  41.0M|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewIKmEixEm:
   68|   201k|        {
   69|   201k|            return data_[i];
   70|   201k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE6reduceEv:
 1845|   652k|    {
 1846|   652k|        storage_.reduce();
 1847|   652k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE6reduceEv:
  414|   652k|    {
  415|   652k|        if (common_.size_ > 0)
  ------------------
  |  Branch (415:13): [True: 652k, False: 0]
  ------------------
  416|   652k|        {
  417|   652k|            auto this_view = get_storage_view();
  418|   652k|            word_type* p = this_view.end() - 1;
  419|   652k|            word_type* first = this_view.begin();
  420|  1.29M|            while ( p >= first )
  ------------------
  |  Branch (420:21): [True: 1.27M, False: 18.9k]
  ------------------
  421|  1.27M|            {
  422|  1.27M|                if ( *p )
  ------------------
  |  Branch (422:22): [True: 633k, False: 643k]
  ------------------
  423|   633k|                {
  424|   633k|                    break;
  425|   633k|                }
  426|   643k|                --common_.size_;
  427|   643k|                --p;
  428|   643k|            }
  429|   652k|        }
  430|   652k|        if (common_.size_ == 0)
  ------------------
  |  Branch (430:13): [True: 18.9k, False: 633k]
  ------------------
  431|  18.9k|        {
  432|  18.9k|            common_.is_negative_ = false;
  433|  18.9k|        }
  434|   652k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImE3endEv:
   92|   652k|        {
   93|   652k|            return data_ + size_;
   94|   652k|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImE5beginEv:
   87|   652k|        {
   88|   652k|            return data_;
   89|   652k|        }
_ZN8jsonconsmlENS_12basic_bigintINSt3__19allocatorImEEEEl:
 1475|   321k|    {
 1476|   321k|        return x *= y;
 1477|   321k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEmLIlEENS1_9enable_ifIXsr10ext_traits17is_signed_integerIT_EE5valueERS4_E4typeES7_:
  918|   321k|    {
  919|   321k|        *this *= word_type(y < 0 ? -y : y);
  ------------------
  |  Branch (919:28): [True: 0, False: 321k]
  ------------------
  920|   321k|        if ( y < 0 )
  ------------------
  |  Branch (920:14): [True: 0, False: 321k]
  ------------------
  921|      0|            set_negative(!is_negative());
  922|   321k|        return *this;
  923|   321k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEmLImEENS1_9enable_ifIXsr10ext_traits19is_unsigned_integerIT_EE5valueERS4_E4typeES7_:
  928|   322k|    {
  929|   322k|        auto this_view = get_storage_view();
  930|   322k|        size_type len0 = this_view.size();
  931|   322k|        word_type dig = this_view[0];
  932|   322k|        word_type carry = 0;
  933|       |
  934|   322k|        resize(this_view.size() + 1);
  935|   322k|        this_view = get_storage_view();
  936|       |
  937|   322k|        size_type i = 0;
  938|  13.5M|        for (; i < len0; i++ )
  ------------------
  |  Branch (938:16): [True: 13.2M, False: 322k]
  ------------------
  939|  13.2M|        {
  940|  13.2M|            word_type hi;
  941|  13.2M|            word_type lo;
  942|  13.2M|            DDproduct( dig, y, hi, lo );
  943|  13.2M|            this_view[i] = lo + carry;
  944|  13.2M|            dig = this_view[i+1];
  945|  13.2M|            carry = hi + (this_view[i] < lo);
  946|  13.2M|        }
  947|   322k|        this_view[i] = carry;
  948|   322k|        reduce();
  949|   322k|        return *this;
  950|   322k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE9DDproductEmmRmS5_:
 1709|  13.2M|    {
 1710|  13.2M|        word_type hiA = A >> word_type_half_bits, loA = A & r_mask,
 1711|  13.2M|                   hiB = B >> word_type_half_bits, loB = B & r_mask;
 1712|       |
 1713|  13.2M|        lo = loA * loB;
 1714|  13.2M|        hi = hiA * hiB;
 1715|  13.2M|        word_type mid1 = loA * hiB;
 1716|  13.2M|        word_type mid2 = hiA * loB;
 1717|  13.2M|        word_type old = lo;
 1718|  13.2M|        lo += mid1 << word_type_half_bits;
 1719|  13.2M|            hi += (lo < old) + (mid1 >> word_type_half_bits);
 1720|  13.2M|        old = lo;
 1721|  13.2M|        lo += mid2 << word_type_half_bits;
 1722|  13.2M|            hi += (lo < old) + (mid2 >> word_type_half_bits);
 1723|  13.2M|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE12set_negativeEb:
  718|  19.0k|    {
  719|  19.0k|        storage_.set_negative(value);
  720|  19.0k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12set_negativeEb:
  500|  19.0k|    {
  501|  19.0k|        common_.is_negative_ = value;
  502|  19.0k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEED2Ev:
  693|  1.32M|    {
  694|  1.32M|        storage_.destroy();
  695|  1.32M|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE7destroyEv:
  472|  1.32M|    {
  473|  1.32M|        if (is_allocated())
  ------------------
  |  Branch (473:13): [True: 751k, False: 573k]
  ------------------
  474|   751k|        {
  475|   751k|            allocated_.destroy(get_allocator());
  476|   751k|            allocated_.~allocated_storage();
  477|   751k|        }
  478|   573k|        else
  479|   573k|        {
  480|   573k|            inlined_.~inlined_storage();
  481|   573k|        }
  482|  1.32M|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storage7destroyERKS4_:
  244|   751k|        {
  245|   751k|            if (data_ != nullptr)
  ------------------
  |  Branch (245:17): [True: 751k, False: 0]
  ------------------
  246|   751k|            {
  247|   751k|                real_allocator_type alloc(a);
  248|   751k|                std::allocator_traits<real_allocator_type>::deallocate(alloc, data_, capacity_);
  249|   751k|            }
  250|   751k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2INS1_12basic_stringIcNS1_11char_traitsIcEENS2_IcEEEEvEERKT_:
  684|  2.28k|    {
  685|  2.28k|        auto r = jsoncons::to_bigint(s.data(), s.size(), *this);
  686|  2.28k|        if (r.ec != std::errc{})
  ------------------
  |  Branch (686:13): [True: 67, False: 2.21k]
  ------------------
  687|     67|        {
  688|     67|            JSONCONS_THROW(std::system_error((int)r.ec, std::system_category()));
  ------------------
  |  |   35|     67|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  689|     67|        }
  690|  2.28k|    }
_ZN8jsoncons9to_bigintIcEENS_16to_bigint_resultIT_EEPKS2_mRNS_12basic_bigintINSt3__19allocatorImEEEE:
 2067|  2.28k|{
 2068|  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]
  |  |  ------------------
  ------------------
 2069|      0|    {
 2070|      0|        return to_bigint_result<CharT>(data, std::errc::invalid_argument);
 2071|      0|    }
 2072|       |
 2073|  2.28k|    if (*data == '-')
  ------------------
  |  Branch (2073:9): [True: 10, False: 2.27k]
  ------------------
 2074|     10|    {
 2075|     10|        return jsoncons::detail::to_bigint(data+1, length-1, true, value, std::allocator<uint64_t>{}); 
 2076|     10|    }
 2077|  2.27k|    else
 2078|  2.27k|    {
 2079|  2.27k|        return jsoncons::detail::to_bigint(data, length, false, value, std::allocator<uint64_t>{}); 
 2080|  2.27k|    }
 2081|  2.28k|}
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2ERKS4_:
  656|   972k|        : storage_(other.storage_)
  657|   972k|    {
  658|   972k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2ERKS5_:
  291|   972k|        : word_allocator_type(other.get_allocator())
  292|   972k|    {
  293|   972k|        if (!other.is_allocated())
  ------------------
  |  Branch (293:13): [True: 279k, False: 693k]
  ------------------
  294|   279k|        {
  295|   279k|            ::new (&inlined_) inlined_storage(other.inlined_);
  296|   279k|        }
  297|   693k|        else
  298|   693k|        {
  299|   693k|            ::new (&allocated_) allocated_storage(other.allocated_, get_allocator());
  300|   693k|        }
  301|   972k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2ERKS6_:
  177|   291k|            : is_allocated_(false),
  178|   291k|            is_negative_(stor.is_negative_),
  179|   291k|            size_(stor.size_)
  180|   291k|        {
  181|   291k|            values_[0] = stor.values_[0];
  182|   291k|            values_[1] = stor.values_[1];
  183|   291k|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storageC2ERKS6_RKS4_:
  207|   694k|            : is_allocated_(true),
  208|   694k|              is_negative_(stor.is_negative_),
  209|   694k|              size_(stor.size_),
  210|   694k|              capacity_(round_up(stor.size_))
  211|   694k|        {
  212|   694k|            real_allocator_type alloc(a);
  213|       |
  214|   694k|            data_ = std::allocator_traits<real_allocator_type>::allocate(alloc, capacity_);
  215|   694k|            JSONCONS_TRY
  ------------------
  |  |   37|   694k|    #define JSONCONS_TRY try
  ------------------
  216|   694k|            {
  217|   694k|                std::allocator_traits<real_allocator_type>::construct(alloc, ext_traits::to_plain_pointer(data_));
  218|   694k|            }
  219|   694k|            JSONCONS_CATCH(...)
  220|   694k|            {
  221|      0|                std::allocator_traits<real_allocator_type>::deallocate(alloc, data_, capacity_);
  222|      0|                data_ = nullptr;
  223|      0|                JSONCONS_RETHROW;
  ------------------
  |  |   36|      0|    #define JSONCONS_RETHROW throw
  ------------------
  224|      0|            }
  225|   694k|            JSONCONS_ASSERT(stor.data_ != nullptr);
  ------------------
  |  |   45|   694k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 694k]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  226|   694k|            std::memcpy(data_, stor.data_, size_type(stor.size_ * sizeof(word_type)));
  227|   694k|        }
_ZN8jsonconsrmENS_12basic_bigintINSt3__19allocatorImEEEERKS4_:
 1490|  4.42k|    {
 1491|  4.42k|        return x %= y;
 1492|  4.42k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEErMERKS4_:
 1039|  4.42k|    {
 1040|  4.42k|        basic_bigint<Allocator> q;
 1041|  4.42k|        divide( divisor, q, *this, true );
 1042|  4.42k|        return *this;
 1043|  4.42k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2Ev:
  626|  4.87k|    basic_bigint() = default;
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE6divideERKS4_RS4_S7_b:
 1603|  4.87k|    {
 1604|  4.87k|        basic_bigint<Allocator> denom(denom_, get_allocator());
 1605|  4.87k|        auto denom_view = denom.get_storage_view();
 1606|       |
 1607|  4.87k|        if (denom_view.size() == 0)
  ------------------
  |  Branch (1607:13): [True: 8, False: 4.86k]
  ------------------
 1608|      8|        {
 1609|      8|            JSONCONS_THROW(std::runtime_error( "Zero divide." ));
  ------------------
  |  |   35|      8|    #define JSONCONS_THROW(exception) throw exception
  ------------------
 1610|      8|        }
 1611|  4.86k|        bool quot_neg = is_negative() ^ denom.is_negative();
 1612|  4.86k|        bool rem_neg = is_negative();
 1613|  4.86k|        basic_bigint<Allocator> num(*this, get_allocator());
 1614|  4.86k|        num.set_negative(false);
 1615|  4.86k|        denom.set_negative(false);
 1616|  4.86k|        if ( num < denom )
  ------------------
  |  Branch (1616:14): [True: 2.20k, False: 2.66k]
  ------------------
 1617|  2.20k|        {
 1618|  2.20k|            quot = word_type(0);
 1619|  2.20k|            quot.set_negative(quot_neg);
 1620|  2.20k|            rem = num;
 1621|  2.20k|            rem.set_negative(rem_neg);
 1622|  2.20k|            return;
 1623|  2.20k|        }
 1624|       |
 1625|  2.66k|        auto num_view = num.get_storage_view();
 1626|  2.66k|        auto quot_view = quot.get_storage_view();
 1627|  2.66k|        auto this_view = get_storage_view();
 1628|       |
 1629|  2.66k|        if ( denom_view.size() == 1 && num_view.size() == 1 )
  ------------------
  |  Branch (1629:14): [True: 1.46k, False: 1.20k]
  |  Branch (1629:40): [True: 0, False: 1.46k]
  ------------------
 1630|      0|        {
 1631|      0|            quot = word_type( num_view[0]/denom_view[0] );
 1632|      0|            rem = word_type( num_view[0]%denom_view[0] );
 1633|      0|            quot.set_negative(quot_neg);
 1634|      0|            rem.set_negative(rem_neg);
 1635|      0|            return;
 1636|      0|        }
 1637|  2.66k|        if (denom_view.size() == 1 && (denom_view[0] & l_mask) == 0 )
  ------------------
  |  Branch (1637:13): [True: 1.46k, False: 1.20k]
  |  Branch (1637:39): [True: 173, False: 1.28k]
  ------------------
 1638|    173|        {
 1639|       |            // Denominator fits into a half word
 1640|    173|            word_type divisor = denom_view[0], dHi = 0, q1, r, q2, dividend;
 1641|    173|            quot.resize(this_view.size());
 1642|    173|            quot_view = quot.get_storage_view();
 1643|    519|            for (size_type i=this_view.size(); i-- > 0; )
  ------------------
  |  Branch (1643:48): [True: 346, False: 173]
  ------------------
 1644|    346|            {
 1645|    346|                dividend = (dHi << word_type_half_bits) | (this_view[i] >> word_type_half_bits);
 1646|    346|                q1 = dividend/divisor;
 1647|    346|                r = dividend % divisor;
 1648|    346|                dividend = (r << word_type_half_bits) | (this_view[i] & r_mask);
 1649|    346|                q2 = dividend/divisor;
 1650|    346|                dHi = dividend % divisor;
 1651|    346|                quot_view[i] = (q1 << word_type_half_bits) | q2;
 1652|    346|            }
 1653|    173|            quot.reduce();
 1654|    173|            rem = dHi;
 1655|    173|            quot.set_negative(quot_neg);
 1656|    173|            rem.set_negative(rem_neg);
 1657|    173|            return;
 1658|    173|        }
 1659|  2.48k|        basic_bigint<Allocator> num0(num, get_allocator());
 1660|  2.48k|        basic_bigint<Allocator> denom0(denom, get_allocator());
 1661|  2.48k|        int x = 0;
 1662|  2.48k|        bool second_done = normalize(denom, num, x);
 1663|  2.48k|        denom_view = denom.get_storage_view();
 1664|  2.48k|        num_view = num.get_storage_view();
 1665|       |
 1666|  2.48k|        size_type l = denom_view.size() - 1;
 1667|  2.48k|        size_type n = num_view.size() - 1;
 1668|  2.48k|        quot.resize(n - l);
 1669|  2.48k|        quot_view = quot.get_storage_view();
 1670|  14.1k|        for (size_type i = quot_view.size(); i-- > 0; )
  ------------------
  |  Branch (1670:46): [True: 11.6k, False: 2.48k]
  ------------------
 1671|  11.6k|        {
 1672|  11.6k|            quot_view[i] = 0;
 1673|  11.6k|        }
 1674|  2.48k|        rem = num;
 1675|  2.48k|        auto rem_view = rem.get_storage_view();
 1676|  2.48k|        if ( rem_view[n] >= denom_view[l] )
  ------------------
  |  Branch (1676:14): [True: 199, False: 2.28k]
  ------------------
 1677|    199|        {
 1678|    199|            rem.resize(rem_view.size() + 1);
 1679|    199|            rem_view = rem.get_storage_view();
 1680|    199|            n++;
 1681|    199|            quot.resize(quot_view.size() + 1);
 1682|    199|            quot_view = quot.get_storage_view();
 1683|    199|        }
 1684|  2.48k|        word_type d = denom_view[l];
 1685|       |
 1686|  14.3k|        for ( size_type k = n; k > l; k-- )
  ------------------
  |  Branch (1686:32): [True: 11.8k, False: 2.48k]
  ------------------
 1687|  11.8k|        {
 1688|  11.8k|            word_type q = DDquotient(rem_view[k], rem_view[k-1], d);
 1689|  11.8k|            subtractmul( rem_view.data() + (k - l - 1), denom_view.data(), l + 1, q );
 1690|  11.8k|            quot_view[k - l - 1] = q;
 1691|  11.8k|        }
 1692|  2.48k|        quot.reduce();
 1693|  2.48k|        quot.set_negative(quot_neg);
 1694|  2.48k|        if (remDesired)
  ------------------
  |  Branch (1694:13): [True: 2.03k, False: 448]
  ------------------
 1695|  2.03k|        {
 1696|  2.03k|            unnormalize(rem, x, second_done);
 1697|  2.03k|            rem.set_negative(rem_neg);
 1698|  2.03k|        }
 1699|  2.48k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE13get_allocatorEv:
  698|  14.7k|    {
  699|  14.7k|        return storage_.get_allocator();
  700|  14.7k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2ERKS4_RKS3_:
  661|  14.7k|        : storage_(other.storage_, alloc)
  662|  14.7k|    {
  663|  14.7k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2ERKS5_RKS4_:
  304|  14.7k|        : word_allocator_type(alloc)
  305|  14.7k|    {
  306|  14.7k|        if (!other.is_allocated())
  ------------------
  |  Branch (306:13): [True: 12.8k, False: 1.84k]
  ------------------
  307|  12.8k|        {
  308|  12.8k|            ::new (&inlined_) inlined_storage(other.inlined_);
  309|  12.8k|        }
  310|  1.84k|        else
  311|  1.84k|        {
  312|  1.84k|            ::new (&allocated_) allocated_storage(other.allocated_, alloc);
  313|  1.84k|        }
  314|  14.7k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2ImEET_RKS3_PNS1_9enable_ifIXsr3std11is_integralIS6_EE5valueEvE4typeE:
  678|  2.82k|        : storage_(n, alloc)
  679|  2.82k|    {
  680|  2.82k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2ImEET_RKS4_PNS2_9enable_ifIXsr3std11is_integralIS7_EE5valueEvE4typeE:
  345|  2.82k|        : word_allocator_type(alloc)
  346|  2.82k|    {
  347|  2.82k|        ::new (&inlined_) inlined_storage(n);
  348|  2.82k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2ImEET_PNS2_9enable_ifIXaaaasr3std11is_integralIS8_EE5valuelestS8_Lm8Entsr3std9is_signedIS8_EE5valueEvE4typeE:
  137|  2.82k|            : is_allocated_(false),
  138|  2.82k|            is_negative_(false),
  139|  2.82k|            size_(n == 0 ? 0 : 1)
  ------------------
  |  Branch (139:19): [True: 2.20k, False: 619]
  ------------------
  140|  2.82k|        {
  141|  2.82k|            values_[0] = n;
  142|  2.82k|            values_[1] = 0;
  143|  2.82k|        }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE9normalizeERS4_S5_Ri:
 1800|  2.48k|    {
 1801|  2.48k|        auto denom_view = denom.get_storage_view();
 1802|  2.48k|        if (denom_view.size() == 0)
  ------------------
  |  Branch (1802:13): [True: 0, False: 2.48k]
  ------------------
 1803|      0|        {
 1804|      0|            return false;
 1805|      0|        }
 1806|  2.48k|        size_type r = denom_view.size() - 1;
 1807|  2.48k|        word_type y = denom_view[r];
 1808|       |
 1809|  2.48k|        x = 0;
 1810|  44.9k|        while ( (y & l_bit) == 0 )
  ------------------
  |  Branch (1810:17): [True: 42.4k, False: 2.48k]
  ------------------
 1811|  42.4k|        {
 1812|  42.4k|            y <<= 1;
 1813|  42.4k|            x++;
 1814|  42.4k|        }
 1815|  2.48k|        denom <<= x;
 1816|  2.48k|        num <<= x;
 1817|       |
 1818|  2.48k|        denom_view = denom.get_storage_view();
 1819|  2.48k|        if ( r > 0 && denom_view[r] < denom_view[r-1] )
  ------------------
  |  Branch (1819:14): [True: 1.20k, False: 1.28k]
  |  Branch (1819:23): [True: 448, False: 752]
  ------------------
 1820|    448|        {
 1821|    448|            denom *= max_word;
 1822|    448|            num *= max_word;
 1823|    448|            return true;
 1824|    448|        }
 1825|  2.03k|        return false;
 1826|  2.48k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEElSEm:
 1046|  4.97k|    {
 1047|  4.97k|        auto this_view = get_storage_view();
 1048|  4.97k|        size_type q = k / word_type_bits;
 1049|  4.97k|        if ( q ) // Increase storage_.size() by q:
  ------------------
  |  Branch (1049:14): [True: 0, False: 4.97k]
  ------------------
 1050|      0|        {
 1051|      0|            resize(this_view.size() + q);
 1052|      0|            this_view = get_storage_view();
 1053|      0|            for (size_type i = this_view.size(); i-- > 0; )
  ------------------
  |  Branch (1053:50): [True: 0, False: 0]
  ------------------
 1054|      0|                this_view[i] = ( i < q ? 0 : this_view[i - q]);
  ------------------
  |  Branch (1054:34): [True: 0, False: 0]
  ------------------
 1055|      0|            k %= word_type_bits;
 1056|      0|        }
 1057|  4.97k|        if ( k )  // 0 < k < word_type_bits:
  ------------------
  |  Branch (1057:14): [True: 3.79k, False: 1.18k]
  ------------------
 1058|  3.79k|        {
 1059|  3.79k|            size_type k1 = word_type_bits - k;
 1060|  3.79k|            word_type mask = (word_type(1) << k) - word_type(1);
 1061|  3.79k|            resize( this_view.size() + 1 );
 1062|  3.79k|            this_view = get_storage_view();
 1063|  23.0k|            for (size_type i = this_view.size(); i-- > 0; )
  ------------------
  |  Branch (1063:50): [True: 19.2k, False: 3.79k]
  ------------------
 1064|  19.2k|            {
 1065|  19.2k|                this_view[i] <<= k;
 1066|  19.2k|                if ( i > 0 )
  ------------------
  |  Branch (1066:22): [True: 15.4k, False: 3.79k]
  ------------------
 1067|  15.4k|                    this_view[i] |= (this_view[i-1] >> k1) & mask;
 1068|  19.2k|            }
 1069|  3.79k|        }
 1070|  4.97k|        reduce();
 1071|  4.97k|        return *this;
 1072|  4.97k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE10DDquotientEmmm:
 1727|  11.8k|    {
 1728|  11.8k|        word_type left, middle, right, qHi, qLo, x, dLo1,
 1729|  11.8k|                   dHi = d >> word_type_half_bits, dLo = d & r_mask;
 1730|  11.8k|        qHi = A/(dHi + 1);
 1731|       |        // This initial guess of qHi may be too small.
 1732|  11.8k|        middle = qHi * dLo;
 1733|  11.8k|        left = qHi * dHi;
 1734|  11.8k|        x = B - (middle << word_type_half_bits);
 1735|  11.8k|        A -= (middle >> word_type_half_bits) + left + (x > B);
 1736|  11.8k|        B = x;
 1737|  11.8k|        dLo1 = dLo << word_type_half_bits;
 1738|       |        // Increase qHi if necessary:
 1739|  14.9k|        while ( A > dHi || (A == dHi && B >= dLo1) )
  ------------------
  |  Branch (1739:17): [True: 2.89k, False: 12.1k]
  |  Branch (1739:29): [True: 326, False: 11.7k]
  |  Branch (1739:41): [True: 285, False: 41]
  ------------------
 1740|  3.17k|        {
 1741|  3.17k|            x = B - dLo1;
 1742|  3.17k|            A -= dHi + (x > B);
 1743|  3.17k|            B = x;
 1744|  3.17k|            qHi++;
 1745|  3.17k|        }
 1746|  11.8k|        qLo = ((A << word_type_half_bits) | (B >> word_type_half_bits))/(dHi + 1);
 1747|       |        // This initial guess of qLo may be too small.
 1748|  11.8k|        right = qLo * dLo;
 1749|  11.8k|        middle = qLo * dHi;
 1750|  11.8k|        x = B - right;
 1751|  11.8k|        A -= (x > B);
 1752|  11.8k|        B = x;
 1753|  11.8k|        x = B - (middle << word_type_half_bits);
 1754|  11.8k|            A -= (middle >> word_type_half_bits) + (x > B);
 1755|  11.8k|        B = x;
 1756|       |        // Increase qLo if necessary:
 1757|  15.6k|        while ( A || B >= d )
  ------------------
  |  Branch (1757:17): [True: 256, False: 15.4k]
  |  Branch (1757:22): [True: 3.60k, False: 11.8k]
  ------------------
 1758|  3.86k|        {
 1759|  3.86k|            x = B - d;
 1760|  3.86k|            A -= (x > B);
 1761|  3.86k|            B = x;
 1762|  3.86k|            qLo++;
 1763|  3.86k|        }
 1764|  11.8k|        return (qHi << word_type_half_bits) + qLo;
 1765|  11.8k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE11subtractmulEPmS5_mRm:
 1769|  11.8k|    {
 1770|  11.8k|        word_type hi, lo, d, carry = 0;
 1771|  11.8k|        size_type i;
 1772|  33.6k|        for ( i = 0; i < n; i++ )
  ------------------
  |  Branch (1772:22): [True: 21.7k, False: 11.8k]
  ------------------
 1773|  21.7k|        {
 1774|  21.7k|            DDproduct( b[i], q, hi, lo );
 1775|  21.7k|            d = a[i];
 1776|  21.7k|            a[i] -= lo;
 1777|  21.7k|            if ( a[i] > d )
  ------------------
  |  Branch (1777:18): [True: 10.0k, False: 11.7k]
  ------------------
 1778|  10.0k|                carry++;
 1779|  21.7k|            d = a[i + 1];
 1780|  21.7k|            a[i + 1] -= hi + carry;
 1781|  21.7k|            carry = a[i + 1] > d;
 1782|  21.7k|        }
 1783|  11.8k|        if ( carry ) // q was too large
  ------------------
  |  Branch (1783:14): [True: 2.76k, False: 9.05k]
  ------------------
 1784|  2.76k|        {
 1785|  2.76k|            q--;
 1786|  2.76k|            carry = 0;
 1787|  8.42k|            for ( i = 0; i < n; i++ )
  ------------------
  |  Branch (1787:26): [True: 5.65k, False: 2.76k]
  ------------------
 1788|  5.65k|            {
 1789|  5.65k|                d = a[i] + carry;
 1790|  5.65k|                carry = d < carry;
 1791|  5.65k|                a[i] = d + b[i];
 1792|  5.65k|                if ( a[i] < d )
  ------------------
  |  Branch (1792:22): [True: 3.79k, False: 1.85k]
  ------------------
 1793|  3.79k|                    carry = 1;
 1794|  5.65k|            }
 1795|  2.76k|            a[n] = 0;
 1796|  2.76k|        }
 1797|  11.8k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE11unnormalizeERS4_ib:
 1829|  2.03k|    {
 1830|  2.03k|        if (secondDone)
  ------------------
  |  Branch (1830:13): [True: 448, False: 1.59k]
  ------------------
 1831|    448|        {
 1832|    448|            rem /= max_word;
 1833|    448|        }
 1834|  2.03k|        if ( x > 0 )
  ------------------
  |  Branch (1834:14): [True: 1.89k, False: 144]
  ------------------
 1835|  1.89k|        {
 1836|  1.89k|            rem >>= x;
 1837|  1.89k|        }
 1838|    144|        else
 1839|    144|        {
 1840|    144|            rem.reduce();
 1841|    144|        }
 1842|  2.03k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEdVERKS4_:
 1032|    448|    {
 1033|    448|        basic_bigint<Allocator> r;
 1034|    448|        divide( divisor, *this, r, false );
 1035|    448|        return *this;
 1036|    448|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEErSEm:
 1075|  1.89k|    {
 1076|  1.89k|        auto this_view = get_storage_view();
 1077|  1.89k|        size_type q = k / word_type_bits;
 1078|  1.89k|        if ( q >= this_view.size())
  ------------------
  |  Branch (1078:14): [True: 0, False: 1.89k]
  ------------------
 1079|      0|        {
 1080|      0|            resize( 0 );
 1081|      0|            return *this;
 1082|      0|        }
 1083|  1.89k|        if (q > 0)
  ------------------
  |  Branch (1083:13): [True: 0, False: 1.89k]
  ------------------
 1084|      0|        {
 1085|      0|            memmove( this_view.data(), this_view.data()+q, size_type((this_view.size() - q)*sizeof(word_type)) );
 1086|      0|            resize( size_type(this_view.size() - q) );
 1087|      0|            k %= word_type_bits;
 1088|      0|            if ( k == 0 )
  ------------------
  |  Branch (1088:18): [True: 0, False: 0]
  ------------------
 1089|      0|            {
 1090|      0|                reduce();
 1091|      0|                return *this;
 1092|      0|            }
 1093|      0|        }
 1094|       |
 1095|  1.89k|        this_view = get_storage_view();
 1096|  1.89k|        size_type n = size_type(this_view.size() - 1);
 1097|  1.89k|        ssize_type k1 = word_type_bits - k;
 1098|  1.89k|        word_type mask = (word_type(1) << k) - 1;
 1099|  15.3k|        for (size_type i = 0; i <= n; i++)
  ------------------
  |  Branch (1099:31): [True: 13.4k, False: 1.89k]
  ------------------
 1100|  13.4k|        {
 1101|  13.4k|            this_view[i] >>= k;
 1102|  13.4k|            if ( i < n )
  ------------------
  |  Branch (1102:18): [True: 11.5k, False: 1.89k]
  ------------------
 1103|  11.5k|                this_view[i] |= ((this_view[i+1] & mask) << k1);
 1104|  13.4k|        }
 1105|  1.89k|        reduce();
 1106|  1.89k|        return *this;
 1107|  1.89k|    }

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