LLVMFuzzerTestOneInput:
   17|  6.26k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
   18|  6.26k|  std::string json(reinterpret_cast<const char *>(data), size);
   19|  6.26k|  Poco::JSON::Parser parser;
   20|       |
   21|  6.26k|  Poco::Dynamic::Var result;
   22|  6.26k|  try {
   23|  6.26k|    result = parser.parse(json);
   24|  6.26k|  } catch (Poco::Exception &e) {
   25|  6.19k|    return 0;
   26|  6.19k|  } catch (const std::exception &e) {
   27|      0|    return 0;
   28|      0|  }
   29|     78|  return 0;
   30|  6.26k|}

_ZN4Poco11PlaceholderINS_7Dynamic9VarHolderELj64EE5eraseEv:
   98|  6.28M|	{
   99|  6.28M|		destruct(true);
  100|  6.28M|	}
_ZN4Poco11PlaceholderINS_7Dynamic9VarHolderELj64EE8destructEb:
  151|  12.0M|	{
  152|  12.0M|		if (!isEmpty())
  ------------------
  |  Branch (152:7): [True: 6.01M, False: 6.03M]
  ------------------
  153|  6.01M|		{
  154|  6.01M|			if (!isLocal())
  ------------------
  |  Branch (154:8): [True: 0, False: 6.01M]
  ------------------
  155|      0|				delete pHolder;
  156|  6.01M|			else
  157|  6.01M|				reinterpret_cast<PlaceholderT*>(holder)->~PlaceholderT();
  158|       |
  159|  6.01M|			if (clear) std::memset(holder, 0, sizeof(Placeholder));
  ------------------
  |  Branch (159:8): [True: 263k, False: 5.75M]
  ------------------
  160|  6.01M|		}
  161|  12.0M|	}
_ZNK4Poco11PlaceholderINS_7Dynamic9VarHolderELj64EE7isEmptyEv:
  103|  12.0M|	{
  104|  12.0M|		static char buf[SizeV+1] = {};
  105|  12.0M|		return 0 == std::memcmp(holder, buf, SizeV+1);
  106|  12.0M|	}
_ZNK4Poco11PlaceholderINS_7Dynamic9VarHolderELj64EE8setLocalEb:
  146|  6.01M|	{
  147|  6.01M|		holder[SizeV] = local ? 1 : 0;
  ------------------
  |  Branch (147:19): [True: 6.01M, False: 0]
  ------------------
  148|  6.01M|	}
_ZN4Poco11PlaceholderINS_7Dynamic9VarHolderELj64EE6assignINS1_13VarHolderImplIlEElLPv0EEEPS2_RKT0_:
  116|  4.21M|	{
  117|  4.21M|		erase();
  118|  4.21M|		new (reinterpret_cast<PlaceholderT*>(holder)) T(value);
  119|  4.21M|		setLocal(true);
  120|  4.21M|		return reinterpret_cast<PlaceholderT*>(holder);
  121|  4.21M|	}
_ZN4Poco11PlaceholderINS_7Dynamic9VarHolderELj64EE6assignINS1_13VarHolderImplImEEmLPv0EEEPS2_RKT0_:
  116|  3.06k|	{
  117|  3.06k|		erase();
  118|  3.06k|		new (reinterpret_cast<PlaceholderT*>(holder)) T(value);
  119|  3.06k|		setLocal(true);
  120|  3.06k|		return reinterpret_cast<PlaceholderT*>(holder);
  121|  3.06k|	}
_ZN4Poco11PlaceholderINS_7Dynamic9VarHolderELj64EE6assignINS1_13VarHolderImplIbEEbLPv0EEEPS2_RKT0_:
  116|  1.41k|	{
  117|  1.41k|		erase();
  118|  1.41k|		new (reinterpret_cast<PlaceholderT*>(holder)) T(value);
  119|  1.41k|		setLocal(true);
  120|  1.41k|		return reinterpret_cast<PlaceholderT*>(holder);
  121|  1.41k|	}
_ZN4Poco11PlaceholderINS_7Dynamic9VarHolderELj64EE6assignINS1_13VarHolderImplIdEEdLPv0EEEPS2_RKT0_:
  116|  38.8k|	{
  117|  38.8k|		erase();
  118|  38.8k|		new (reinterpret_cast<PlaceholderT*>(holder)) T(value);
  119|  38.8k|		setLocal(true);
  120|  38.8k|		return reinterpret_cast<PlaceholderT*>(holder);
  121|  38.8k|	}
_ZNK4Poco11PlaceholderINS_7Dynamic9VarHolderELj64EE7contentEv:
  134|  16.6M|	{
  135|  16.6M|		if (isLocal())
  ------------------
  |  Branch (135:7): [True: 16.6M, False: 2.08k]
  ------------------
  136|  16.6M|			return reinterpret_cast<PlaceholderT*>(holder);
  137|  2.08k|		else
  138|  2.08k|			return pHolder;
  139|  16.6M|	}
_ZN4Poco11PlaceholderINS_7Dynamic9VarHolderELj64EE6assignINS1_13VarHolderImplINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEEESC_LPv0EEEPS2_RKT0_:
  116|  3.03k|	{
  117|  3.03k|		erase();
  118|  3.03k|		new (reinterpret_cast<PlaceholderT*>(holder)) T(value);
  119|  3.03k|		setLocal(true);
  120|  3.03k|		return reinterpret_cast<PlaceholderT*>(holder);
  121|  3.03k|	}
_ZNK4Poco11PlaceholderINS_7Dynamic9VarHolderELj64EE7isLocalEv:
  109|  22.7M|	{
  110|  22.7M|		return holder[SizeV] != 0;
  111|  22.7M|	}
_ZN4Poco11PlaceholderINS_7Dynamic9VarHolderELj64EE6assignINS1_13VarHolderImplINS_9SharedPtrINS_4JSON5ArrayENS_16ReferenceCounterENS_13ReleasePolicyIS8_EEEEEESC_LPv0EEEPS2_RKT0_:
  116|  1.29M|	{
  117|  1.29M|		erase();
  118|  1.29M|		new (reinterpret_cast<PlaceholderT*>(holder)) T(value);
  119|  1.29M|		setLocal(true);
  120|  1.29M|		return reinterpret_cast<PlaceholderT*>(holder);
  121|  1.29M|	}
_ZN4Poco11PlaceholderINS_7Dynamic9VarHolderELj64EE6assignINS1_13VarHolderImplINS_9SharedPtrINS_4JSON6ObjectENS_16ReferenceCounterENS_13ReleasePolicyIS8_EEEEEESC_LPv0EEEPS2_RKT0_:
  116|   465k|	{
  117|   465k|		erase();
  118|   465k|		new (reinterpret_cast<PlaceholderT*>(holder)) T(value);
  119|   465k|		setLocal(true);
  120|   465k|		return reinterpret_cast<PlaceholderT*>(holder);
  121|   465k|	}
_ZN4Poco11PlaceholderINS_7Dynamic9VarHolderELj64EEC2Ev:
   82|  5.76M|	{
   83|  5.76M|		std::memset(holder, 0, sizeof(Placeholder));
   84|  5.76M|	}
_ZN4Poco11PlaceholderINS_7Dynamic9VarHolderELj64EED2Ev:
   87|  5.76M|	{
   88|  5.76M|		destruct(false);
   89|  5.76M|	}

_ZN4Poco5Ascii10propertiesEi:
  128|  27.3k|{
  129|  27.3k|	if (isAscii(ch))
  ------------------
  |  Branch (129:6): [True: 27.3k, False: 0]
  ------------------
  130|  27.3k|		return CHARACTER_PROPERTIES[ch];
  131|      0|	else
  132|      0|		return 0;
  133|  27.3k|}
_ZN4Poco5Ascii7isAsciiEi:
  137|  27.3k|{
  138|  27.3k|	return (static_cast<UInt32>(ch) & 0xFFFFFF80) == 0;
  139|  27.3k|}
_ZN4Poco5Ascii13hasPropertiesEii:
  143|  27.3k|{
  144|  27.3k|	return (properties(ch) & props) == props;
  145|  27.3k|}
_ZN4Poco5Ascii7isSpaceEi:
  155|  27.3k|{
  156|  27.3k|	return hasProperties(ch, ACP_SPACE);
  157|  27.3k|}

_ZN4Poco13AtomicCountermmEv:
  113|  3.30M|{
  114|  3.30M|	return --_counter;
  115|  3.30M|}
_ZN4Poco13AtomicCounterppEv:
  101|  3.23M|{
  102|  3.23M|	return ++_counter;
  103|  3.23M|}

_ZNK4Poco7Dynamic3Var7contentEv:
  596|  16.6M|	{
  597|  16.6M|		return _placeholder.content();
  598|  16.6M|	}
_ZN4Poco7Dynamic3Var8destructEv:
  601|  5.76M|	{
  602|  5.76M|	}
_ZN4Poco7Dynamic3Var9constructERKS1_:
  634|  4.48M|{
  635|  4.48M|	if (!other.isEmpty())
  ------------------
  |  Branch (635:6): [True: 4.48M, False: 0]
  ------------------
  636|  4.48M|		other.content()->clone(&_placeholder);
  637|  4.48M|}
_ZNK4Poco7Dynamic3Var4typeEv:
  666|  1.77M|{
  667|  1.77M|	VarHolder* pHolder = content();
  668|  1.77M|	return pHolder ? pHolder->type() : typeid(void);
  ------------------
  |  Branch (668:9): [True: 1.77M, False: 0]
  ------------------
  669|  1.77M|}
_ZNK4Poco7Dynamic3Var7isEmptyEv:
  735|  8.96M|{
  736|  8.96M|	return 0 == content();
  737|  8.96M|}
_ZN4Poco7Dynamic3Var9constructINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEvRKT_:
  606|  1.02k|	{
  607|  1.02k|		_placeholder.assign<VarHolderImpl<ValueType>, ValueType>(value);
  608|  1.02k|	}
_ZN4Poco7Dynamic3Var9constructIlEEvRKT_:
  606|  1.39M|	{
  607|  1.39M|		_placeholder.assign<VarHolderImpl<ValueType>, ValueType>(value);
  608|  1.39M|	}
_ZN4Poco7Dynamic3Var9constructImEEvRKT_:
  606|    975|	{
  607|    975|		_placeholder.assign<VarHolderImpl<ValueType>, ValueType>(value);
  608|    975|	}
_ZN4Poco7Dynamic3Var9constructIdEEvRKT_:
  606|  13.4k|	{
  607|  13.4k|		_placeholder.assign<VarHolderImpl<ValueType>, ValueType>(value);
  608|  13.4k|	}
_ZN4Poco7Dynamic3Var9constructIbEEvRKT_:
  606|    455|	{
  607|    455|		_placeholder.assign<VarHolderImpl<ValueType>, ValueType>(value);
  608|    455|	}
_ZN4Poco7Dynamic3VarC2IlEERKT_:
   94|  1.39M|	{
   95|  1.39M|		construct(val);
   96|  1.39M|	}
_ZN4Poco7Dynamic3VarC2ImEERKT_:
   94|    975|	{
   95|    975|		construct(val);
   96|    975|	}
_ZN4Poco7Dynamic3VarC2INSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEERKT_:
   94|  1.02k|	{
   95|  1.02k|		construct(val);
   96|  1.02k|	}
_ZN4Poco7Dynamic3VarC2IdEERKT_:
   94|  13.4k|	{
   95|  13.4k|		construct(val);
   96|  13.4k|	}
_ZN4Poco7Dynamic3VarC2IbEERKT_:
   94|    455|	{
   95|    455|		construct(val);
   96|    455|	}
_ZN4Poco7Dynamic3VaraSINS_9SharedPtrINS_4JSON6ObjectENS_16ReferenceCounterENS_13ReleasePolicyIS5_EEEEEERS1_RKT_:
  227|    854|	{
  228|    854|		clear();
  229|    854|		construct(other);
  230|    854|		return *this;
  231|    854|	}
_ZN4Poco7Dynamic3Var9constructINS_9SharedPtrINS_4JSON6ObjectENS_16ReferenceCounterENS_13ReleasePolicyIS5_EEEEEEvRKT_:
  606|  64.7k|	{
  607|  64.7k|		_placeholder.assign<VarHolderImpl<ValueType>, ValueType>(value);
  608|  64.7k|	}
_ZNK4Poco7Dynamic3Var7extractINS_9SharedPtrINS_4JSON5ArrayENS_16ReferenceCounterENS_13ReleasePolicyIS5_EEEEEERKT_v:
  208|  1.16M|	{
  209|  1.16M|		VarHolder* pHolder = content();
  210|       |
  211|  1.16M|		if (pHolder && pHolder->type() == typeid(T))
  ------------------
  |  Branch (211:7): [True: 1.16M, False: 0]
  |  Branch (211:18): [True: 1.16M, False: 0]
  ------------------
  212|  1.16M|		{
  213|  1.16M|			VarHolderImpl<T>* pHolderImpl = static_cast<VarHolderImpl<T>*>(pHolder);
  214|  1.16M|			return pHolderImpl->value();
  215|  1.16M|		}
  216|      0|		else if (!pHolder)
  ------------------
  |  Branch (216:12): [True: 0, False: 0]
  ------------------
  217|      0|			throw InvalidAccessException("Can not extract empty value.");
  218|      0|		else
  219|      0|			throw BadCastException(Poco::format("Can not convert %s to %s.",
  220|      0|				std::string(pHolder->type().name()),
  221|      0|				std::string(typeid(T).name())));
  222|  1.16M|	}
_ZN4Poco7Dynamic3VarC2INS_9SharedPtrINS_4JSON6ObjectENS_16ReferenceCounterENS_13ReleasePolicyIS5_EEEEEERKT_:
   94|  63.8k|	{
   95|  63.8k|		construct(val);
   96|  63.8k|	}
_ZNK4Poco7Dynamic3Var7extractINS_9SharedPtrINS_4JSON6ObjectENS_16ReferenceCounterENS_13ReleasePolicyIS5_EEEEEERKT_v:
  208|   305k|	{
  209|   305k|		VarHolder* pHolder = content();
  210|       |
  211|   305k|		if (pHolder && pHolder->type() == typeid(T))
  ------------------
  |  Branch (211:7): [True: 305k, False: 0]
  |  Branch (211:18): [True: 305k, False: 0]
  ------------------
  212|   305k|		{
  213|   305k|			VarHolderImpl<T>* pHolderImpl = static_cast<VarHolderImpl<T>*>(pHolder);
  214|   305k|			return pHolderImpl->value();
  215|   305k|		}
  216|      0|		else if (!pHolder)
  ------------------
  |  Branch (216:12): [True: 0, False: 0]
  ------------------
  217|      0|			throw InvalidAccessException("Can not extract empty value.");
  218|      0|		else
  219|      0|			throw BadCastException(Poco::format("Can not convert %s to %s.",
  220|      0|				std::string(pHolder->type().name()),
  221|      0|				std::string(typeid(T).name())));
  222|   305k|	}
_ZN4Poco7Dynamic3VaraSINS_9SharedPtrINS_4JSON5ArrayENS_16ReferenceCounterENS_13ReleasePolicyIS5_EEEEEERS1_RKT_:
  227|  1.19k|	{
  228|  1.19k|		clear();
  229|  1.19k|		construct(other);
  230|  1.19k|		return *this;
  231|  1.19k|	}
_ZN4Poco7Dynamic3Var9constructINS_9SharedPtrINS_4JSON5ArrayENS_16ReferenceCounterENS_13ReleasePolicyIS5_EEEEEEvRKT_:
  606|  62.3k|	{
  607|  62.3k|		_placeholder.assign<VarHolderImpl<ValueType>, ValueType>(value);
  608|  62.3k|	}
_ZN4Poco7Dynamic3VarC2INS_9SharedPtrINS_4JSON5ArrayENS_16ReferenceCounterENS_13ReleasePolicyIS5_EEEEEERKT_:
   94|  61.1k|	{
   95|  61.1k|		construct(val);
   96|  61.1k|	}

_ZN4Poco7Dynamic13VarHolderImplIlEC2El:
 1275|  4.21M|	{
 1276|  4.21M|	}
_ZNK4Poco7Dynamic13VarHolderImplIlE5cloneEPNS_11PlaceholderINS0_9VarHolderELj64EEE:
 1384|  2.82M|	{
 1385|  2.82M|		return cloneHolder(pVarHolder, _val);
 1386|  2.82M|	}
_ZN4Poco7Dynamic13VarHolderImplImEC2Em:
 1898|  3.06k|	{
 1899|  3.06k|	}
_ZNK4Poco7Dynamic13VarHolderImplImE5cloneEPNS_11PlaceholderINS0_9VarHolderELj64EEE:
 2013|  2.09k|	{
 2014|  2.09k|		return cloneHolder(pVarHolder, _val);
 2015|  2.09k|	}
_ZN4Poco7Dynamic13VarHolderImplIbEC2Eb:
 2071|  1.41k|	{
 2072|  1.41k|	}
_ZNK4Poco7Dynamic13VarHolderImplIbE5cloneEPNS_11PlaceholderINS0_9VarHolderELj64EEE:
 2163|    958|	{
 2164|    958|		return cloneHolder(pVarHolder, _val);
 2165|    958|	}
_ZN4Poco7Dynamic13VarHolderImplIdEC2Ed:
 2374|  38.8k|	{
 2375|  38.8k|	}
_ZNK4Poco7Dynamic13VarHolderImplIdE5cloneEPNS_11PlaceholderINS0_9VarHolderELj64EEE:
 2475|  25.3k|	{
 2476|  25.3k|		return cloneHolder(pVarHolder, _val);
 2477|  25.3k|	}
_ZN4Poco7Dynamic13VarHolderImplINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEC2ERKS8_:
 2687|  3.03k|	{
 2688|  3.03k|	}
_ZN4Poco7Dynamic13VarHolderImplINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEED2Ev:
 2691|  3.03k|	{
 2692|  3.03k|	}
_ZNK4Poco7Dynamic13VarHolderImplINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE5cloneEPNS_11PlaceholderINS0_9VarHolderELj64EEE:
 2833|  2.00k|	{
 2834|  2.00k|		return cloneHolder(pVarHolder, _val);
 2835|  2.00k|	}
_ZNK4Poco7Dynamic9VarHolder11cloneHolderIlEEPS1_PNS_11PlaceholderIS1_Lj64EEERKT_:
  320|  2.82M|	{
  321|  2.82M|		poco_check_ptr (pVarHolder);
  ------------------
  |  |  126|  2.82M|	if (!(ptr)) Poco::Bugcheck::nullPointer(#ptr, __FILE__, __LINE__); else (void) 0
  |  |  ------------------
  |  |  |  Branch (126:6): [True: 0, False: 2.82M]
  |  |  ------------------
  ------------------
  322|  2.82M|		return pVarHolder->assign<VarHolderImpl<T>, T>(val);
  323|  2.82M|	}
_ZNK4Poco7Dynamic9VarHolder11cloneHolderImEEPS1_PNS_11PlaceholderIS1_Lj64EEERKT_:
  320|  2.09k|	{
  321|  2.09k|		poco_check_ptr (pVarHolder);
  ------------------
  |  |  126|  2.09k|	if (!(ptr)) Poco::Bugcheck::nullPointer(#ptr, __FILE__, __LINE__); else (void) 0
  |  |  ------------------
  |  |  |  Branch (126:6): [True: 0, False: 2.09k]
  |  |  ------------------
  ------------------
  322|  2.09k|		return pVarHolder->assign<VarHolderImpl<T>, T>(val);
  323|  2.09k|	}
_ZNK4Poco7Dynamic9VarHolder11cloneHolderIbEEPS1_PNS_11PlaceholderIS1_Lj64EEERKT_:
  320|    958|	{
  321|    958|		poco_check_ptr (pVarHolder);
  ------------------
  |  |  126|    958|	if (!(ptr)) Poco::Bugcheck::nullPointer(#ptr, __FILE__, __LINE__); else (void) 0
  |  |  ------------------
  |  |  |  Branch (126:6): [True: 0, False: 958]
  |  |  ------------------
  ------------------
  322|    958|		return pVarHolder->assign<VarHolderImpl<T>, T>(val);
  323|    958|	}
_ZNK4Poco7Dynamic9VarHolder11cloneHolderIdEEPS1_PNS_11PlaceholderIS1_Lj64EEERKT_:
  320|  25.3k|	{
  321|  25.3k|		poco_check_ptr (pVarHolder);
  ------------------
  |  |  126|  25.3k|	if (!(ptr)) Poco::Bugcheck::nullPointer(#ptr, __FILE__, __LINE__); else (void) 0
  |  |  ------------------
  |  |  |  Branch (126:6): [True: 0, False: 25.3k]
  |  |  ------------------
  ------------------
  322|  25.3k|		return pVarHolder->assign<VarHolderImpl<T>, T>(val);
  323|  25.3k|	}
_ZNK4Poco7Dynamic9VarHolder11cloneHolderINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEPS1_PNS_11PlaceholderIS1_Lj64EEERKT_:
  320|  2.00k|	{
  321|  2.00k|		poco_check_ptr (pVarHolder);
  ------------------
  |  |  126|  2.00k|	if (!(ptr)) Poco::Bugcheck::nullPointer(#ptr, __FILE__, __LINE__); else (void) 0
  |  |  ------------------
  |  |  |  Branch (126:6): [True: 0, False: 2.00k]
  |  |  ------------------
  ------------------
  322|  2.00k|		return pVarHolder->assign<VarHolderImpl<T>, T>(val);
  323|  2.00k|	}
_ZNK4Poco7Dynamic9VarHolder11cloneHolderINS_9SharedPtrINS_4JSON5ArrayENS_16ReferenceCounterENS_13ReleasePolicyIS5_EEEEEEPS1_PNS_11PlaceholderIS1_Lj64EEERKT_:
  320|  1.22M|	{
  321|  1.22M|		poco_check_ptr (pVarHolder);
  ------------------
  |  |  126|  1.22M|	if (!(ptr)) Poco::Bugcheck::nullPointer(#ptr, __FILE__, __LINE__); else (void) 0
  |  |  ------------------
  |  |  |  Branch (126:6): [True: 0, False: 1.22M]
  |  |  ------------------
  ------------------
  322|  1.22M|		return pVarHolder->assign<VarHolderImpl<T>, T>(val);
  323|  1.22M|	}
_ZNK4Poco7Dynamic9VarHolder11cloneHolderINS_9SharedPtrINS_4JSON6ObjectENS_16ReferenceCounterENS_13ReleasePolicyIS5_EEEEEEPS1_PNS_11PlaceholderIS1_Lj64EEERKT_:
  320|   400k|	{
  321|   400k|		poco_check_ptr (pVarHolder);
  ------------------
  |  |  126|   400k|	if (!(ptr)) Poco::Bugcheck::nullPointer(#ptr, __FILE__, __LINE__); else (void) 0
  |  |  ------------------
  |  |  |  Branch (126:6): [True: 0, False: 400k]
  |  |  ------------------
  ------------------
  322|   400k|		return pVarHolder->assign<VarHolderImpl<T>, T>(val);
  323|   400k|	}

_ZN4Poco4JSON13JSONExceptionC2ERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEi:
  165|  5.93k|	{																								\
  166|  5.93k|	}																								\
_ZN4Poco4JSON13JSONExceptionD2Ev:
  177|  5.93k|	{																								\
  178|  5.93k|	}																								\
_ZN4Poco16RuntimeExceptionC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_i:
  168|    253|	{																								\
  169|    253|	}																								\
_ZN4Poco13DataExceptionC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_i:
  168|    253|	{																								\
  169|    253|	}																								\
_ZN4Poco15SyntaxExceptionC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_i:
  168|    253|	{																								\
  169|    253|	}																								\

_ZN4Poco13FPEnvironment10isInfiniteEd:
  157|  13.6k|{
  158|  13.6k|	return isInfiniteImpl(value);
  159|  13.6k|}
_ZN4Poco13FPEnvironment5isNaNEd:
  175|  13.4k|{
  176|  13.4k|	return isNaNImpl(value);
  177|  13.4k|}

_ZN4Poco17FPEnvironmentImpl14isInfiniteImplEd:
  121|  13.6k|{
  122|       |#if POCO_OS == POCO_OS_AIX
  123|       |	return ::isinf(value) != 0;
  124|       |#else
  125|  13.6k|	return std::isinf(value) != 0;
  126|  13.6k|#endif
  127|  13.6k|}
_ZN4Poco17FPEnvironmentImpl9isNaNImplEd:
  151|  13.4k|{
  152|       |#if POCO_OS == POCO_OS_AIX
  153|       |	return ::isnan(value) != 0;
  154|       |#else
  155|  13.4k|	return std::isnan(value) != 0;
  156|  13.4k|#endif
  157|  13.4k|}

_ZN4Poco12safeMultiplyImmsEEbRT_T0_T1_:
  116|  1.45M|{
  117|  1.45M|	if ((f == 0) || (s==0))
  ------------------
  |  Branch (117:6): [True: 1.39M, False: 61.7k]
  |  Branch (117:18): [True: 0, False: 61.7k]
  ------------------
  118|  1.39M|	{
  119|  1.39M|		result = 0;
  120|  1.39M|		return true;
  121|  1.39M|	}
  122|       |
  123|  61.7k|	if (f > 0)
  ------------------
  |  Branch (123:6): [True: 61.7k, False: 0]
  ------------------
  124|  61.7k|	{
  125|  61.7k|		if (s > 0)
  ------------------
  |  Branch (125:7): [True: 61.7k, False: 0]
  ------------------
  126|  61.7k|		{
  127|  61.7k|			if (f > (std::numeric_limits<R>::max() / s))
  ------------------
  |  Branch (127:8): [True: 0, False: 61.7k]
  ------------------
  128|      0|				return false;
  129|  61.7k|		}
  130|      0|		else
  131|      0|		{
  132|      0|			if (s < (std::numeric_limits<R>::min() / f))
  ------------------
  |  Branch (132:8): [True: 0, False: 0]
  ------------------
  133|      0|				return false;
  134|      0|		}
  135|  61.7k|	}
  136|      0|	else
  137|      0|	{
  138|      0|		if (s > 0)
  ------------------
  |  Branch (138:7): [True: 0, False: 0]
  ------------------
  139|      0|		{
  140|      0|			if (f < (std::numeric_limits<R>::min() / s))
  ------------------
  |  Branch (140:8): [True: 0, False: 0]
  ------------------
  141|      0|				return false;
  142|      0|		}
  143|      0|		else
  144|      0|		{
  145|      0|			if (s < (std::numeric_limits<R>::max() / f))
  ------------------
  |  Branch (145:8): [True: 0, False: 0]
  ------------------
  146|      0|				return false;
  147|      0|		}
  148|      0|	}
  149|  61.7k|	result = f * s;
  150|  61.7k|	return true;
  151|  61.7k|}
_ZN4Poco8strToIntIlEEbPKcRT_sc:
  217|  1.39M|{
  218|  1.39M|	poco_assert_dbg (base == 2 || base == 8 || base == 10 || base == 16);
  219|       |
  220|  1.39M|	if (!pStr) return false;
  ------------------
  |  Branch (220:6): [True: 0, False: 1.39M]
  ------------------
  221|  1.39M|	while (std::isspace(*pStr)) ++pStr;
  ------------------
  |  Branch (221:9): [True: 0, False: 1.39M]
  ------------------
  222|  1.39M|	if ((*pStr == '\0') || ((*pStr == '-') && ((base != 10) || (std::is_unsigned<I>::value))))
  ------------------
  |  Branch (222:6): [True: 0, False: 1.39M]
  |  Branch (222:26): [True: 329, False: 1.39M]
  |  Branch (222:45): [True: 0, False: 329]
  |  Branch (222:61): [Folded - Ignored]
  ------------------
  223|      0|		return false;
  224|       |
  225|  1.39M|	bool negative = false;
  226|  1.39M|	if ((base == 10) && (*pStr == '-'))
  ------------------
  |  Branch (226:6): [True: 1.39M, False: 0]
  |  Branch (226:22): [True: 329, False: 1.39M]
  ------------------
  227|    329|	{
  228|    329|		if (!std::numeric_limits<I>::is_signed) return false;
  ------------------
  |  Branch (228:7): [Folded - Ignored]
  ------------------
  229|    329|		negative = true;
  230|    329|		++pStr;
  231|    329|	}
  232|  1.39M|	else if (*pStr == '+') ++pStr;
  ------------------
  |  Branch (232:11): [True: 0, False: 1.39M]
  ------------------
  233|       |
  234|       |	// numbers are parsed as unsigned, for negative numbers the sign is applied after parsing
  235|       |	// overflow is checked in every parse step
  236|  1.39M|	uintmax_t limitCheck = std::numeric_limits<I>::max();
  237|  1.39M|	if (negative) ++limitCheck;
  ------------------
  |  Branch (237:6): [True: 329, False: 1.39M]
  ------------------
  238|  1.39M|	uintmax_t result = 0;
  239|  1.39M|	unsigned char add = 0;
  240|  2.83M|	for (; *pStr != '\0'; ++pStr)
  ------------------
  |  Branch (240:9): [True: 1.43M, False: 1.39M]
  ------------------
  241|  1.43M|	{
  242|  1.43M|		if (*pStr == thSep)
  ------------------
  |  Branch (242:7): [True: 0, False: 1.43M]
  ------------------
  243|      0|		{
  244|      0|			if (base == 10) continue;
  ------------------
  |  Branch (244:8): [True: 0, False: 0]
  ------------------
  245|      0|			throw Poco::SyntaxException("strToInt: thousand separators only allowed for base 10");
  246|      0|		}
  247|  1.43M|		if (result > (limitCheck / base)) return false;
  ------------------
  |  Branch (247:7): [True: 665, False: 1.43M]
  ------------------
  248|  1.43M|		if (!safeMultiply(result, result, base)) return false;
  ------------------
  |  Branch (248:7): [True: 0, False: 1.43M]
  ------------------
  249|  1.43M|		switch (*pStr)
  250|  1.43M|		{
  251|  1.23M|		case '0': case '1': case '2': case '3':
  ------------------
  |  Branch (251:3): [True: 1.02M, False: 417k]
  |  Branch (251:13): [True: 117k, False: 1.32M]
  |  Branch (251:23): [True: 72.1k, False: 1.36M]
  |  Branch (251:33): [True: 25.5k, False: 1.41M]
  ------------------
  252|  1.32M|		case '4': case '5': case '6': case '7':
  ------------------
  |  Branch (252:3): [True: 2.72k, False: 1.43M]
  |  Branch (252:13): [True: 78.5k, False: 1.35M]
  |  Branch (252:23): [True: 2.40k, False: 1.43M]
  |  Branch (252:33): [True: 3.77k, False: 1.43M]
  ------------------
  253|  1.32M|			add = (*pStr - '0');
  254|  1.32M|			break;
  255|       |
  256|   114k|		case '8': case '9':
  ------------------
  |  Branch (256:3): [True: 46.8k, False: 1.39M]
  |  Branch (256:13): [True: 68.1k, False: 1.37M]
  ------------------
  257|   114k|			if ((base == 10) || (base == 0x10)) add = (*pStr - '0');
  ------------------
  |  Branch (257:8): [True: 114k, False: 0]
  |  Branch (257:24): [True: 0, False: 0]
  ------------------
  258|      0|			else return false;
  259|   114k|			break;
  260|       |
  261|   114k|		case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
  ------------------
  |  Branch (261:3): [True: 0, False: 1.43M]
  |  Branch (261:13): [True: 0, False: 1.43M]
  |  Branch (261:23): [True: 0, False: 1.43M]
  |  Branch (261:33): [True: 0, False: 1.43M]
  |  Branch (261:43): [True: 0, False: 1.43M]
  |  Branch (261:53): [True: 0, False: 1.43M]
  ------------------
  262|      0|			if (base != 0x10) return false;
  ------------------
  |  Branch (262:8): [True: 0, False: 0]
  ------------------
  263|      0|			add = (*pStr - 'a') + 10;
  264|      0|			break;
  265|       |
  266|      0|		case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
  ------------------
  |  Branch (266:3): [True: 0, False: 1.43M]
  |  Branch (266:13): [True: 0, False: 1.43M]
  |  Branch (266:23): [True: 0, False: 1.43M]
  |  Branch (266:33): [True: 0, False: 1.43M]
  |  Branch (266:43): [True: 0, False: 1.43M]
  |  Branch (266:53): [True: 0, False: 1.43M]
  ------------------
  267|      0|			if (base != 0x10) return false;
  ------------------
  |  Branch (267:8): [True: 0, False: 0]
  ------------------
  268|      0|			add = (*pStr - 'A') + 10;
  269|      0|			break;
  270|       |
  271|      0|		default:
  ------------------
  |  Branch (271:3): [True: 0, False: 1.43M]
  ------------------
  272|      0|			return false;
  273|  1.43M|		}
  274|  1.43M|		if ((limitCheck - static_cast<uintmax_t>(result)) < add) return false;
  ------------------
  |  Branch (274:7): [True: 365, False: 1.43M]
  ------------------
  275|  1.43M|		result += add;
  276|  1.43M|	}
  277|       |
  278|  1.39M|	if (negative && (base == 10))
  ------------------
  |  Branch (278:6): [True: 328, False: 1.39M]
  |  Branch (278:18): [True: 328, False: 0]
  ------------------
  279|    328|		outResult = static_cast<I>(-result);
  280|  1.39M|	else
  281|  1.39M|		outResult = static_cast<I>(result);
  282|       |
  283|  1.39M|	return true;
  284|  1.39M|}
_ZN4Poco8strToIntImEEbPKcRT_sc:
  217|  1.03k|{
  218|  1.03k|	poco_assert_dbg (base == 2 || base == 8 || base == 10 || base == 16);
  219|       |
  220|  1.03k|	if (!pStr) return false;
  ------------------
  |  Branch (220:6): [True: 0, False: 1.03k]
  ------------------
  221|  1.03k|	while (std::isspace(*pStr)) ++pStr;
  ------------------
  |  Branch (221:9): [True: 0, False: 1.03k]
  ------------------
  222|  1.03k|	if ((*pStr == '\0') || ((*pStr == '-') && ((base != 10) || (std::is_unsigned<I>::value))))
  ------------------
  |  Branch (222:6): [True: 0, False: 1.03k]
  |  Branch (222:26): [True: 1, False: 1.02k]
  |  Branch (222:45): [True: 0, False: 1]
  |  Branch (222:61): [Folded - Ignored]
  ------------------
  223|      1|		return false;
  224|       |
  225|  1.02k|	bool negative = false;
  226|  1.02k|	if ((base == 10) && (*pStr == '-'))
  ------------------
  |  Branch (226:6): [True: 1.02k, False: 0]
  |  Branch (226:22): [True: 0, False: 1.02k]
  ------------------
  227|      0|	{
  228|      0|		if (!std::numeric_limits<I>::is_signed) return false;
  ------------------
  |  Branch (228:7): [Folded - Ignored]
  ------------------
  229|      0|		negative = true;
  230|      0|		++pStr;
  231|      0|	}
  232|  1.02k|	else if (*pStr == '+') ++pStr;
  ------------------
  |  Branch (232:11): [True: 0, False: 1.02k]
  ------------------
  233|       |
  234|       |	// numbers are parsed as unsigned, for negative numbers the sign is applied after parsing
  235|       |	// overflow is checked in every parse step
  236|  1.02k|	uintmax_t limitCheck = std::numeric_limits<I>::max();
  237|  1.02k|	if (negative) ++limitCheck;
  ------------------
  |  Branch (237:6): [True: 0, False: 1.02k]
  ------------------
  238|  1.02k|	uintmax_t result = 0;
  239|  1.02k|	unsigned char add = 0;
  240|  20.7k|	for (; *pStr != '\0'; ++pStr)
  ------------------
  |  Branch (240:9): [True: 19.7k, False: 975]
  ------------------
  241|  19.7k|	{
  242|  19.7k|		if (*pStr == thSep)
  ------------------
  |  Branch (242:7): [True: 0, False: 19.7k]
  ------------------
  243|      0|		{
  244|      0|			if (base == 10) continue;
  ------------------
  |  Branch (244:8): [True: 0, False: 0]
  ------------------
  245|      0|			throw Poco::SyntaxException("strToInt: thousand separators only allowed for base 10");
  246|      0|		}
  247|  19.7k|		if (result > (limitCheck / base)) return false;
  ------------------
  |  Branch (247:7): [True: 53, False: 19.7k]
  ------------------
  248|  19.7k|		if (!safeMultiply(result, result, base)) return false;
  ------------------
  |  Branch (248:7): [True: 0, False: 19.7k]
  ------------------
  249|  19.7k|		switch (*pStr)
  250|  19.7k|		{
  251|  7.81k|		case '0': case '1': case '2': case '3':
  ------------------
  |  Branch (251:3): [True: 2.71k, False: 17.0k]
  |  Branch (251:13): [True: 1.24k, False: 18.4k]
  |  Branch (251:23): [True: 1.85k, False: 17.8k]
  |  Branch (251:33): [True: 1.99k, False: 17.7k]
  ------------------
  252|  16.4k|		case '4': case '5': case '6': case '7':
  ------------------
  |  Branch (252:3): [True: 1.52k, False: 18.2k]
  |  Branch (252:13): [True: 3.36k, False: 16.3k]
  |  Branch (252:23): [True: 1.21k, False: 18.5k]
  |  Branch (252:33): [True: 2.54k, False: 17.1k]
  ------------------
  253|  16.4k|			add = (*pStr - '0');
  254|  16.4k|			break;
  255|       |
  256|  3.27k|		case '8': case '9':
  ------------------
  |  Branch (256:3): [True: 1.70k, False: 18.0k]
  |  Branch (256:13): [True: 1.56k, False: 18.1k]
  ------------------
  257|  3.27k|			if ((base == 10) || (base == 0x10)) add = (*pStr - '0');
  ------------------
  |  Branch (257:8): [True: 3.27k, False: 0]
  |  Branch (257:24): [True: 0, False: 0]
  ------------------
  258|      0|			else return false;
  259|  3.27k|			break;
  260|       |
  261|  3.27k|		case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
  ------------------
  |  Branch (261:3): [True: 0, False: 19.7k]
  |  Branch (261:13): [True: 0, False: 19.7k]
  |  Branch (261:23): [True: 0, False: 19.7k]
  |  Branch (261:33): [True: 0, False: 19.7k]
  |  Branch (261:43): [True: 0, False: 19.7k]
  |  Branch (261:53): [True: 0, False: 19.7k]
  ------------------
  262|      0|			if (base != 0x10) return false;
  ------------------
  |  Branch (262:8): [True: 0, False: 0]
  ------------------
  263|      0|			add = (*pStr - 'a') + 10;
  264|      0|			break;
  265|       |
  266|      0|		case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
  ------------------
  |  Branch (266:3): [True: 0, False: 19.7k]
  |  Branch (266:13): [True: 0, False: 19.7k]
  |  Branch (266:23): [True: 0, False: 19.7k]
  |  Branch (266:33): [True: 0, False: 19.7k]
  |  Branch (266:43): [True: 0, False: 19.7k]
  |  Branch (266:53): [True: 0, False: 19.7k]
  ------------------
  267|      0|			if (base != 0x10) return false;
  ------------------
  |  Branch (267:8): [True: 0, False: 0]
  ------------------
  268|      0|			add = (*pStr - 'A') + 10;
  269|      0|			break;
  270|       |
  271|      0|		default:
  ------------------
  |  Branch (271:3): [True: 0, False: 19.7k]
  ------------------
  272|      0|			return false;
  273|  19.7k|		}
  274|  19.7k|		if ((limitCheck - static_cast<uintmax_t>(result)) < add) return false;
  ------------------
  |  Branch (274:7): [True: 1, False: 19.7k]
  ------------------
  275|  19.7k|		result += add;
  276|  19.7k|	}
  277|       |
  278|    975|	if (negative && (base == 10))
  ------------------
  |  Branch (278:6): [True: 0, False: 975]
  |  Branch (278:18): [True: 0, False: 0]
  ------------------
  279|      0|		outResult = static_cast<I>(-result);
  280|    975|	else
  281|    975|		outResult = static_cast<I>(result);
  282|       |
  283|    975|	return true;
  284|  1.02k|}

_ZN4Poco9SharedPtrINS_4JSON7HandlerENS_16ReferenceCounterENS_13ReleasePolicyIS2_EEED2Ev:
  160|  12.5k|	{
  161|  12.5k|		release();
  162|  12.5k|	}
_ZN4Poco9SharedPtrINS_4JSON7HandlerENS_16ReferenceCounterENS_13ReleasePolicyIS2_EEE7releaseEv:
  440|  12.5k|	{
  441|  12.5k|		if (_pCounter && _pCounter->release() == 0)
  ------------------
  |  Branch (441:7): [True: 12.5k, False: 0]
  |  Branch (441:20): [True: 6.26k, False: 6.26k]
  ------------------
  442|  6.26k|		{
  443|  6.26k|			RP::release(_ptr);
  444|  6.26k|			_ptr = nullptr;
  445|       |
  446|  6.26k|			delete _pCounter;
  447|  6.26k|			_pCounter = nullptr;
  448|  6.26k|		}
  449|  12.5k|	}
_ZN4Poco16ReferenceCounter7releaseEv:
   45|  3.30M|	{
   46|  3.30M|		return --_cnt;
   47|  3.30M|	}
_ZN4Poco13ReleasePolicyINS_4JSON7HandlerEE7releaseEPS2_:
   68|  6.26k|	{
   69|  6.26k|		delete pObj;
   70|  6.26k|	}
_ZN4Poco9SharedPtrINS_4JSON7HandlerENS_16ReferenceCounterENS_13ReleasePolicyIS2_EEEC2EPS2_:
  126|  12.5k|	try:
  127|  12.5k|		_pCounter(ptr ? new RC : nullptr),
  128|  12.5k|		_ptr(ptr)
  129|  12.5k|	{
  130|  12.5k|	}
  131|  12.5k|	catch (...)
  132|  12.5k|	{
  133|      0|		RP::release(ptr);
  134|      0|	}
_ZN4Poco16ReferenceCounterC2Ev:
   36|  69.8k|	{
   37|  69.8k|	}
_ZN4Poco16ReferenceCounter9duplicateEv:
   40|  3.23M|	{
   41|  3.23M|		++_cnt;
   42|  3.23M|	}
_ZN4Poco9SharedPtrINS_4JSON5ArrayENS_16ReferenceCounterENS_13ReleasePolicyIS2_EEE7releaseEv:
  440|  2.48M|	{
  441|  2.48M|		if (_pCounter && _pCounter->release() == 0)
  ------------------
  |  Branch (441:7): [True: 2.48M, False: 0]
  |  Branch (441:20): [True: 31.1k, False: 2.45M]
  ------------------
  442|  31.1k|		{
  443|  31.1k|			RP::release(_ptr);
  444|  31.1k|			_ptr = nullptr;
  445|       |
  446|  31.1k|			delete _pCounter;
  447|  31.1k|			_pCounter = nullptr;
  448|  31.1k|		}
  449|  2.48M|	}
_ZN4Poco13ReleasePolicyINS_4JSON5ArrayEE7releaseEPS2_:
   68|  31.1k|	{
   69|  31.1k|		delete pObj;
   70|  31.1k|	}
_ZNK4Poco9SharedPtrINS_4JSON5ArrayENS_16ReferenceCounterENS_13ReleasePolicyIS2_EEE5derefEv:
  432|  1.16M|	{
  433|  1.16M|		if (!_ptr)
  ------------------
  |  Branch (433:7): [True: 0, False: 1.16M]
  ------------------
  434|      0|			throw NullPointerException();
  435|       |
  436|  1.16M|		return _ptr;
  437|  1.16M|	}
_ZN4Poco9SharedPtrINS_4JSON6ObjectENS_16ReferenceCounterENS_13ReleasePolicyIS2_EEE7releaseEv:
  440|   803k|	{
  441|   803k|		if (_pCounter && _pCounter->release() == 0)
  ------------------
  |  Branch (441:7): [True: 803k, False: 0]
  |  Branch (441:20): [True: 32.3k, False: 770k]
  ------------------
  442|  32.3k|		{
  443|  32.3k|			RP::release(_ptr);
  444|  32.3k|			_ptr = nullptr;
  445|       |
  446|  32.3k|			delete _pCounter;
  447|  32.3k|			_pCounter = nullptr;
  448|  32.3k|		}
  449|   803k|	}
_ZN4Poco13ReleasePolicyINS_4JSON6ObjectEE7releaseEPS2_:
   68|  32.3k|	{
   69|  32.3k|		delete pObj;
   70|  32.3k|	}
_ZNK4Poco9SharedPtrINS_4JSON6ObjectENS_16ReferenceCounterENS_13ReleasePolicyIS2_EEE5derefEv:
  432|   305k|	{
  433|   305k|		if (!_ptr)
  ------------------
  |  Branch (433:7): [True: 0, False: 305k]
  ------------------
  434|      0|			throw NullPointerException();
  435|       |
  436|   305k|		return _ptr;
  437|   305k|	}
_ZN4Poco9SharedPtrINS_4JSON7HandlerENS_16ReferenceCounterENS_13ReleasePolicyIS2_EEEcvPS2_Ev:
  306|  1.82M|	{
  307|  1.82M|		return _ptr;
  308|  1.82M|	}
_ZN4Poco9SharedPtrINS_4JSON7HandlerENS_16ReferenceCounterENS_13ReleasePolicyIS2_EEEptEv:
  276|  1.82M|	{
  277|  1.82M|		return deref();
  278|  1.82M|	}
_ZNK4Poco9SharedPtrINS_4JSON7HandlerENS_16ReferenceCounterENS_13ReleasePolicyIS2_EEE5derefEv:
  432|  1.82M|	{
  433|  1.82M|		if (!_ptr)
  ------------------
  |  Branch (433:7): [True: 0, False: 1.82M]
  ------------------
  434|      0|			throw NullPointerException();
  435|       |
  436|  1.82M|		return _ptr;
  437|  1.82M|	}
_ZNK4Poco9SharedPtrINS_4JSON7HandlerENS_16ReferenceCounterENS_13ReleasePolicyIS2_EEEcvPKS2_Ev:
  311|     78|	{
  312|     78|		return _ptr;
  313|     78|	}
_ZNK4Poco9SharedPtrINS_4JSON7HandlerENS_16ReferenceCounterENS_13ReleasePolicyIS2_EEEptEv:
  281|     78|	{
  282|     78|		return deref();
  283|     78|	}
_ZN4Poco9SharedPtrINS_4JSON5ArrayENS_16ReferenceCounterENS_13ReleasePolicyIS2_EEEC2ERKS6_:
  147|  2.45M|	{
  148|  2.45M|		if (_pCounter) _pCounter->duplicate();
  ------------------
  |  Branch (148:7): [True: 2.45M, False: 0]
  ------------------
  149|  2.45M|	}
_ZN4Poco9SharedPtrINS_4JSON5ArrayENS_16ReferenceCounterENS_13ReleasePolicyIS2_EEED2Ev:
  160|  2.48M|	{
  161|  2.48M|		release();
  162|  2.48M|	}
_ZN4Poco9SharedPtrINS_4JSON6ObjectENS_16ReferenceCounterENS_13ReleasePolicyIS2_EEEC2ERKS6_:
  147|   770k|	{
  148|   770k|		if (_pCounter) _pCounter->duplicate();
  ------------------
  |  Branch (148:7): [True: 770k, False: 0]
  ------------------
  149|   770k|	}
_ZN4Poco9SharedPtrINS_4JSON6ObjectENS_16ReferenceCounterENS_13ReleasePolicyIS2_EEED2Ev:
  160|   803k|	{
  161|   803k|		release();
  162|   803k|	}
_ZN4Poco9SharedPtrINS_4JSON6ObjectENS_16ReferenceCounterENS_13ReleasePolicyIS2_EEEC2EPS2_:
  126|  64.7k|	try:
  127|  64.7k|		_pCounter(ptr ? new RC : nullptr),
  128|  64.7k|		_ptr(ptr)
  129|  64.7k|	{
  130|  64.7k|	}
  131|  64.7k|	catch (...)
  132|  64.7k|	{
  133|      0|		RP::release(ptr);
  134|      0|	}
_ZN4Poco9SharedPtrINS_4JSON5ArrayENS_16ReferenceCounterENS_13ReleasePolicyIS2_EEEptEv:
  276|  1.16M|	{
  277|  1.16M|		return deref();
  278|  1.16M|	}
_ZN4Poco9SharedPtrINS_4JSON6ObjectENS_16ReferenceCounterENS_13ReleasePolicyIS2_EEEptEv:
  276|   305k|	{
  277|   305k|		return deref();
  278|   305k|	}
_ZN4Poco9SharedPtrINS_4JSON5ArrayENS_16ReferenceCounterENS_13ReleasePolicyIS2_EEEC2EPS2_:
  126|  62.3k|	try:
  127|  62.3k|		_pCounter(ptr ? new RC : nullptr),
  128|  62.3k|		_ptr(ptr)
  129|  62.3k|	{
  130|  62.3k|	}
  131|  62.3k|	catch (...)
  132|  62.3k|	{
  133|      0|		RP::release(ptr);
  134|      0|	}
_ZN4Poco9SharedPtrINS_4JSON7HandlerENS_16ReferenceCounterENS_13ReleasePolicyIS2_EEEC2ERKS6_:
  147|  6.26k|	{
  148|  6.26k|		if (_pCounter) _pCounter->duplicate();
  ------------------
  |  Branch (148:7): [True: 6.26k, False: 0]
  ------------------
  149|  6.26k|	}
_ZN4Poco9SharedPtrINSt3__16vectorINS_7Dynamic3VarENS1_9allocatorIS4_EEEENS_16ReferenceCounterENS_13ReleasePolicyIS7_EEEC2Ev:
  122|  31.1k|	{
  123|  31.1k|	}
_ZN4Poco9SharedPtrINSt3__16vectorINS_7Dynamic3VarENS1_9allocatorIS4_EEEENS_16ReferenceCounterENS_13ReleasePolicyIS7_EEED2Ev:
  160|  31.1k|	{
  161|  31.1k|		release();
  162|  31.1k|	}
_ZN4Poco9SharedPtrINSt3__16vectorINS_7Dynamic3VarENS1_9allocatorIS4_EEEENS_16ReferenceCounterENS_13ReleasePolicyIS7_EEE7releaseEv:
  440|  31.1k|	{
  441|  31.1k|		if (_pCounter && _pCounter->release() == 0)
  ------------------
  |  Branch (441:7): [True: 0, False: 31.1k]
  |  Branch (441:20): [True: 0, False: 0]
  ------------------
  442|      0|		{
  443|      0|			RP::release(_ptr);
  444|      0|			_ptr = nullptr;
  445|       |
  446|      0|			delete _pCounter;
  447|      0|			_pCounter = nullptr;
  448|      0|		}
  449|  31.1k|	}
_ZN4Poco9SharedPtrINS_7Dynamic6StructINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS3_3mapIS9_NS1_3VarENS3_4lessIS9_EENS7_INS3_4pairIKS9_SB_EEEEEENS3_3setIS9_SD_NS7_IS9_EEEEEENS_16ReferenceCounterENS_13ReleasePolicyISM_EEEC2Ev:
  122|  32.3k|	{
  123|  32.3k|	}
_ZN4Poco9SharedPtrINS_7Dynamic6StructINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEN3tsl11ordered_mapIS9_NS1_3VarENS3_4hashIS9_EENS3_8equal_toIS9_EENS7_INS3_4pairIS9_SC_EEEENS3_5dequeISI_SJ_EEEENSA_11ordered_setIS9_SE_SG_NS7_IS9_EENSK_IS9_SO_EEEEEENS_16ReferenceCounterENS_13ReleasePolicyISR_EEEC2Ev:
  122|  32.3k|	{
  123|  32.3k|	}
_ZN4Poco9SharedPtrINS_7Dynamic6StructINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS3_3mapIS9_NS1_3VarENS3_4lessIS9_EENS7_INS3_4pairIKS9_SB_EEEEEENS3_3setIS9_SD_NS7_IS9_EEEEEENS_16ReferenceCounterENS_13ReleasePolicyISM_EEED2Ev:
  160|  32.3k|	{
  161|  32.3k|		release();
  162|  32.3k|	}
_ZN4Poco9SharedPtrINS_7Dynamic6StructINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS3_3mapIS9_NS1_3VarENS3_4lessIS9_EENS7_INS3_4pairIKS9_SB_EEEEEENS3_3setIS9_SD_NS7_IS9_EEEEEENS_16ReferenceCounterENS_13ReleasePolicyISM_EEE7releaseEv:
  440|  32.3k|	{
  441|  32.3k|		if (_pCounter && _pCounter->release() == 0)
  ------------------
  |  Branch (441:7): [True: 0, False: 32.3k]
  |  Branch (441:20): [True: 0, False: 0]
  ------------------
  442|      0|		{
  443|      0|			RP::release(_ptr);
  444|      0|			_ptr = nullptr;
  445|       |
  446|      0|			delete _pCounter;
  447|      0|			_pCounter = nullptr;
  448|      0|		}
  449|  32.3k|	}
_ZN4Poco9SharedPtrINS_7Dynamic6StructINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEN3tsl11ordered_mapIS9_NS1_3VarENS3_4hashIS9_EENS3_8equal_toIS9_EENS7_INS3_4pairIS9_SC_EEEENS3_5dequeISI_SJ_EEEENSA_11ordered_setIS9_SE_SG_NS7_IS9_EENSK_IS9_SO_EEEEEENS_16ReferenceCounterENS_13ReleasePolicyISR_EEED2Ev:
  160|  32.3k|	{
  161|  32.3k|		release();
  162|  32.3k|	}
_ZN4Poco9SharedPtrINS_7Dynamic6StructINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEN3tsl11ordered_mapIS9_NS1_3VarENS3_4hashIS9_EENS3_8equal_toIS9_EENS7_INS3_4pairIS9_SC_EEEENS3_5dequeISI_SJ_EEEENSA_11ordered_setIS9_SE_SG_NS7_IS9_EENSK_IS9_SO_EEEEEENS_16ReferenceCounterENS_13ReleasePolicyISR_EEE7releaseEv:
  440|  32.3k|	{
  441|  32.3k|		if (_pCounter && _pCounter->release() == 0)
  ------------------
  |  Branch (441:7): [True: 0, False: 32.3k]
  |  Branch (441:20): [True: 0, False: 0]
  ------------------
  442|      0|		{
  443|      0|			RP::release(_ptr);
  444|      0|			_ptr = nullptr;
  445|       |
  446|      0|			delete _pCounter;
  447|      0|			_pCounter = nullptr;
  448|      0|		}
  449|  32.3k|	}

_ZN4Poco14replaceInPlaceINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEERT_S9_NS8_10value_typeESA_NS8_9size_typeE:
  518|  41.0k|{
  519|  41.0k|	if (from == to) return str;
  ------------------
  |  Branch (519:6): [True: 13.6k, False: 27.3k]
  ------------------
  520|       |
  521|  27.3k|	typename S::size_type pos = 0;
  522|  27.3k|	do
  523|  27.3k|	{
  524|  27.3k|		pos = str.find(from, start);
  525|  27.3k|		if (pos != S::npos)
  ------------------
  |  Branch (525:7): [True: 0, False: 27.3k]
  ------------------
  526|      0|		{
  527|      0|			if (to) str[pos] = to;
  ------------------
  |  Branch (527:8): [True: 0, False: 0]
  ------------------
  528|      0|			else str.erase(pos, 1);
  529|      0|		}
  530|  27.3k|	} while (pos != S::npos);
  ------------------
  |  Branch (530:11): [True: 0, False: 27.3k]
  ------------------
  531|       |
  532|  27.3k|	return str;
  533|  41.0k|}
_ZN4Poco11trimInPlaceINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEERT_S9_:
  104|  13.6k|{
  105|  13.6k|	std::ptrdiff_t first = 0;
  106|  13.6k|	std::ptrdiff_t last  = static_cast<std::ptrdiff_t>(str.size()) - 1;
  107|       |
  108|  13.6k|	while (first <= last && Ascii::isSpace(str[first])) ++first;
  ------------------
  |  Branch (108:9): [True: 13.6k, False: 0]
  |  Branch (108:26): [True: 0, False: 13.6k]
  ------------------
  109|  13.6k|	while (last >= first && Ascii::isSpace(str[last])) --last;
  ------------------
  |  Branch (109:9): [True: 13.6k, False: 0]
  |  Branch (109:26): [True: 0, False: 13.6k]
  ------------------
  110|       |
  111|  13.6k|	if (last >= 0)
  ------------------
  |  Branch (111:6): [True: 13.6k, False: 0]
  ------------------
  112|  13.6k|	{
  113|  13.6k|		str.resize(last + 1);
  114|  13.6k|		str.erase(0, first);
  115|  13.6k|	}
  116|  13.6k|	return str;
  117|  13.6k|}
_ZN4Poco13removeInPlaceINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEERT_S9_NS8_10value_typeENS8_9size_typeE:
  538|  27.3k|{
  539|  27.3k|	return replaceInPlace(str, ch, 0, start);
  540|  27.3k|}

_ZN4Poco13AtomicCounterC2Ei:
   29|  69.8k|{
   30|  69.8k|}
_ZN4Poco13AtomicCounterD2Ev:
   40|  69.8k|{
   41|  69.8k|}

_ZN4Poco9ExceptionC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEi:
   28|  5.93k|{
   29|  5.93k|}
_ZN4Poco9ExceptionC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_i:
   33|    253|{
   34|    253|	if (!arg.empty())
  ------------------
  |  Branch (34:6): [True: 253, False: 0]
  ------------------
   35|    253|	{
   36|    253|		_msg.append(": ");
   37|    253|		_msg.append(arg);
   38|    253|	}
   39|    253|}
_ZN4Poco9ExceptionD2Ev:
   57|  6.19k|{
   58|  6.19k|	delete _pNested;
   59|  6.19k|}

_ZN4Poco12NumberParser10tryParse64ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERlc:
  121|  1.39M|{
  122|  1.39M|	return strToInt(s.c_str(), value, NUM_BASE_DEC, thSep);
  123|  1.39M|}
_ZN4Poco12NumberParser15parseUnsigned64ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEc:
  127|  1.03k|{
  128|  1.03k|	UInt64 result;
  129|  1.03k|	if (tryParseUnsigned64(s, result, thSep))
  ------------------
  |  Branch (129:6): [True: 975, False: 55]
  ------------------
  130|    975|		return result;
  131|     55|	else
  132|     55|		throw SyntaxException("Not a valid unsigned integer", s);
  133|  1.03k|}
_ZN4Poco12NumberParser18tryParseUnsigned64ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERmc:
  137|  1.03k|{
  138|  1.03k|	return strToInt(s.c_str(), value, NUM_BASE_DEC, thSep);
  139|  1.03k|}
_ZN4Poco12NumberParser10parseFloatERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEcc:
  180|  13.6k|{
  181|  13.6k|	double result;
  182|  13.6k|	if (tryParseFloat(s, result, decSep, thSep))
  ------------------
  |  Branch (182:6): [True: 13.4k, False: 198]
  ------------------
  183|  13.4k|		return result;
  184|    198|	else
  185|    198|		throw SyntaxException("Not a valid floating-point number", s);
  186|  13.6k|}
_ZN4Poco12NumberParser13tryParseFloatERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERdcc:
  190|  13.6k|{
  191|  13.6k|	return strToDouble(s.c_str(), value, decSep, thSep);
  192|  13.6k|}

_ZN4Poco11strToDoubleEPKcS1_S1_:
  307|  13.6k|{
  308|  13.6k|	using namespace double_conversion;
  309|  13.6k|	int processed;
  310|  13.6k|	int flags = StringToDoubleConverter::ALLOW_LEADING_SPACES |
  311|  13.6k|		StringToDoubleConverter::ALLOW_TRAILING_SPACES;
  312|  13.6k|	StringToDoubleConverter converter(flags, 0.0, Double::NaN(), inf, nan);
  313|  13.6k|	double result = converter.StringToDouble(str, static_cast<int>(strlen(str)), &processed);
  314|  13.6k|	return result;
  315|  13.6k|}
_ZN4Poco11strToDoubleERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEERdccPKcSB_:
  334|  13.6k|{
  335|  13.6k|	if (str.empty()) return false;
  ------------------
  |  Branch (335:6): [True: 0, False: 13.6k]
  ------------------
  336|       |
  337|  13.6k|	using namespace double_conversion;
  338|       |
  339|  13.6k|	std::string tmp(str);
  340|  13.6k|	trimInPlace(tmp);
  341|  13.6k|	removeInPlace(tmp, thSep);
  342|  13.6k|	replaceInPlace(tmp, decSep, '.');
  343|  13.6k|	removeInPlace(tmp, 'f');
  344|  13.6k|	result = strToDouble(tmp.c_str(), inf, nan);
  345|  13.6k|	return !FPEnvironment::isInfinite(result) &&
  ------------------
  |  Branch (345:9): [True: 13.4k, False: 198]
  ------------------
  346|  13.6k|		!FPEnvironment::isNaN(result);
  ------------------
  |  Branch (346:3): [True: 13.4k, False: 0]
  ------------------
  347|  13.6k|}

_ZN4Poco6TZInfoC2Ev:
   28|      2|	{
   29|      2|		tzset();
   30|      2|	}

_ZN4Poco12UTF8EncodingC2Ev:
   52|      2|{
   53|      2|}

_ZN4Poco4UUIDC2Ev:
   30|     10|{
   31|     10|	std::memset(_node, 0, sizeof(_node));
   32|     10|}
_ZN4Poco4UUIDC2EPKc:
   52|      8|{
   53|      8|	poco_check_ptr (uuid);
  ------------------
  |  |  126|      8|	if (!(ptr)) Poco::Bugcheck::nullPointer(#ptr, __FILE__, __LINE__); else (void) 0
  |  |  ------------------
  |  |  |  Branch (126:6): [True: 0, False: 8]
  |  |  ------------------
  ------------------
   54|      8|	parse(std::string(uuid));
   55|      8|}
_ZN4Poco4UUIDD2Ev:
   94|      8|{
   95|      8|}
_ZN4Poco4UUID4swapERS0_:
  113|      8|{
  114|      8|	std::swap(_timeLow, uuid._timeLow);
  115|      8|	std::swap(_timeMid, uuid._timeMid);
  116|      8|	std::swap(_timeHiAndVersion, uuid._timeHiAndVersion);
  117|      8|	std::swap(_clockSeq, uuid._clockSeq);
  118|      8|	std::swap_ranges(_node, _node + 6, &uuid._node[0]);
  119|      8|}
_ZN4Poco4UUID5parseERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  123|      8|{
  124|      8|	if (!tryParse(uuid))
  ------------------
  |  Branch (124:6): [True: 0, False: 8]
  ------------------
  125|      0|		throw SyntaxException(uuid);
  126|      8|}
_ZN4Poco4UUID8tryParseERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  130|      8|{
  131|      8|	if (uuid.size() < 32)
  ------------------
  |  Branch (131:6): [True: 0, False: 8]
  ------------------
  132|      0|		return false;
  133|       |
  134|      8|	bool haveHyphens = false;
  135|      8|	if (uuid[8] == '-' && uuid[13] == '-' && uuid[18] == '-' && uuid[23] == '-')
  ------------------
  |  Branch (135:6): [True: 8, False: 0]
  |  Branch (135:24): [True: 8, False: 0]
  |  Branch (135:43): [True: 8, False: 0]
  |  Branch (135:62): [True: 8, False: 0]
  ------------------
  136|      8|	{
  137|      8|		if (uuid.size() == 36)
  ------------------
  |  Branch (137:7): [True: 8, False: 0]
  ------------------
  138|      8|			haveHyphens = true;
  139|      0|		else
  140|      0|			return false;
  141|      8|	}
  142|       |
  143|      8|	UUID newUUID;
  144|      8|	std::string::const_iterator it = uuid.begin();
  145|      8|	newUUID._timeLow = 0;
  146|     72|	for (int i = 0; i < 8; ++i)
  ------------------
  |  Branch (146:18): [True: 64, False: 8]
  ------------------
  147|     64|	{
  148|     64|		Int16 n = nibble(*it++);
  149|     64|		if (n < 0) return false;
  ------------------
  |  Branch (149:7): [True: 0, False: 64]
  ------------------
  150|     64|		newUUID._timeLow = (newUUID._timeLow << 4) | n;
  151|     64|	}
  152|      8|	if (haveHyphens) ++it;
  ------------------
  |  Branch (152:6): [True: 8, False: 0]
  ------------------
  153|      8|	newUUID._timeMid = 0;
  154|     40|	for (int i = 0; i < 4; ++i)
  ------------------
  |  Branch (154:18): [True: 32, False: 8]
  ------------------
  155|     32|	{
  156|     32|		Int16 n = nibble(*it++);
  157|     32|		if (n < 0) return false;
  ------------------
  |  Branch (157:7): [True: 0, False: 32]
  ------------------
  158|     32|		newUUID._timeMid = (newUUID._timeMid << 4) | n;
  159|     32|	}
  160|      8|	if (haveHyphens) ++it;
  ------------------
  |  Branch (160:6): [True: 8, False: 0]
  ------------------
  161|      8|	newUUID._timeHiAndVersion = 0;
  162|     40|	for (int i = 0; i < 4; ++i)
  ------------------
  |  Branch (162:18): [True: 32, False: 8]
  ------------------
  163|     32|	{
  164|     32|		Int16 n = nibble(*it++);
  165|     32|		if (n < 0) return false;
  ------------------
  |  Branch (165:7): [True: 0, False: 32]
  ------------------
  166|     32|		newUUID._timeHiAndVersion = (newUUID._timeHiAndVersion << 4) | n;
  167|     32|	}
  168|      8|	if (haveHyphens) ++it;
  ------------------
  |  Branch (168:6): [True: 8, False: 0]
  ------------------
  169|      8|	newUUID._clockSeq = 0;
  170|     40|	for (int i = 0; i < 4; ++i)
  ------------------
  |  Branch (170:18): [True: 32, False: 8]
  ------------------
  171|     32|	{
  172|     32|		Int16 n = nibble(*it++);
  173|     32|		if (n < 0) return false;
  ------------------
  |  Branch (173:7): [True: 0, False: 32]
  ------------------
  174|     32|		newUUID._clockSeq = (newUUID._clockSeq << 4) | n;
  175|     32|	}
  176|      8|	if (haveHyphens) ++it;
  ------------------
  |  Branch (176:6): [True: 8, False: 0]
  ------------------
  177|     56|	for (int i = 0; i < 6; ++i)
  ------------------
  |  Branch (177:18): [True: 48, False: 8]
  ------------------
  178|     48|	{
  179|     48|		Int16 n1 = nibble(*it++);
  180|     48|		if (n1 < 0) return false;
  ------------------
  |  Branch (180:7): [True: 0, False: 48]
  ------------------
  181|     48|		Int16 n2 = nibble(*it++);
  182|     48|		if (n2 < 0) return false;
  ------------------
  |  Branch (182:7): [True: 0, False: 48]
  ------------------
  183|       |
  184|     48|		newUUID._node[i] = (n1 << 4) | n2;
  185|     48|	}
  186|      8|	swap(newUUID);
  187|       |
  188|      8|	return true;
  189|      8|}
_ZN4Poco4UUID6nibbleEc:
  300|    256|{
  301|    256|	if (hex >= 'a' && hex <= 'f')
  ------------------
  |  Branch (301:6): [True: 96, False: 160]
  |  Branch (301:20): [True: 96, False: 0]
  ------------------
  302|     96|		return hex - 'a' + 10;
  303|    160|	else if (hex >= 'A' && hex <= 'F')
  ------------------
  |  Branch (303:11): [True: 0, False: 160]
  |  Branch (303:25): [True: 0, False: 0]
  ------------------
  304|      0|		return hex - 'A' + 10;
  305|    160|	else if (hex >= '0' && hex <= '9')
  ------------------
  |  Branch (305:11): [True: 160, False: 0]
  |  Branch (305:25): [True: 160, False: 0]
  ------------------
  306|    160|		return hex - '0';
  307|      0|	else
  308|      0|		return -1;
  309|    256|}

_ZN4Poco7Dynamic3VarC2Ev:
   29|  13.5k|{
   30|  13.5k|}
_ZN4Poco7Dynamic3VarC2ERKS1_:
   40|  4.21M|{
   41|  4.21M|	if ((this != &other) && !other.isEmpty())
  ------------------
  |  Branch (41:6): [True: 4.21M, False: 0]
  |  Branch (41:26): [True: 4.21M, False: 1.83k]
  ------------------
   42|  4.21M|			construct(other);
   43|  4.21M|}
_ZN4Poco7Dynamic3VarD2Ev:
   47|  5.76M|{
   48|  5.76M|	destruct();
   49|  5.76M|}
_ZN4Poco7Dynamic3VaraSERKS1_:
   53|   263k|{
   54|   263k|	if (this == &rhs) return *this;
  ------------------
  |  Branch (54:6): [True: 0, False: 263k]
  ------------------
   55|   263k|	clear();
   56|   263k|	if (!rhs.isEmpty()) construct(rhs);
  ------------------
  |  Branch (56:6): [True: 263k, False: 247]
  ------------------
   57|   263k|	return *this;
   58|   263k|}
_ZN4Poco7Dynamic3Var5clearEv:
  313|   265k|{
  314|   265k|	_placeholder.erase();
  315|   265k|}

_ZN4Poco7Dynamic9VarHolderC2Ev:
   45|  6.01M|{
   46|  6.01M|}
_ZN4Poco7Dynamic9VarHolderD2Ev:
   50|  6.01M|{
   51|  6.01M|}

_ZN22poco_double_conversion6Bignum8RawBigitEi:
   36|  2.88M|Bignum::Chunk& Bignum::RawBigit(const int index) {
   37|  2.88M|  DOUBLE_CONVERSION_ASSERT(static_cast<unsigned>(index) < kBigitCapacity);
  ------------------
  |  |   47|  2.88M|    assert(condition)
  ------------------
   38|  2.88M|  return bigits_buffer_[index];
   39|  2.88M|}
_ZNK22poco_double_conversion6Bignum8RawBigitEi:
   42|  59.2k|const Bignum::Chunk& Bignum::RawBigit(const int index) const {
   43|  59.2k|  DOUBLE_CONVERSION_ASSERT(static_cast<unsigned>(index) < kBigitCapacity);
  ------------------
  |  |   47|  59.2k|    assert(condition)
  ------------------
   44|  59.2k|  return bigits_buffer_[index];
   45|  59.2k|}
_ZN22poco_double_conversion6Bignum12AssignUInt64Em:
   65|  17.7k|void Bignum::AssignUInt64(uint64_t value) {
   66|  17.7k|  Zero();
   67|  54.0k|  for(int i = 0; value > 0; ++i) {
  ------------------
  |  Branch (67:18): [True: 36.3k, False: 17.7k]
  ------------------
   68|  36.3k|    RawBigit(i) = value & kBigitMask;
   69|  36.3k|    value >>= kBigitSize;
   70|  36.3k|    ++used_bigits_;
   71|  36.3k|  }
   72|  17.7k|}
_ZN22poco_double_conversion6Bignum19AssignDecimalStringENS_6VectorIKcEE:
   97|  6.02k|void Bignum::AssignDecimalString(const Vector<const char> value) {
   98|       |  // 2^64 = 18446744073709551616 > 10^19
   99|  6.02k|  static const int kMaxUint64DecimalDigits = 19;
  100|  6.02k|  Zero();
  101|  6.02k|  int length = value.length();
  102|  6.02k|  unsigned pos = 0;
  103|       |  // Let's just say that each digit needs 4 bits.
  104|  14.5k|  while (length >= kMaxUint64DecimalDigits) {
  ------------------
  |  Branch (104:10): [True: 8.49k, False: 6.02k]
  ------------------
  105|  8.49k|    const uint64_t digits = ReadUInt64(value, pos, kMaxUint64DecimalDigits);
  106|  8.49k|    pos += kMaxUint64DecimalDigits;
  107|  8.49k|    length -= kMaxUint64DecimalDigits;
  108|  8.49k|    MultiplyByPowerOfTen(kMaxUint64DecimalDigits);
  109|  8.49k|    AddUInt64(digits);
  110|  8.49k|  }
  111|  6.02k|  const uint64_t digits = ReadUInt64(value, pos, length);
  112|  6.02k|  MultiplyByPowerOfTen(length);
  113|  6.02k|  AddUInt64(digits);
  114|  6.02k|  Clamp();
  115|  6.02k|}
_ZN22poco_double_conversion6Bignum9AddUInt64Em:
  156|  14.5k|void Bignum::AddUInt64(const uint64_t operand) {
  157|  14.5k|  if (operand == 0) {
  ------------------
  |  Branch (157:7): [True: 2.81k, False: 11.6k]
  ------------------
  158|  2.81k|    return;
  159|  2.81k|  }
  160|  11.6k|  Bignum other;
  161|  11.6k|  other.AssignUInt64(operand);
  162|  11.6k|  AddBignum(other);
  163|  11.6k|}
_ZN22poco_double_conversion6Bignum9AddBignumERKS0_:
  166|  11.6k|void Bignum::AddBignum(const Bignum& other) {
  167|  11.6k|  DOUBLE_CONVERSION_ASSERT(IsClamped());
  ------------------
  |  |   47|  11.6k|    assert(condition)
  ------------------
  168|  11.6k|  DOUBLE_CONVERSION_ASSERT(other.IsClamped());
  ------------------
  |  |   47|  11.6k|    assert(condition)
  ------------------
  169|       |
  170|       |  // If this has a greater exponent than other append zero-bigits to this.
  171|       |  // After this call exponent_ <= other.exponent_.
  172|  11.6k|  Align(other);
  173|       |
  174|       |  // There are two possibilities:
  175|       |  //   aaaaaaaaaaa 0000  (where the 0s represent a's exponent)
  176|       |  //     bbbbb 00000000
  177|       |  //   ----------------
  178|       |  //   ccccccccccc 0000
  179|       |  // or
  180|       |  //    aaaaaaaaaa 0000
  181|       |  //  bbbbbbbbb 0000000
  182|       |  //  -----------------
  183|       |  //  cccccccccccc 0000
  184|       |  // In both cases we might need a carry bigit.
  185|       |
  186|  11.6k|  EnsureCapacity(1 + (std::max)(BigitLength(), other.BigitLength()) - exponent_);
  187|  11.6k|  Chunk carry = 0;
  188|  11.6k|  int bigit_pos = other.exponent_ - exponent_;
  189|  11.6k|  DOUBLE_CONVERSION_ASSERT(bigit_pos >= 0);
  ------------------
  |  |   47|  11.6k|    assert(condition)
  ------------------
  190|  11.6k|  for (int i = used_bigits_; i < bigit_pos; ++i) {
  ------------------
  |  Branch (190:30): [True: 0, False: 11.6k]
  ------------------
  191|      0|    RawBigit(i) = 0;
  192|      0|  }
  193|  36.2k|  for (int i = 0; i < other.used_bigits_; ++i) {
  ------------------
  |  Branch (193:19): [True: 24.5k, False: 11.6k]
  ------------------
  194|  24.5k|    const Chunk my = (bigit_pos < used_bigits_) ? RawBigit(bigit_pos) : 0;
  ------------------
  |  Branch (194:22): [True: 12.6k, False: 11.8k]
  ------------------
  195|  24.5k|    const Chunk sum = my + other.RawBigit(i) + carry;
  196|  24.5k|    RawBigit(bigit_pos) = sum & kBigitMask;
  197|  24.5k|    carry = sum >> kBigitSize;
  198|  24.5k|    ++bigit_pos;
  199|  24.5k|  }
  200|  12.5k|  while (carry != 0) {
  ------------------
  |  Branch (200:10): [True: 859, False: 11.6k]
  ------------------
  201|    859|    const Chunk my = (bigit_pos < used_bigits_) ? RawBigit(bigit_pos) : 0;
  ------------------
  |  Branch (201:22): [True: 859, False: 0]
  ------------------
  202|    859|    const Chunk sum = my + carry;
  203|    859|    RawBigit(bigit_pos) = sum & kBigitMask;
  204|    859|    carry = sum >> kBigitSize;
  205|    859|    ++bigit_pos;
  206|    859|  }
  207|  11.6k|  used_bigits_ = static_cast<int16_t>(std::max(bigit_pos, static_cast<int>(used_bigits_)));
  208|  11.6k|  DOUBLE_CONVERSION_ASSERT(IsClamped());
  ------------------
  |  |   47|  11.6k|    assert(condition)
  ------------------
  209|  11.6k|}
_ZN22poco_double_conversion6Bignum9ShiftLeftEi:
  239|  19.9k|void Bignum::ShiftLeft(const int shift_amount) {
  240|  19.9k|  if (used_bigits_ == 0) {
  ------------------
  |  Branch (240:7): [True: 0, False: 19.9k]
  ------------------
  241|      0|    return;
  242|      0|  }
  243|  19.9k|  exponent_ += static_cast<int16_t>(shift_amount / kBigitSize);
  244|  19.9k|  const int local_shift = shift_amount % kBigitSize;
  245|  19.9k|  EnsureCapacity(used_bigits_ + 1);
  246|  19.9k|  BigitsShiftLeft(local_shift);
  247|  19.9k|}
_ZN22poco_double_conversion6Bignum16MultiplyByUInt32Ej:
  250|  23.1k|void Bignum::MultiplyByUInt32(const uint32_t factor) {
  251|  23.1k|  if (factor == 1) {
  ------------------
  |  Branch (251:7): [True: 0, False: 23.1k]
  ------------------
  252|      0|    return;
  253|      0|  }
  254|  23.1k|  if (factor == 0) {
  ------------------
  |  Branch (254:7): [True: 0, False: 23.1k]
  ------------------
  255|      0|    Zero();
  256|      0|    return;
  257|      0|  }
  258|  23.1k|  if (used_bigits_ == 0) {
  ------------------
  |  Branch (258:7): [True: 0, False: 23.1k]
  ------------------
  259|      0|    return;
  260|      0|  }
  261|       |  // The product of a bigit with the factor is of size kBigitSize + 32.
  262|       |  // Assert that this number + 1 (for the carry) fits into double chunk.
  263|  23.1k|  DOUBLE_CONVERSION_ASSERT(kDoubleChunkSize >= kBigitSize + 32 + 1);
  ------------------
  |  |   47|  23.1k|    assert(condition)
  ------------------
  264|  23.1k|  DoubleChunk carry = 0;
  265|   522k|  for (int i = 0; i < used_bigits_; ++i) {
  ------------------
  |  Branch (265:19): [True: 499k, False: 23.1k]
  ------------------
  266|   499k|    const DoubleChunk product = static_cast<DoubleChunk>(factor) * RawBigit(i) + carry;
  267|   499k|    RawBigit(i) = static_cast<Chunk>(product & kBigitMask);
  268|   499k|    carry = (product >> kBigitSize);
  269|   499k|  }
  270|  40.5k|  while (carry != 0) {
  ------------------
  |  Branch (270:10): [True: 17.4k, False: 23.1k]
  ------------------
  271|  17.4k|    EnsureCapacity(used_bigits_ + 1);
  272|  17.4k|    RawBigit(used_bigits_) = carry & kBigitMask;
  273|  17.4k|    used_bigits_++;
  274|  17.4k|    carry >>= kBigitSize;
  275|  17.4k|  }
  276|  23.1k|}
_ZN22poco_double_conversion6Bignum16MultiplyByUInt64Em:
  279|  21.6k|void Bignum::MultiplyByUInt64(const uint64_t factor) {
  280|  21.6k|  if (factor == 1) {
  ------------------
  |  Branch (280:7): [True: 0, False: 21.6k]
  ------------------
  281|      0|    return;
  282|      0|  }
  283|  21.6k|  if (factor == 0) {
  ------------------
  |  Branch (283:7): [True: 0, False: 21.6k]
  ------------------
  284|      0|    Zero();
  285|      0|    return;
  286|      0|  }
  287|  21.6k|  if (used_bigits_ == 0) {
  ------------------
  |  Branch (287:7): [True: 0, False: 21.6k]
  ------------------
  288|      0|    return;
  289|      0|  }
  290|  21.6k|  DOUBLE_CONVERSION_ASSERT(kBigitSize < 32);
  ------------------
  |  |   47|  21.6k|    assert(condition)
  ------------------
  291|  21.6k|  uint64_t carry = 0;
  292|  21.6k|  const uint64_t low = factor & 0xFFFFFFFF;
  293|  21.6k|  const uint64_t high = factor >> 32;
  294|   290k|  for (int i = 0; i < used_bigits_; ++i) {
  ------------------
  |  Branch (294:19): [True: 268k, False: 21.6k]
  ------------------
  295|   268k|    const uint64_t product_low = low * RawBigit(i);
  296|   268k|    const uint64_t product_high = high * RawBigit(i);
  297|   268k|    const uint64_t tmp = (carry & kBigitMask) + product_low;
  298|   268k|    RawBigit(i) = tmp & kBigitMask;
  299|   268k|    carry = (carry >> kBigitSize) + (tmp >> kBigitSize) +
  300|   268k|        (product_high << (32 - kBigitSize));
  301|   268k|  }
  302|  70.0k|  while (carry != 0) {
  ------------------
  |  Branch (302:10): [True: 48.3k, False: 21.6k]
  ------------------
  303|  48.3k|    EnsureCapacity(used_bigits_ + 1);
  304|  48.3k|    RawBigit(used_bigits_) = carry & kBigitMask;
  305|  48.3k|    used_bigits_++;
  306|  48.3k|    carry >>= kBigitSize;
  307|  48.3k|  }
  308|  21.6k|}
_ZN22poco_double_conversion6Bignum20MultiplyByPowerOfTenEi:
  311|  20.5k|void Bignum::MultiplyByPowerOfTen(const int exponent) {
  312|  20.5k|  static const uint64_t kFive27 = DOUBLE_CONVERSION_UINT64_2PART_C(0x6765c793, fa10079d);
  ------------------
  |  |  195|  20.5k|#define DOUBLE_CONVERSION_UINT64_2PART_C(a, b) (((static_cast<uint64_t>(a) << 32) + 0x##b##u))
  ------------------
  313|  20.5k|  static const uint16_t kFive1 = 5;
  314|  20.5k|  static const uint16_t kFive2 = kFive1 * 5;
  315|  20.5k|  static const uint16_t kFive3 = kFive2 * 5;
  316|  20.5k|  static const uint16_t kFive4 = kFive3 * 5;
  317|  20.5k|  static const uint16_t kFive5 = kFive4 * 5;
  318|  20.5k|  static const uint16_t kFive6 = kFive5 * 5;
  319|  20.5k|  static const uint32_t kFive7 = kFive6 * 5;
  320|  20.5k|  static const uint32_t kFive8 = kFive7 * 5;
  321|  20.5k|  static const uint32_t kFive9 = kFive8 * 5;
  322|  20.5k|  static const uint32_t kFive10 = kFive9 * 5;
  323|  20.5k|  static const uint32_t kFive11 = kFive10 * 5;
  324|  20.5k|  static const uint32_t kFive12 = kFive11 * 5;
  325|  20.5k|  static const uint32_t kFive13 = kFive12 * 5;
  326|  20.5k|  static const uint32_t kFive1_to_12[] =
  327|  20.5k|      { kFive1, kFive2, kFive3, kFive4, kFive5, kFive6,
  328|  20.5k|        kFive7, kFive8, kFive9, kFive10, kFive11, kFive12 };
  329|       |
  330|  20.5k|  DOUBLE_CONVERSION_ASSERT(exponent >= 0);
  ------------------
  |  |   47|  20.5k|    assert(condition)
  ------------------
  331|       |
  332|  20.5k|  if (exponent == 0) {
  ------------------
  |  Branch (332:7): [True: 611, False: 19.9k]
  ------------------
  333|    611|    return;
  334|    611|  }
  335|  19.9k|  if (used_bigits_ == 0) {
  ------------------
  |  Branch (335:7): [True: 6.02k, False: 13.9k]
  ------------------
  336|  6.02k|    return;
  337|  6.02k|  }
  338|       |  // We shift by exponent at the end just before returning.
  339|  13.9k|  int remaining_exponent = exponent;
  340|  35.5k|  while (remaining_exponent >= 27) {
  ------------------
  |  Branch (340:10): [True: 21.6k, False: 13.9k]
  ------------------
  341|  21.6k|    MultiplyByUInt64(kFive27);
  342|  21.6k|    remaining_exponent -= 27;
  343|  21.6k|  }
  344|  24.2k|  while (remaining_exponent >= 13) {
  ------------------
  |  Branch (344:10): [True: 10.3k, False: 13.9k]
  ------------------
  345|  10.3k|    MultiplyByUInt32(kFive13);
  346|  10.3k|    remaining_exponent -= 13;
  347|  10.3k|  }
  348|  13.9k|  if (remaining_exponent > 0) {
  ------------------
  |  Branch (348:7): [True: 12.8k, False: 1.07k]
  ------------------
  349|  12.8k|    MultiplyByUInt32(kFive1_to_12[remaining_exponent - 1]);
  350|  12.8k|  }
  351|  13.9k|  ShiftLeft(exponent);
  352|  13.9k|}
_ZNK22poco_double_conversion6Bignum11BigitOrZeroEi:
  633|  36.7k|Bignum::Chunk Bignum::BigitOrZero(const int index) const {
  634|  36.7k|  if (index >= BigitLength()) {
  ------------------
  |  Branch (634:7): [True: 0, False: 36.7k]
  ------------------
  635|      0|    return 0;
  636|      0|  }
  637|  36.7k|  if (index < exponent_) {
  ------------------
  |  Branch (637:7): [True: 2.03k, False: 34.7k]
  ------------------
  638|  2.03k|    return 0;
  639|  2.03k|  }
  640|  34.7k|  return RawBigit(index - exponent_);
  641|  36.7k|}
_ZN22poco_double_conversion6Bignum7CompareERKS0_S2_:
  644|  6.02k|int Bignum::Compare(const Bignum& a, const Bignum& b) {
  645|  6.02k|  DOUBLE_CONVERSION_ASSERT(a.IsClamped());
  ------------------
  |  |   47|  6.02k|    assert(condition)
  ------------------
  646|  6.02k|  DOUBLE_CONVERSION_ASSERT(b.IsClamped());
  ------------------
  |  |   47|  6.02k|    assert(condition)
  ------------------
  647|  6.02k|  const int bigit_length_a = a.BigitLength();
  648|  6.02k|  const int bigit_length_b = b.BigitLength();
  649|  6.02k|  if (bigit_length_a < bigit_length_b) {
  ------------------
  |  Branch (649:7): [True: 195, False: 5.82k]
  ------------------
  650|    195|    return -1;
  651|    195|  }
  652|  5.82k|  if (bigit_length_a > bigit_length_b) {
  ------------------
  |  Branch (652:7): [True: 0, False: 5.82k]
  ------------------
  653|      0|    return +1;
  654|      0|  }
  655|  19.2k|  for (int i = bigit_length_a - 1; i >= (std::min)(a.exponent_, b.exponent_); --i) {
  ------------------
  |  Branch (655:36): [True: 18.3k, False: 860]
  ------------------
  656|  18.3k|    const Chunk bigit_a = a.BigitOrZero(i);
  657|  18.3k|    const Chunk bigit_b = b.BigitOrZero(i);
  658|  18.3k|    if (bigit_a < bigit_b) {
  ------------------
  |  Branch (658:9): [True: 1.66k, False: 16.7k]
  ------------------
  659|  1.66k|      return -1;
  660|  1.66k|    }
  661|  16.7k|    if (bigit_a > bigit_b) {
  ------------------
  |  Branch (661:9): [True: 3.30k, False: 13.4k]
  ------------------
  662|  3.30k|      return +1;
  663|  3.30k|    }
  664|       |    // Otherwise they are equal up to this digit. Try the next digit.
  665|  16.7k|  }
  666|    860|  return 0;
  667|  5.82k|}
_ZN22poco_double_conversion6Bignum5ClampEv:
  715|  6.02k|void Bignum::Clamp() {
  716|  6.02k|  while (used_bigits_ > 0 && RawBigit(used_bigits_ - 1) == 0) {
  ------------------
  |  Branch (716:10): [True: 6.02k, False: 0]
  |  Branch (716:30): [True: 0, False: 6.02k]
  ------------------
  717|      0|    used_bigits_--;
  718|      0|  }
  719|  6.02k|  if (used_bigits_ == 0) {
  ------------------
  |  Branch (719:7): [True: 0, False: 6.02k]
  ------------------
  720|       |    // Zero.
  721|      0|    exponent_ = 0;
  722|      0|  }
  723|  6.02k|}
_ZN22poco_double_conversion6Bignum5AlignERKS0_:
  726|  11.6k|void Bignum::Align(const Bignum& other) {
  727|  11.6k|  if (exponent_ > other.exponent_) {
  ------------------
  |  Branch (727:7): [True: 0, False: 11.6k]
  ------------------
  728|       |    // If "X" represents a "hidden" bigit (by the exponent) then we are in the
  729|       |    // following case (a == this, b == other):
  730|       |    // a:  aaaaaaXXXX   or a:   aaaaaXXX
  731|       |    // b:     bbbbbbX      b: bbbbbbbbXX
  732|       |    // We replace some of the hidden digits (X) of a with 0 digits.
  733|       |    // a:  aaaaaa000X   or a:   aaaaa0XX
  734|      0|    const int zero_bigits = exponent_ - other.exponent_;
  735|      0|    EnsureCapacity(used_bigits_ + zero_bigits);
  736|      0|    for (int i = used_bigits_ - 1; i >= 0; --i) {
  ------------------
  |  Branch (736:36): [True: 0, False: 0]
  ------------------
  737|      0|      RawBigit(i + zero_bigits) = RawBigit(i);
  738|      0|    }
  739|      0|    for (int i = 0; i < zero_bigits; ++i) {
  ------------------
  |  Branch (739:21): [True: 0, False: 0]
  ------------------
  740|      0|      RawBigit(i) = 0;
  741|      0|    }
  742|      0|    used_bigits_ += static_cast<int16_t>(zero_bigits);
  743|      0|    exponent_ -= static_cast<int16_t>(zero_bigits);
  744|       |
  745|      0|    DOUBLE_CONVERSION_ASSERT(used_bigits_ >= 0);
  ------------------
  |  |   47|      0|    assert(condition)
  ------------------
  746|      0|    DOUBLE_CONVERSION_ASSERT(exponent_ >= 0);
  ------------------
  |  |   47|      0|    assert(condition)
  ------------------
  747|      0|  }
  748|  11.6k|}
_ZN22poco_double_conversion6Bignum15BigitsShiftLeftEi:
  751|  19.9k|void Bignum::BigitsShiftLeft(const int shift_amount) {
  752|  19.9k|  DOUBLE_CONVERSION_ASSERT(shift_amount < kBigitSize);
  ------------------
  |  |   47|  19.9k|    assert(condition)
  ------------------
  753|  19.9k|  DOUBLE_CONVERSION_ASSERT(shift_amount >= 0);
  ------------------
  |  |   47|  19.9k|    assert(condition)
  ------------------
  754|  19.9k|  Chunk carry = 0;
  755|   327k|  for (int i = 0; i < used_bigits_; ++i) {
  ------------------
  |  Branch (755:19): [True: 307k, False: 19.9k]
  ------------------
  756|   307k|    const Chunk new_carry = RawBigit(i) >> (kBigitSize - shift_amount);
  757|   307k|    RawBigit(i) = ((RawBigit(i) << shift_amount) + carry) & kBigitMask;
  758|   307k|    carry = new_carry;
  759|   307k|  }
  760|  19.9k|  if (carry != 0) {
  ------------------
  |  Branch (760:7): [True: 10.6k, False: 9.24k]
  ------------------
  761|  10.6k|    RawBigit(used_bigits_) = carry;
  762|  10.6k|    used_bigits_++;
  763|  10.6k|  }
  764|  19.9k|}
NumericString.cpp:_ZN22poco_double_conversionL10ReadUInt64ENS_6VectorIKcEEii:
   86|  14.5k|                           const int digits_to_read) {
   87|  14.5k|  uint64_t result = 0;
   88|   211k|  for (int i = from; i < from + digits_to_read; ++i) {
  ------------------
  |  Branch (88:22): [True: 196k, False: 14.5k]
  ------------------
   89|   196k|    const int digit = buffer[i] - '0';
   90|   196k|    DOUBLE_CONVERSION_ASSERT(0 <= digit && digit <= 9);
  ------------------
  |  |   47|   196k|    assert(condition)
  ------------------
   91|   196k|    result = result * 10 + digit;
   92|   196k|  }
   93|  14.5k|  return result;
   94|  14.5k|}

_ZN22poco_double_conversion6BignumC2Ev:
   42|  23.7k|  Bignum() : used_bigits_(0), exponent_(0) {}
_ZN22poco_double_conversion6Bignum4ZeroEv:
  124|  23.7k|  void Zero() {
  125|  23.7k|    used_bigits_ = 0;
  126|  23.7k|    exponent_ = 0;
  127|  23.7k|  }
_ZN22poco_double_conversion6Bignum14EnsureCapacityEi:
  114|  97.4k|  static void EnsureCapacity(const int size) {
  115|  97.4k|    if (size > kBigitCapacity) {
  ------------------
  |  Branch (115:9): [True: 0, False: 97.4k]
  ------------------
  116|      0|      DOUBLE_CONVERSION_UNREACHABLE();
  ------------------
  |  |   77|      0|#define DOUBLE_CONVERSION_UNREACHABLE()   (abort())
  ------------------
  117|      0|    }
  118|  97.4k|  }
_ZNK22poco_double_conversion6Bignum11BigitLengthEv:
  133|  72.2k|  int BigitLength() const { return used_bigits_ + exponent_; }

_ZN22poco_double_conversion16PowersOfTenCache32GetCachedPowerForDecimalExponentEiPNS_5DiyFpEPi:
  161|  9.21k|                                      int* found_exponent) {
  162|  9.21k|  DOUBLE_CONVERSION_ASSERT(kMinDecimalExponent <= requested_exponent);
  ------------------
  |  |   47|  9.21k|    assert(condition)
  ------------------
  163|  9.21k|  DOUBLE_CONVERSION_ASSERT(requested_exponent < kMaxDecimalExponent + kDecimalExponentDistance);
  ------------------
  |  |   47|  9.21k|    assert(condition)
  ------------------
  164|  9.21k|  int index =
  165|  9.21k|      (requested_exponent + kCachedPowersOffset) / kDecimalExponentDistance;
  166|  9.21k|  CachedPower cached_power = kCachedPowers[index];
  167|  9.21k|  *power = DiyFp(cached_power.significand, cached_power.binary_exponent);
  168|  9.21k|  *found_exponent = cached_power.decimal_exponent;
  169|  9.21k|  DOUBLE_CONVERSION_ASSERT(*found_exponent <= requested_exponent);
  ------------------
  |  |   47|  9.21k|    assert(condition)
  ------------------
  170|  9.21k|  DOUBLE_CONVERSION_ASSERT(requested_exponent < *found_exponent + kDecimalExponentDistance);
  ------------------
  |  |   47|  9.21k|    assert(condition)
  ------------------
  171|  9.21k|}

_ZN22poco_double_conversion5DiyFpC2Emi:
   46|  41.9k|  DiyFp(const uint64_t significand, const int32_t exponent) : f_(significand), e_(exponent) {}
_ZN22poco_double_conversion5DiyFp9NormalizeEv:
   96|  18.4k|  void Normalize() {
   97|  18.4k|    DOUBLE_CONVERSION_ASSERT(f_ != 0);
  ------------------
  |  |   47|  18.4k|    assert(condition)
  ------------------
   98|  18.4k|    uint64_t significand = f_;
   99|  18.4k|    int32_t exponent = e_;
  100|       |
  101|       |    // This method is mainly called for normalizing boundaries. In general,
  102|       |    // boundaries need to be shifted by 10 bits, and we optimize for this case.
  103|  18.4k|    const uint64_t k10MSBits = DOUBLE_CONVERSION_UINT64_2PART_C(0xFFC00000, 00000000);
  ------------------
  |  |  195|  18.4k|#define DOUBLE_CONVERSION_UINT64_2PART_C(a, b) (((static_cast<uint64_t>(a) << 32) + 0x##b##u))
  ------------------
  104|  45.8k|    while ((significand & k10MSBits) == 0) {
  ------------------
  |  Branch (104:12): [True: 27.4k, False: 18.4k]
  ------------------
  105|  27.4k|      significand <<= 10;
  106|  27.4k|      exponent -= 10;
  107|  27.4k|    }
  108|  57.8k|    while ((significand & kUint64MSB) == 0) {
  ------------------
  |  Branch (108:12): [True: 39.4k, False: 18.4k]
  ------------------
  109|  39.4k|      significand <<= 1;
  110|  39.4k|      exponent--;
  111|  39.4k|    }
  112|  18.4k|    f_ = significand;
  113|  18.4k|    e_ = exponent;
  114|  18.4k|  }
_ZNK22poco_double_conversion5DiyFp1fEv:
  122|  36.0k|  uint64_t f() const { return f_; }
_ZN22poco_double_conversion5DiyFp5set_fEm:
  125|  2.39k|  void set_f(uint64_t new_value) { f_ = new_value; }
_ZN22poco_double_conversion5DiyFp5set_eEi:
  126|    658|  void set_e(int32_t new_value) { e_ = new_value; }
_ZNK22poco_double_conversion5DiyFp1eEv:
  123|  77.1k|  int32_t e() const { return e_; }
_ZN22poco_double_conversion5DiyFp8MultiplyERKS0_:
   68|  17.5k|  void Multiply(const DiyFp& other) {
   69|       |    // Simply "emulates" a 128 bit multiplication.
   70|       |    // However: the resulting number only contains 64 bits. The least
   71|       |    // significant 64 bits are only used for rounding the most significant 64
   72|       |    // bits.
   73|  17.5k|    const uint64_t kM32 = 0xFFFFFFFFU;
   74|  17.5k|    const uint64_t a = f_ >> 32;
   75|  17.5k|    const uint64_t b = f_ & kM32;
   76|  17.5k|    const uint64_t c = other.f_ >> 32;
   77|  17.5k|    const uint64_t d = other.f_ & kM32;
   78|  17.5k|    const uint64_t ac = a * c;
   79|  17.5k|    const uint64_t bc = b * c;
   80|  17.5k|    const uint64_t ad = a * d;
   81|  17.5k|    const uint64_t bd = b * d;
   82|       |    // By adding 1U << 31 to tmp we round the final result.
   83|       |    // Halfway cases will be rounded up.
   84|  17.5k|    const uint64_t tmp = (bd >> 32) + (ad & kM32) + (bc & kM32) + (1U << 31);
   85|  17.5k|    e_ += other.e_ + 64;
   86|  17.5k|    f_ = ac + (ad >> 32) + (bc >> 32) + (tmp >> 32);
   87|  17.5k|  }
_ZN22poco_double_conversion5DiyFpC2Ev:
   45|  18.4k|  DiyFp() : f_(0), e_(0) {}

_ZN22poco_double_conversion6DoubleC2Ed:
   55|  10.5k|  explicit Double(double d) : d64_(double_to_uint64(d)) {}
NumericString.cpp:_ZN22poco_double_conversionL16double_to_uint64Ed:
   36|  10.5k|static uint64_t double_to_uint64(double d) { return BitCast<uint64_t>(d); }
_ZNK22poco_double_conversion6Double11SignificandEv:
  123|  6.88k|  uint64_t Significand() const {
  124|  6.88k|    uint64_t d64 = AsUint64();
  125|  6.88k|    uint64_t significand = d64 & kSignificandMask;
  126|  6.88k|    if (!IsDenormal()) {
  ------------------
  |  Branch (126:9): [True: 6.46k, False: 416]
  ------------------
  127|  6.46k|      return significand + kHiddenBit;
  128|  6.46k|    } else {
  129|    416|      return significand;
  130|    416|    }
  131|  6.88k|  }
_ZNK22poco_double_conversion6Double8AsUint64Ev:
   86|  32.6k|  uint64_t AsUint64() const {
   87|  32.6k|    return d64_;
   88|  32.6k|  }
_ZNK22poco_double_conversion6Double10IsDenormalEv:
  134|  12.9k|  bool IsDenormal() const {
  135|  12.9k|    uint64_t d64 = AsUint64();
  136|  12.9k|    return (d64 & kExponentMask) == 0;
  137|  12.9k|  }
_ZNK22poco_double_conversion6Double8ExponentEv:
  114|  6.02k|  int Exponent() const {
  115|  6.02k|    if (IsDenormal()) return kDenormalExponent;
  ------------------
  |  Branch (115:9): [True: 416, False: 5.60k]
  ------------------
  116|       |
  117|  5.60k|    uint64_t d64 = AsUint64();
  118|  5.60k|    int biased_e =
  119|  5.60k|        static_cast<int>((d64 & kExponentMask) >> kPhysicalSignificandSize);
  120|  5.60k|    return biased_e - kExponentBias;
  121|  6.02k|  }
_ZN22poco_double_conversion6Double8InfinityEv:
  236|  6.21k|  static double Infinity() {
  237|  6.21k|    return Double(kInfinity).value();
  238|  6.21k|  }
_ZN22poco_double_conversion6DoubleC2Em:
   56|  23.5k|  explicit Double(uint64_t d64) : d64_(d64) {}
_ZNK22poco_double_conversion6Double5valueEv:
  220|  32.7k|  double value() const { return uint64_to_double(d64_); }
NumericString.cpp:_ZN22poco_double_conversionL16uint64_to_doubleEm:
   37|  32.7k|static double uint64_to_double(uint64_t d64) { return BitCast<double>(d64); }
_ZN22poco_double_conversion6Double34SignificandSizeForOrderOfMagnitudeEi:
  228|  9.21k|  static int SignificandSizeForOrderOfMagnitude(int order) {
  229|  9.21k|    if (order >= (kDenormalExponent + kSignificandSize)) {
  ------------------
  |  Branch (229:9): [True: 8.04k, False: 1.16k]
  ------------------
  230|  8.04k|      return kSignificandSize;
  231|  8.04k|    }
  232|  1.16k|    if (order <= kDenormalExponent) return 0;
  ------------------
  |  Branch (232:9): [True: 426, False: 738]
  ------------------
  233|    738|    return order - kDenormalExponent;
  234|  1.16k|  }
_ZN22poco_double_conversion6DoubleC2ENS_5DiyFpE:
   58|  9.21k|    : d64_(DiyFpToUint64(diy_fp)) {}
_ZN22poco_double_conversion6Double13DiyFpToUint64ENS_5DiyFpE:
  256|  9.21k|  static uint64_t DiyFpToUint64(DiyFp diy_fp) {
  257|  9.21k|    uint64_t significand = diy_fp.f();
  258|  9.21k|    int exponent = diy_fp.e();
  259|  9.40k|    while (significand > kHiddenBit + kSignificandMask) {
  ------------------
  |  Branch (259:12): [True: 199, False: 9.21k]
  ------------------
  260|    199|      significand >>= 1;
  261|    199|      exponent++;
  262|    199|    }
  263|  9.21k|    if (exponent >= kMaxExponent) {
  ------------------
  |  Branch (263:9): [True: 3, False: 9.20k]
  ------------------
  264|      3|      return kInfinity;
  265|      3|    }
  266|  9.20k|    if (exponent < kDenormalExponent) {
  ------------------
  |  Branch (266:9): [True: 417, False: 8.79k]
  ------------------
  267|    417|      return 0;
  268|    417|    }
  269|  8.79k|    while (exponent > kDenormalExponent && (significand & kHiddenBit) == 0) {
  ------------------
  |  Branch (269:12): [True: 7.84k, False: 941]
  |  Branch (269:44): [True: 0, False: 7.84k]
  ------------------
  270|      0|      significand <<= 1;
  271|      0|      exponent--;
  272|      0|    }
  273|  8.79k|    uint64_t biased_exponent;
  274|  8.79k|    if (exponent == kDenormalExponent && (significand & kHiddenBit) == 0) {
  ------------------
  |  Branch (274:9): [True: 941, False: 7.84k]
  |  Branch (274:42): [True: 747, False: 194]
  ------------------
  275|    747|      biased_exponent = 0;
  276|  8.04k|    } else {
  277|  8.04k|      biased_exponent = static_cast<uint64_t>(exponent + kExponentBias);
  278|  8.04k|    }
  279|  8.79k|    return (significand & kSignificandMask) |
  280|  8.79k|        (biased_exponent << kPhysicalSignificandSize);
  281|  9.20k|  }
_ZNK22poco_double_conversion6Double13UpperBoundaryEv:
  182|  6.02k|  DiyFp UpperBoundary() const {
  183|  6.02k|    DOUBLE_CONVERSION_ASSERT(Sign() > 0);
  ------------------
  |  |   47|  6.02k|    assert(condition)
  ------------------
  184|  6.02k|    return DiyFp(Significand() * 2 + 1, Exponent() - 1);
  185|  6.02k|  }
_ZNK22poco_double_conversion6Double10NextDoubleEv:
   91|  3.65k|  double NextDouble() const {
   92|  3.65k|    if (d64_ == kInfinity) return Double(kInfinity).value();
  ------------------
  |  Branch (92:9): [True: 0, False: 3.65k]
  ------------------
   93|  3.65k|    if (Sign() < 0 && Significand() == 0) {
  ------------------
  |  Branch (93:9): [True: 0, False: 3.65k]
  |  Branch (93:23): [True: 0, False: 0]
  ------------------
   94|       |      // -0.0
   95|      0|      return 0.0;
   96|      0|    }
   97|  3.65k|    if (Sign() < 0) {
  ------------------
  |  Branch (97:9): [True: 0, False: 3.65k]
  ------------------
   98|      0|      return Double(d64_ - 1).value();
   99|  3.65k|    } else {
  100|  3.65k|      return Double(d64_ + 1).value();
  101|  3.65k|    }
  102|  3.65k|  }
_ZNK22poco_double_conversion6Double4SignEv:
  175|  7.31k|  int Sign() const {
  176|  7.31k|    uint64_t d64 = AsUint64();
  177|  7.31k|    return (d64 & kSignMask) == 0? 1: -1;
  ------------------
  |  Branch (177:12): [True: 7.31k, False: 0]
  ------------------
  178|  7.31k|  }
_ZN22poco_double_conversion6Double3NaNEv:
  240|  13.6k|  static double NaN() {
  241|  13.6k|    return Double(kNaN).value();
  242|  13.6k|  }

_ZNK22poco_double_conversion23StringToDoubleConverter14StringToDoubleEPKciPi:
  752|  13.6k|    int* processed_characters_count) const {
  753|  13.6k|  return StringToIeee(buffer, length, true, processed_characters_count);
  754|  13.6k|}
_ZNK22poco_double_conversion23StringToDoubleConverter12StringToIeeeIPKcEEdT_ibPi:
  423|  13.6k|    int* processed_characters_count) const {
  424|  13.6k|  Iterator current = input;
  425|  13.6k|  Iterator end = input + length;
  426|       |
  427|  13.6k|  *processed_characters_count = 0;
  428|       |
  429|  13.6k|  const bool allow_trailing_junk = (flags_ & ALLOW_TRAILING_JUNK) != 0;
  430|  13.6k|  const bool allow_leading_spaces = (flags_ & ALLOW_LEADING_SPACES) != 0;
  431|  13.6k|  const bool allow_trailing_spaces = (flags_ & ALLOW_TRAILING_SPACES) != 0;
  432|  13.6k|  const bool allow_spaces_after_sign = (flags_ & ALLOW_SPACES_AFTER_SIGN) != 0;
  433|  13.6k|  const bool allow_case_insensitivity = (flags_ & ALLOW_CASE_INSENSITIVITY) != 0;
  434|       |
  435|       |  // To make sure that iterator dereferencing is valid the following
  436|       |  // convention is used:
  437|       |  // 1. Each '++current' statement is followed by check for equality to 'end'.
  438|       |  // 2. If AdvanceToNonspace returned false then current == end.
  439|       |  // 3. If 'current' becomes equal to 'end' the function returns or goes to
  440|       |  // 'parsing_done'.
  441|       |  // 4. 'current' is not dereferenced after the 'parsing_done' label.
  442|       |  // 5. Code before 'parsing_done' may rely on 'current != end'.
  443|  13.6k|  if (current == end) return empty_string_value_;
  ------------------
  |  Branch (443:7): [True: 0, False: 13.6k]
  ------------------
  444|       |
  445|  13.6k|  if (allow_leading_spaces || allow_trailing_spaces) {
  ------------------
  |  Branch (445:7): [True: 13.6k, False: 0]
  |  Branch (445:31): [True: 0, False: 0]
  ------------------
  446|  13.6k|    if (!AdvanceToNonspace(&current, end)) {
  ------------------
  |  Branch (446:9): [True: 0, False: 13.6k]
  ------------------
  447|      0|      *processed_characters_count = static_cast<int>(current - input);
  448|      0|      return empty_string_value_;
  449|      0|    }
  450|  13.6k|    if (!allow_leading_spaces && (input != current)) {
  ------------------
  |  Branch (450:9): [True: 0, False: 13.6k]
  |  Branch (450:34): [True: 0, False: 0]
  ------------------
  451|       |      // No leading spaces allowed, but AdvanceToNonspace moved forward.
  452|      0|      return junk_string_value_;
  453|      0|    }
  454|  13.6k|  }
  455|       |
  456|       |  // Exponent will be adjusted if insignificant digits of the integer part
  457|       |  // or insignificant leading zeros of the fractional part are dropped.
  458|  13.6k|  int exponent = 0;
  459|  13.6k|  int significant_digits = 0;
  460|  13.6k|  int insignificant_digits = 0;
  461|  13.6k|  bool nonzero_digit_dropped = false;
  462|       |
  463|  13.6k|  bool sign = false;
  464|       |
  465|  13.6k|  if (*current == '+' || *current == '-') {
  ------------------
  |  Branch (465:7): [True: 0, False: 13.6k]
  |  Branch (465:26): [True: 281, False: 13.4k]
  ------------------
  466|    281|    sign = (*current == '-');
  467|    281|    ++current;
  468|    281|    Iterator next_non_space = current;
  469|       |    // Skip following spaces (if allowed).
  470|    281|    if (!AdvanceToNonspace(&next_non_space, end)) return junk_string_value_;
  ------------------
  |  Branch (470:9): [True: 0, False: 281]
  ------------------
  471|    281|    if (!allow_spaces_after_sign && (current != next_non_space)) {
  ------------------
  |  Branch (471:9): [True: 281, False: 0]
  |  Branch (471:37): [True: 0, False: 281]
  ------------------
  472|      0|      return junk_string_value_;
  473|      0|    }
  474|    281|    current = next_non_space;
  475|    281|  }
  476|       |
  477|  13.6k|  if (infinity_symbol_ != DOUBLE_CONVERSION_NULLPTR) {
  ------------------
  |  |   39|  13.6k|#define DOUBLE_CONVERSION_NULLPTR nullptr
  ------------------
  |  Branch (477:7): [True: 13.6k, False: 0]
  ------------------
  478|  13.6k|    if (ConsumeFirstCharacter(*current, infinity_symbol_, allow_case_insensitivity)) {
  ------------------
  |  Branch (478:9): [True: 0, False: 13.6k]
  ------------------
  479|      0|      if (!ConsumeSubString(&current, end, infinity_symbol_, allow_case_insensitivity)) {
  ------------------
  |  Branch (479:11): [True: 0, False: 0]
  ------------------
  480|      0|        return junk_string_value_;
  481|      0|      }
  482|       |
  483|      0|      if (!(allow_trailing_spaces || allow_trailing_junk) && (current != end)) {
  ------------------
  |  Branch (483:13): [True: 0, False: 0]
  |  Branch (483:38): [True: 0, False: 0]
  |  Branch (483:62): [True: 0, False: 0]
  ------------------
  484|      0|        return junk_string_value_;
  485|      0|      }
  486|      0|      if (!allow_trailing_junk && AdvanceToNonspace(&current, end)) {
  ------------------
  |  Branch (486:11): [True: 0, False: 0]
  |  Branch (486:35): [True: 0, False: 0]
  ------------------
  487|      0|        return junk_string_value_;
  488|      0|      }
  489|       |
  490|      0|      *processed_characters_count = static_cast<int>(current - input);
  491|      0|      return sign ? -Double::Infinity() : Double::Infinity();
  ------------------
  |  Branch (491:14): [True: 0, False: 0]
  ------------------
  492|      0|    }
  493|  13.6k|  }
  494|       |
  495|  13.6k|  if (nan_symbol_ != DOUBLE_CONVERSION_NULLPTR) {
  ------------------
  |  |   39|  13.6k|#define DOUBLE_CONVERSION_NULLPTR nullptr
  ------------------
  |  Branch (495:7): [True: 13.6k, False: 0]
  ------------------
  496|  13.6k|    if (ConsumeFirstCharacter(*current, nan_symbol_, allow_case_insensitivity)) {
  ------------------
  |  Branch (496:9): [True: 0, False: 13.6k]
  ------------------
  497|      0|      if (!ConsumeSubString(&current, end, nan_symbol_, allow_case_insensitivity)) {
  ------------------
  |  Branch (497:11): [True: 0, False: 0]
  ------------------
  498|      0|        return junk_string_value_;
  499|      0|      }
  500|       |
  501|      0|      if (!(allow_trailing_spaces || allow_trailing_junk) && (current != end)) {
  ------------------
  |  Branch (501:13): [True: 0, False: 0]
  |  Branch (501:38): [True: 0, False: 0]
  |  Branch (501:62): [True: 0, False: 0]
  ------------------
  502|      0|        return junk_string_value_;
  503|      0|      }
  504|      0|      if (!allow_trailing_junk && AdvanceToNonspace(&current, end)) {
  ------------------
  |  Branch (504:11): [True: 0, False: 0]
  |  Branch (504:35): [True: 0, False: 0]
  ------------------
  505|      0|        return junk_string_value_;
  506|      0|      }
  507|       |
  508|      0|      *processed_characters_count = static_cast<int>(current - input);
  509|      0|      return sign ? -Double::NaN() : Double::NaN();
  ------------------
  |  Branch (509:14): [True: 0, False: 0]
  ------------------
  510|      0|    }
  511|  13.6k|  }
  512|       |
  513|  13.6k|  bool leading_zero = false;
  514|  13.6k|  if (*current == '0') {
  ------------------
  |  Branch (514:7): [True: 1.60k, False: 12.0k]
  ------------------
  515|  1.60k|    if (Advance(&current, separator_, 10, end)) {
  ------------------
  |  Branch (515:9): [True: 0, False: 1.60k]
  ------------------
  516|      0|      *processed_characters_count = static_cast<int>(current - input);
  517|      0|      return SignedZero(sign);
  518|      0|    }
  519|       |
  520|  1.60k|    leading_zero = true;
  521|       |
  522|       |    // It could be hexadecimal value.
  523|  1.60k|    if (((flags_ & ALLOW_HEX) || (flags_ & ALLOW_HEX_FLOATS)) &&
  ------------------
  |  Branch (523:10): [True: 0, False: 1.60k]
  |  Branch (523:34): [True: 0, False: 1.60k]
  ------------------
  524|  1.60k|        (*current == 'x' || *current == 'X')) {
  ------------------
  |  Branch (524:10): [True: 0, False: 0]
  |  Branch (524:29): [True: 0, False: 0]
  ------------------
  525|      0|      ++current;
  526|       |
  527|      0|      if (current == end) return junk_string_value_;  // "0x"
  ------------------
  |  Branch (527:11): [True: 0, False: 0]
  ------------------
  528|       |
  529|      0|      bool parse_as_hex_float = (flags_ & ALLOW_HEX_FLOATS) &&
  ------------------
  |  Branch (529:33): [True: 0, False: 0]
  ------------------
  530|      0|                IsHexFloatString(current, end, separator_, allow_trailing_junk);
  ------------------
  |  Branch (530:17): [True: 0, False: 0]
  ------------------
  531|       |
  532|      0|      if (!parse_as_hex_float && !isDigit(*current, 16)) {
  ------------------
  |  Branch (532:11): [True: 0, False: 0]
  |  Branch (532:34): [True: 0, False: 0]
  ------------------
  533|      0|        return junk_string_value_;
  534|      0|      }
  535|       |
  536|      0|      bool result_is_junk;
  537|      0|      double result = RadixStringToIeee<4>(&current,
  538|      0|                                           end,
  539|      0|                                           sign,
  540|      0|                                           separator_,
  541|      0|                                           parse_as_hex_float,
  542|      0|                                           allow_trailing_junk,
  543|      0|                                           junk_string_value_,
  544|      0|                                           read_as_double,
  545|      0|                                           &result_is_junk);
  546|      0|      if (!result_is_junk) {
  ------------------
  |  Branch (546:11): [True: 0, False: 0]
  ------------------
  547|      0|        if (allow_trailing_spaces) AdvanceToNonspace(&current, end);
  ------------------
  |  Branch (547:13): [True: 0, False: 0]
  ------------------
  548|      0|        *processed_characters_count = static_cast<int>(current - input);
  549|      0|      }
  550|      0|      return result;
  551|      0|    }
  552|       |
  553|       |    // Ignore leading zeros in the integer part.
  554|  1.60k|    while (*current == '0') {
  ------------------
  |  Branch (554:12): [True: 0, False: 1.60k]
  ------------------
  555|      0|      if (Advance(&current, separator_, 10, end)) {
  ------------------
  |  Branch (555:11): [True: 0, False: 0]
  ------------------
  556|      0|        *processed_characters_count = static_cast<int>(current - input);
  557|      0|        return SignedZero(sign);
  558|      0|      }
  559|      0|    }
  560|  1.60k|  }
  561|       |
  562|  13.6k|  bool octal = leading_zero && (flags_ & ALLOW_OCTALS) != 0;
  ------------------
  |  Branch (562:16): [True: 1.60k, False: 12.0k]
  |  Branch (562:32): [True: 0, False: 1.60k]
  ------------------
  563|       |
  564|       |  // The longest form of simplified number is: "-<significant digits>.1eXXX\0".
  565|  13.6k|  const int kBufferSize = kMaxSignificantDigits + 10;
  566|  13.6k|  DOUBLE_CONVERSION_STACK_UNINITIALIZED char
  ------------------
  |  |  104|  13.6k|#define DOUBLE_CONVERSION_STACK_UNINITIALIZED __attribute__((uninitialized))
  ------------------
  567|  13.6k|      buffer[kBufferSize];  // NOLINT: size is known at compile time.
  568|  13.6k|  int buffer_pos = 0;
  569|       |
  570|       |  // Copy significant digits of the integer part (if any) to the buffer.
  571|  10.0M|  while (*current >= '0' && *current <= '9') {
  ------------------
  |  Branch (571:10): [True: 10.0M, False: 6.11k]
  |  Branch (571:29): [True: 10.0M, False: 7.58k]
  ------------------
  572|  10.0M|    if (significant_digits < kMaxSignificantDigits) {
  ------------------
  |  Branch (572:9): [True: 346k, False: 9.69M]
  ------------------
  573|   346k|      DOUBLE_CONVERSION_ASSERT(buffer_pos < kBufferSize);
  ------------------
  |  |   47|   346k|    assert(condition)
  ------------------
  574|   346k|      buffer[buffer_pos++] = static_cast<char>(*current);
  575|   346k|      significant_digits++;
  576|       |      // Will later check if it's an octal in the buffer.
  577|  9.69M|    } else {
  578|  9.69M|      insignificant_digits++;  // Move the digit into the exponential part.
  579|  9.69M|      nonzero_digit_dropped = nonzero_digit_dropped || *current != '0';
  ------------------
  |  Branch (579:31): [True: 9.33M, False: 363k]
  |  Branch (579:56): [True: 177, False: 363k]
  ------------------
  580|  9.69M|    }
  581|  10.0M|    octal = octal && *current < '8';
  ------------------
  |  Branch (581:13): [True: 0, False: 10.0M]
  |  Branch (581:22): [True: 0, False: 0]
  ------------------
  582|  10.0M|    if (Advance(&current, separator_, 10, end)) goto parsing_done;
  ------------------
  |  Branch (582:9): [True: 0, False: 10.0M]
  ------------------
  583|  10.0M|  }
  584|       |
  585|  13.6k|  if (significant_digits == 0) {
  ------------------
  |  Branch (585:7): [True: 1.60k, False: 12.0k]
  ------------------
  586|  1.60k|    octal = false;
  587|  1.60k|  }
  588|       |
  589|  13.6k|  if (*current == '.') {
  ------------------
  |  Branch (589:7): [True: 6.11k, False: 7.58k]
  ------------------
  590|  6.11k|    if (octal && !allow_trailing_junk) return junk_string_value_;
  ------------------
  |  Branch (590:9): [True: 0, False: 6.11k]
  |  Branch (590:18): [True: 0, False: 0]
  ------------------
  591|  6.11k|    if (octal) goto parsing_done;
  ------------------
  |  Branch (591:9): [True: 0, False: 6.11k]
  ------------------
  592|       |
  593|  6.11k|    if (Advance(&current, separator_, 10, end)) {
  ------------------
  |  Branch (593:9): [True: 0, False: 6.11k]
  ------------------
  594|      0|      if (significant_digits == 0 && !leading_zero) {
  ------------------
  |  Branch (594:11): [True: 0, False: 0]
  |  Branch (594:38): [True: 0, False: 0]
  ------------------
  595|      0|        return junk_string_value_;
  596|      0|      } else {
  597|      0|        goto parsing_done;
  598|      0|      }
  599|      0|    }
  600|       |
  601|  6.11k|    if (significant_digits == 0) {
  ------------------
  |  Branch (601:9): [True: 954, False: 5.16k]
  ------------------
  602|       |      // octal = false;
  603|       |      // Integer part consists of 0 or is absent. Significant digits start after
  604|       |      // leading zeros (if any).
  605|  2.01k|      while (*current == '0') {
  ------------------
  |  Branch (605:14): [True: 1.31k, False: 703]
  ------------------
  606|  1.31k|        if (Advance(&current, separator_, 10, end)) {
  ------------------
  |  Branch (606:13): [True: 251, False: 1.06k]
  ------------------
  607|    251|          *processed_characters_count = static_cast<int>(current - input);
  608|    251|          return SignedZero(sign);
  609|    251|        }
  610|  1.06k|        exponent--;  // Move this 0 into the exponent.
  611|  1.06k|      }
  612|    954|    }
  613|       |
  614|       |    // There is a fractional part.
  615|       |    // We don't emit a '.', but adjust the exponent instead.
  616|  1.09M|    while (*current >= '0' && *current <= '9') {
  ------------------
  |  Branch (616:12): [True: 1.09M, False: 0]
  |  Branch (616:31): [True: 1.09M, False: 900]
  ------------------
  617|  1.09M|      if (significant_digits < kMaxSignificantDigits) {
  ------------------
  |  Branch (617:11): [True: 177k, False: 913k]
  ------------------
  618|   177k|        DOUBLE_CONVERSION_ASSERT(buffer_pos < kBufferSize);
  ------------------
  |  |   47|   177k|    assert(condition)
  ------------------
  619|   177k|        buffer[buffer_pos++] = static_cast<char>(*current);
  620|   177k|        significant_digits++;
  621|   177k|        exponent--;
  622|   913k|      } else {
  623|       |        // Ignore insignificant digits in the fractional part.
  624|   913k|        nonzero_digit_dropped = nonzero_digit_dropped || *current != '0';
  ------------------
  |  Branch (624:33): [True: 897k, False: 15.5k]
  |  Branch (624:58): [True: 185, False: 15.3k]
  ------------------
  625|   913k|      }
  626|  1.09M|      if (Advance(&current, separator_, 10, end)) goto parsing_done;
  ------------------
  |  Branch (626:11): [True: 4.96k, False: 1.08M]
  ------------------
  627|  1.09M|    }
  628|  5.86k|  }
  629|       |
  630|  8.48k|  if (!leading_zero && exponent == 0 && significant_digits == 0) {
  ------------------
  |  Branch (630:7): [True: 7.64k, False: 841]
  |  Branch (630:24): [True: 7.19k, False: 450]
  |  Branch (630:41): [True: 0, False: 7.19k]
  ------------------
  631|       |    // If leading_zeros is true then the string contains zeros.
  632|       |    // If exponent < 0 then string was [+-]\.0*...
  633|       |    // If significant_digits != 0 the string is not equal to 0.
  634|       |    // Otherwise there are no digits in the string.
  635|      0|    return junk_string_value_;
  636|      0|  }
  637|       |
  638|       |  // Parse exponential part.
  639|  8.48k|  if (*current == 'e' || *current == 'E') {
  ------------------
  |  Branch (639:7): [True: 4.81k, False: 3.66k]
  |  Branch (639:26): [True: 3.66k, False: 0]
  ------------------
  640|  8.48k|    if (octal && !allow_trailing_junk) return junk_string_value_;
  ------------------
  |  Branch (640:9): [True: 0, False: 8.48k]
  |  Branch (640:18): [True: 0, False: 0]
  ------------------
  641|  8.48k|    if (octal) goto parsing_done;
  ------------------
  |  Branch (641:9): [True: 0, False: 8.48k]
  ------------------
  642|  8.48k|    Iterator junk_begin = current;
  643|  8.48k|    ++current;
  644|  8.48k|    if (current == end) {
  ------------------
  |  Branch (644:9): [True: 0, False: 8.48k]
  ------------------
  645|      0|      if (allow_trailing_junk) {
  ------------------
  |  Branch (645:11): [True: 0, False: 0]
  ------------------
  646|      0|        current = junk_begin;
  647|      0|        goto parsing_done;
  648|      0|      } else {
  649|      0|        return junk_string_value_;
  650|      0|      }
  651|      0|    }
  652|  8.48k|    char exponen_sign = '+';
  653|  8.48k|    if (*current == '+' || *current == '-') {
  ------------------
  |  Branch (653:9): [True: 223, False: 8.26k]
  |  Branch (653:28): [True: 3.24k, False: 5.01k]
  ------------------
  654|  3.47k|      exponen_sign = static_cast<char>(*current);
  655|  3.47k|      ++current;
  656|  3.47k|      if (current == end) {
  ------------------
  |  Branch (656:11): [True: 0, False: 3.47k]
  ------------------
  657|      0|        if (allow_trailing_junk) {
  ------------------
  |  Branch (657:13): [True: 0, False: 0]
  ------------------
  658|      0|          current = junk_begin;
  659|      0|          goto parsing_done;
  660|      0|        } else {
  661|      0|          return junk_string_value_;
  662|      0|        }
  663|      0|      }
  664|  3.47k|    }
  665|       |
  666|  8.48k|    if (current == end || *current < '0' || *current > '9') {
  ------------------
  |  Branch (666:9): [True: 0, False: 8.48k]
  |  Branch (666:27): [True: 0, False: 8.48k]
  |  Branch (666:45): [True: 0, False: 8.48k]
  ------------------
  667|      0|      if (allow_trailing_junk) {
  ------------------
  |  Branch (667:11): [True: 0, False: 0]
  ------------------
  668|      0|        current = junk_begin;
  669|      0|        goto parsing_done;
  670|      0|      } else {
  671|      0|        return junk_string_value_;
  672|      0|      }
  673|      0|    }
  674|       |
  675|  8.48k|    const int max_exponent = INT_MAX / 2;
  676|  8.48k|    DOUBLE_CONVERSION_ASSERT(-max_exponent / 2 <= exponent && exponent <= max_exponent / 2);
  ------------------
  |  |   47|  8.48k|    assert(condition)
  ------------------
  677|  8.48k|    int num = 0;
  678|   166k|    do {
  679|       |      // Check overflow.
  680|   166k|      int digit = *current - '0';
  681|   166k|      if (num >= max_exponent / 10
  ------------------
  |  Branch (681:11): [True: 143k, False: 23.3k]
  ------------------
  682|   166k|          && !(num == max_exponent / 10 && digit <= max_exponent % 10)) {
  ------------------
  |  Branch (682:16): [True: 390, False: 142k]
  |  Branch (682:44): [True: 196, False: 194]
  ------------------
  683|   143k|        num = max_exponent;
  684|   143k|      } else {
  685|  23.4k|        num = num * 10 + digit;
  686|  23.4k|      }
  687|   166k|      ++current;
  688|   166k|    } while (current != end && *current >= '0' && *current <= '9');
  ------------------
  |  Branch (688:14): [True: 158k, False: 8.48k]
  |  Branch (688:32): [True: 158k, False: 0]
  |  Branch (688:51): [True: 158k, False: 0]
  ------------------
  689|       |
  690|  8.48k|    exponent += (exponen_sign == '-' ? -num : num);
  ------------------
  |  Branch (690:18): [True: 3.24k, False: 5.23k]
  ------------------
  691|  8.48k|  }
  692|       |
  693|  8.48k|  if (!(allow_trailing_spaces || allow_trailing_junk) && (current != end)) {
  ------------------
  |  Branch (693:9): [True: 8.48k, False: 0]
  |  Branch (693:34): [True: 0, False: 0]
  |  Branch (693:58): [True: 0, False: 0]
  ------------------
  694|      0|    return junk_string_value_;
  695|      0|  }
  696|  8.48k|  if (!allow_trailing_junk && AdvanceToNonspace(&current, end)) {
  ------------------
  |  Branch (696:7): [True: 8.48k, False: 0]
  |  Branch (696:31): [True: 0, False: 8.48k]
  ------------------
  697|      0|    return junk_string_value_;
  698|      0|  }
  699|  8.48k|  if (allow_trailing_spaces) {
  ------------------
  |  Branch (699:7): [True: 8.48k, False: 0]
  ------------------
  700|  8.48k|    AdvanceToNonspace(&current, end);
  701|  8.48k|  }
  702|       |
  703|  13.4k|  parsing_done:
  704|  13.4k|  exponent += insignificant_digits;
  705|       |
  706|  13.4k|  if (octal) {
  ------------------
  |  Branch (706:7): [True: 0, False: 13.4k]
  ------------------
  707|      0|    double result;
  708|      0|    bool result_is_junk;
  709|      0|    char* start = buffer;
  710|      0|    result = RadixStringToIeee<3>(&start,
  711|      0|                                  buffer + buffer_pos,
  712|      0|                                  sign,
  713|      0|                                  separator_,
  714|      0|                                  false, // Don't parse as hex_float.
  715|      0|                                  allow_trailing_junk,
  716|      0|                                  junk_string_value_,
  717|      0|                                  read_as_double,
  718|      0|                                  &result_is_junk);
  719|      0|    DOUBLE_CONVERSION_ASSERT(!result_is_junk);
  ------------------
  |  |   47|      0|    assert(condition)
  ------------------
  720|      0|    *processed_characters_count = static_cast<int>(current - input);
  721|      0|    return result;
  722|      0|  }
  723|       |
  724|  13.4k|  if (nonzero_digit_dropped) {
  ------------------
  |  Branch (724:7): [True: 362, False: 13.0k]
  ------------------
  725|    362|    buffer[buffer_pos++] = '1';
  726|    362|    exponent--;
  727|    362|  }
  728|       |
  729|  13.4k|  DOUBLE_CONVERSION_ASSERT(buffer_pos < kBufferSize);
  ------------------
  |  |   47|  13.4k|    assert(condition)
  ------------------
  730|  13.4k|  buffer[buffer_pos] = '\0';
  731|       |
  732|       |  // Code above ensures there are no leading zeros and the buffer has fewer than
  733|       |  // kMaxSignificantDecimalDigits characters. Trim trailing zeros.
  734|  13.4k|  Vector<const char> chars(buffer, buffer_pos);
  735|  13.4k|  chars = TrimTrailingZeros(chars);
  736|  13.4k|  exponent += buffer_pos - chars.length();
  737|       |
  738|  13.4k|  double converted;
  739|  13.4k|  if (read_as_double) {
  ------------------
  |  Branch (739:7): [True: 13.4k, False: 0]
  ------------------
  740|  13.4k|    converted = StrtodTrimmed(chars, exponent);
  741|  13.4k|  } else {
  742|      0|    converted = StrtofTrimmed(chars, exponent);
  743|      0|  }
  744|  13.4k|  *processed_characters_count = static_cast<int>(current - input);
  745|  13.4k|  return sign? -converted: converted;
  ------------------
  |  Branch (745:10): [True: 271, False: 13.1k]
  ------------------
  746|  13.4k|}
NumericString.cpp:_ZN22poco_double_conversionL17AdvanceToNonspaceIPKcEEbPT_S3_:
  139|  30.9k|static inline bool AdvanceToNonspace(Iterator* current, Iterator end) {
  140|  30.9k|  while (*current != end) {
  ------------------
  |  Branch (140:10): [True: 13.9k, False: 16.9k]
  ------------------
  141|  13.9k|    if (!isWhitespace(**current)) return true;
  ------------------
  |  Branch (141:9): [True: 13.9k, False: 0]
  ------------------
  142|      0|    ++*current;
  143|      0|  }
  144|  16.9k|  return false;
  145|  30.9k|}
NumericString.cpp:_ZN22poco_double_conversionL12isWhitespaceEi:
  123|  13.9k|static bool isWhitespace(int x) {
  124|  13.9k|  if (x < 128) {
  ------------------
  |  Branch (124:7): [True: 13.9k, False: 0]
  ------------------
  125|  97.8k|    for (int i = 0; i < kWhitespaceTable7Length; i++) {
  ------------------
  |  Branch (125:21): [True: 83.8k, False: 13.9k]
  ------------------
  126|  83.8k|      if (kWhitespaceTable7[i] == x) return true;
  ------------------
  |  Branch (126:11): [True: 0, False: 83.8k]
  ------------------
  127|  83.8k|    }
  128|  13.9k|  } else {
  129|      0|    for (int i = 0; i < kWhitespaceTable16Length; i++) {
  ------------------
  |  Branch (129:21): [True: 0, False: 0]
  ------------------
  130|      0|      if (kWhitespaceTable16[i] == x) return true;
  ------------------
  |  Branch (130:11): [True: 0, False: 0]
  ------------------
  131|      0|    }
  132|      0|  }
  133|  13.9k|  return false;
  134|  13.9k|}
NumericString.cpp:_ZN22poco_double_conversion12_GLOBAL__N_121ConsumeFirstCharacterEcPKcb:
   97|  27.3k|                                         bool case_insensitivity) {
   98|  27.3k|  return case_insensitivity ? ToLower(ch) == str[0] : ch == str[0];
  ------------------
  |  Branch (98:10): [True: 0, False: 27.3k]
  ------------------
   99|  27.3k|}
NumericString.cpp:_ZN22poco_double_conversionL7AdvanceIPKcEEbPT_tiRS3_:
  190|  11.1M|static bool Advance (Iterator* it, uc16 separator, int base, Iterator& end) {
  191|  11.1M|  if (separator == StringToDoubleConverter::kNoSeparator) {
  ------------------
  |  Branch (191:7): [True: 11.1M, False: 0]
  ------------------
  192|  11.1M|    ++(*it);
  193|  11.1M|    return *it == end;
  194|  11.1M|  }
  195|      0|  if (!isDigit(**it, base)) {
  ------------------
  |  Branch (195:7): [True: 0, False: 0]
  ------------------
  196|      0|    ++(*it);
  197|      0|    return *it == end;
  198|      0|  }
  199|      0|  ++(*it);
  200|      0|  if (*it == end) return true;
  ------------------
  |  Branch (200:7): [True: 0, False: 0]
  ------------------
  201|      0|  if (*it + 1 == end) return false;
  ------------------
  |  Branch (201:7): [True: 0, False: 0]
  ------------------
  202|      0|  if (**it == separator && isDigit(*(*it + 1), base)) {
  ------------------
  |  Branch (202:7): [True: 0, False: 0]
  |  Branch (202:28): [True: 0, False: 0]
  ------------------
  203|      0|    ++(*it);
  204|      0|  }
  205|      0|  return *it == end;
  206|      0|}
NumericString.cpp:_ZN22poco_double_conversionL10SignedZeroEb:
  155|    251|static double SignedZero(bool sign) {
  156|    251|  return sign ? -0.0 : 0.0;
  ------------------
  |  Branch (156:10): [True: 10, False: 241]
  ------------------
  157|    251|}

_ZN22poco_double_conversion23StringToDoubleConverterC2EiddPKcS2_t:
  178|  13.6k|        separator_(separator) {
  179|  13.6k|  }

_ZN22poco_double_conversion13StrtodTrimmedENS_6VectorIKcEEi:
  466|  13.4k|double StrtodTrimmed(Vector<const char> trimmed, int exponent) {
  467|  13.4k|  DOUBLE_CONVERSION_ASSERT(trimmed.length() <= kMaxSignificantDecimalDigits);
  ------------------
  |  |   47|  13.4k|    assert(condition)
  ------------------
  468|  13.4k|  DOUBLE_CONVERSION_ASSERT(AssertTrimmedDigits(trimmed));
  ------------------
  |  |   47|  13.4k|    assert(condition)
  ------------------
  469|  13.4k|  double guess;
  470|  13.4k|  const bool is_correct = ComputeGuess(trimmed, exponent, &guess);
  471|  13.4k|  if (is_correct) {
  ------------------
  |  Branch (471:7): [True: 7.42k, False: 6.02k]
  ------------------
  472|  7.42k|    return guess;
  473|  7.42k|  }
  474|  6.02k|  DiyFp upper_boundary = Double(guess).UpperBoundary();
  475|  6.02k|  int comparison = CompareBufferWithDiyFp(trimmed, exponent, upper_boundary);
  476|  6.02k|  if (comparison < 0) {
  ------------------
  |  Branch (476:7): [True: 1.85k, False: 4.16k]
  ------------------
  477|  1.85k|    return guess;
  478|  4.16k|  } else if (comparison > 0) {
  ------------------
  |  Branch (478:14): [True: 3.30k, False: 860]
  ------------------
  479|  3.30k|    return Double(guess).NextDouble();
  480|  3.30k|  } else if ((Double(guess).Significand() & 1) == 0) {
  ------------------
  |  Branch (480:14): [True: 506, False: 354]
  ------------------
  481|       |    // Round towards even.
  482|    506|    return guess;
  483|    506|  } else {
  484|    354|    return Double(guess).NextDouble();
  485|    354|  }
  486|  6.02k|}
NumericString.cpp:_ZN22poco_double_conversionL12ComputeGuessENS_6VectorIKcEEiPd:
  420|  13.4k|                         double* guess) {
  421|  13.4k|  if (trimmed.length() == 0) {
  ------------------
  |  Branch (421:7): [True: 818, False: 12.6k]
  ------------------
  422|    818|    *guess = 0.0;
  423|    818|    return true;
  424|    818|  }
  425|  12.6k|  if (exponent + trimmed.length() - 1 >= kMaxDecimalPower) {
  ------------------
  |  Branch (425:7): [True: 193, False: 12.4k]
  ------------------
  426|    193|    *guess = Double::Infinity();
  427|    193|    return true;
  428|    193|  }
  429|  12.4k|  if (exponent + trimmed.length() <= kMinDecimalPower) {
  ------------------
  |  Branch (429:7): [True: 491, False: 11.9k]
  ------------------
  430|    491|    *guess = 0.0;
  431|    491|    return true;
  432|    491|  }
  433|       |
  434|  11.9k|  if (DoubleStrtod(trimmed, exponent, guess) ||
  ------------------
  |  Branch (434:7): [True: 2.73k, False: 9.21k]
  ------------------
  435|  11.9k|      DiyFpStrtod(trimmed, exponent, guess)) {
  ------------------
  |  Branch (435:7): [True: 3.18k, False: 6.02k]
  ------------------
  436|  5.92k|    return true;
  437|  5.92k|  }
  438|  6.02k|  if (*guess == Double::Infinity()) {
  ------------------
  |  Branch (438:7): [True: 1, False: 6.02k]
  ------------------
  439|      1|    return true;
  440|      1|  }
  441|  6.02k|  return false;
  442|  6.02k|}
NumericString.cpp:_ZN22poco_double_conversionL12DoubleStrtodENS_6VectorIKcEEiPd:
  192|  11.9k|                         double* result) {
  193|       |#if !defined(DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS)
  194|       |  // Avoid "unused parameter" warnings
  195|       |  (void) trimmed;
  196|       |  (void) exponent;
  197|       |  (void) result;
  198|       |  // On x86 the floating-point stack can be 64 or 80 bits wide. If it is
  199|       |  // 80 bits wide (as is the case on Linux) then double-rounding occurs and the
  200|       |  // result is not accurate.
  201|       |  // We know that Windows32 uses 64 bits and is therefore accurate.
  202|       |  return false;
  203|       |#else
  204|  11.9k|  if (trimmed.length() <= kMaxExactDoubleIntegerDecimalDigits) {
  ------------------
  |  Branch (204:7): [True: 7.90k, False: 4.04k]
  ------------------
  205|  7.90k|    int read_digits;
  206|       |    // The trimmed input fits into a double.
  207|       |    // If the 10^exponent (resp. 10^-exponent) fits into a double too then we
  208|       |    // can compute the result-double simply by multiplying (resp. dividing) the
  209|       |    // two numbers.
  210|       |    // This is possible because IEEE guarantees that floating-point operations
  211|       |    // return the best possible approximation.
  212|  7.90k|    if (exponent < 0 && -exponent < kExactPowersOfTenSize) {
  ------------------
  |  Branch (212:9): [True: 3.54k, False: 4.36k]
  |  Branch (212:25): [True: 1.32k, False: 2.22k]
  ------------------
  213|       |      // 10^-exponent fits into a double.
  214|  1.32k|      *result = static_cast<double>(ReadUint64(trimmed, &read_digits));
  215|  1.32k|      DOUBLE_CONVERSION_ASSERT(read_digits == trimmed.length());
  ------------------
  |  |   47|  1.32k|    assert(condition)
  ------------------
  216|  1.32k|      *result /= exact_powers_of_ten[-exponent];
  217|  1.32k|      return true;
  218|  1.32k|    }
  219|  6.58k|    if (0 <= exponent && exponent < kExactPowersOfTenSize) {
  ------------------
  |  Branch (219:9): [True: 4.36k, False: 2.22k]
  |  Branch (219:26): [True: 1.15k, False: 3.21k]
  ------------------
  220|       |      // 10^exponent fits into a double.
  221|  1.15k|      *result = static_cast<double>(ReadUint64(trimmed, &read_digits));
  222|  1.15k|      DOUBLE_CONVERSION_ASSERT(read_digits == trimmed.length());
  ------------------
  |  |   47|  1.15k|    assert(condition)
  ------------------
  223|  1.15k|      *result *= exact_powers_of_ten[exponent];
  224|  1.15k|      return true;
  225|  1.15k|    }
  226|  5.43k|    int remaining_digits =
  227|  5.43k|        kMaxExactDoubleIntegerDecimalDigits - trimmed.length();
  228|  5.43k|    if ((0 <= exponent) &&
  ------------------
  |  Branch (228:9): [True: 3.21k, False: 2.22k]
  ------------------
  229|  5.43k|        (exponent - remaining_digits < kExactPowersOfTenSize)) {
  ------------------
  |  Branch (229:9): [True: 263, False: 2.94k]
  ------------------
  230|       |      // The trimmed string was short and we can multiply it with
  231|       |      // 10^remaining_digits. As a result the remaining exponent now fits
  232|       |      // into a double too.
  233|    263|      *result = static_cast<double>(ReadUint64(trimmed, &read_digits));
  234|    263|      DOUBLE_CONVERSION_ASSERT(read_digits == trimmed.length());
  ------------------
  |  |   47|    263|    assert(condition)
  ------------------
  235|    263|      *result *= exact_powers_of_ten[remaining_digits];
  236|    263|      *result *= exact_powers_of_ten[exponent - remaining_digits];
  237|    263|      return true;
  238|    263|    }
  239|  5.43k|  }
  240|  9.21k|  return false;
  241|  11.9k|#endif
  242|  11.9k|}
NumericString.cpp:_ZN22poco_double_conversionL10ReadUint64ENS_6VectorIKcEEPi:
  152|  11.9k|                           int* number_of_read_digits) {
  153|  11.9k|  uint64_t result = 0;
  154|  11.9k|  int i = 0;
  155|   105k|  while (i < buffer.length() && result <= (kMaxUint64 / 10 - 1)) {
  ------------------
  |  Branch (155:10): [True: 95.5k, False: 9.44k]
  |  Branch (155:33): [True: 93.0k, False: 2.49k]
  ------------------
  156|  93.0k|    int digit = buffer[i++] - '0';
  157|  93.0k|    DOUBLE_CONVERSION_ASSERT(0 <= digit && digit <= 9);
  ------------------
  |  |   47|  93.0k|    assert(condition)
  ------------------
  158|  93.0k|    result = 10 * result + digit;
  159|  93.0k|  }
  160|  11.9k|  *number_of_read_digits = i;
  161|  11.9k|  return result;
  162|  11.9k|}
NumericString.cpp:_ZN22poco_double_conversionL11DiyFpStrtodENS_6VectorIKcEEiPd:
  272|  9.21k|                        double* result) {
  273|  9.21k|  DiyFp input;
  274|  9.21k|  int remaining_decimals;
  275|  9.21k|  ReadDiyFp(buffer, &input, &remaining_decimals);
  276|       |  // Since we may have dropped some digits the input is not accurate.
  277|       |  // If remaining_decimals is different than 0 than the error is at most
  278|       |  // .5 ulp (unit in the last place).
  279|       |  // We don't want to deal with fractions and therefore keep a common
  280|       |  // denominator.
  281|  9.21k|  const int kDenominatorLog = 3;
  282|  9.21k|  const int kDenominator = 1 << kDenominatorLog;
  283|       |  // Move the remaining decimals into the exponent.
  284|  9.21k|  exponent += remaining_decimals;
  285|  9.21k|  uint64_t error = (remaining_decimals == 0 ? 0 : kDenominator / 2);
  ------------------
  |  Branch (285:21): [True: 6.71k, False: 2.49k]
  ------------------
  286|       |
  287|  9.21k|  int old_e = input.e();
  288|  9.21k|  input.Normalize();
  289|  9.21k|  error <<= old_e - input.e();
  290|       |
  291|  9.21k|  DOUBLE_CONVERSION_ASSERT(exponent <= PowersOfTenCache::kMaxDecimalExponent);
  ------------------
  |  |   47|  9.21k|    assert(condition)
  ------------------
  292|  9.21k|  if (exponent < PowersOfTenCache::kMinDecimalExponent) {
  ------------------
  |  Branch (292:7): [True: 0, False: 9.21k]
  ------------------
  293|      0|    *result = 0.0;
  294|      0|    return true;
  295|      0|  }
  296|  9.21k|  DiyFp cached_power;
  297|  9.21k|  int cached_decimal_exponent;
  298|  9.21k|  PowersOfTenCache::GetCachedPowerForDecimalExponent(exponent,
  299|  9.21k|                                                     &cached_power,
  300|  9.21k|                                                     &cached_decimal_exponent);
  301|       |
  302|  9.21k|  if (cached_decimal_exponent != exponent) {
  ------------------
  |  Branch (302:7): [True: 8.30k, False: 905]
  ------------------
  303|  8.30k|    int adjustment_exponent = exponent - cached_decimal_exponent;
  304|  8.30k|    DiyFp adjustment_power = AdjustmentPowerOfTen(adjustment_exponent);
  305|  8.30k|    input.Multiply(adjustment_power);
  306|  8.30k|    if (kMaxUint64DecimalDigits - buffer.length() >= adjustment_exponent) {
  ------------------
  |  Branch (306:9): [True: 4.26k, False: 4.03k]
  ------------------
  307|       |      // The product of input with the adjustment power fits into a 64 bit
  308|       |      // integer.
  309|  4.26k|      DOUBLE_CONVERSION_ASSERT(DiyFp::kSignificandSize == 64);
  ------------------
  |  |   47|  4.26k|    assert(condition)
  ------------------
  310|  4.26k|    } else {
  311|       |      // The adjustment power is exact. There is hence only an error of 0.5.
  312|  4.03k|      error += kDenominator / 2;
  313|  4.03k|    }
  314|  8.30k|  }
  315|       |
  316|  9.21k|  input.Multiply(cached_power);
  317|       |  // The error introduced by a multiplication of a*b equals
  318|       |  //   error_a + error_b + error_a*error_b/2^64 + 0.5
  319|       |  // Substituting a with 'input' and b with 'cached_power' we have
  320|       |  //   error_b = 0.5  (all cached powers have an error of less than 0.5 ulp),
  321|       |  //   error_ab = 0 or 1 / kDenominator > error_a*error_b/ 2^64
  322|  9.21k|  int error_b = kDenominator / 2;
  323|  9.21k|  int error_ab = (error == 0 ? 0 : 1);  // We round up to 1.
  ------------------
  |  Branch (323:19): [True: 5.16k, False: 4.05k]
  ------------------
  324|  9.21k|  int fixed_error = kDenominator / 2;
  325|  9.21k|  error += error_b + error_ab + fixed_error;
  326|       |
  327|  9.21k|  old_e = input.e();
  328|  9.21k|  input.Normalize();
  329|  9.21k|  error <<= old_e - input.e();
  330|       |
  331|       |  // See if the double's significand changes if we add/subtract the error.
  332|  9.21k|  int order_of_magnitude = DiyFp::kSignificandSize + input.e();
  333|  9.21k|  int effective_significand_size =
  334|  9.21k|      Double::SignificandSizeForOrderOfMagnitude(order_of_magnitude);
  335|  9.21k|  int precision_digits_count =
  336|  9.21k|      DiyFp::kSignificandSize - effective_significand_size;
  337|  9.21k|  if (precision_digits_count + kDenominatorLog >= DiyFp::kSignificandSize) {
  ------------------
  |  Branch (337:7): [True: 658, False: 8.55k]
  ------------------
  338|       |    // This can only happen for very small denormals. In this case the
  339|       |    // half-way multiplied by the denominator exceeds the range of an uint64.
  340|       |    // Simply shift everything to the right.
  341|    658|    int shift_amount = (precision_digits_count + kDenominatorLog) -
  342|    658|        DiyFp::kSignificandSize + 1;
  343|    658|    input.set_f(input.f() >> shift_amount);
  344|    658|    input.set_e(input.e() + shift_amount);
  345|       |    // We add 1 for the lost precision of error, and kDenominator for
  346|       |    // the lost precision of input.f().
  347|    658|    error = (error >> shift_amount) + 1 + kDenominator;
  348|    658|    precision_digits_count -= shift_amount;
  349|    658|  }
  350|       |  // We use uint64_ts now. This only works if the DiyFp uses uint64_ts too.
  351|  9.21k|  DOUBLE_CONVERSION_ASSERT(DiyFp::kSignificandSize == 64);
  ------------------
  |  |   47|  9.21k|    assert(condition)
  ------------------
  352|  9.21k|  DOUBLE_CONVERSION_ASSERT(precision_digits_count < 64);
  ------------------
  |  |   47|  9.21k|    assert(condition)
  ------------------
  353|  9.21k|  uint64_t one64 = 1;
  354|  9.21k|  uint64_t precision_bits_mask = (one64 << precision_digits_count) - 1;
  355|  9.21k|  uint64_t precision_bits = input.f() & precision_bits_mask;
  356|  9.21k|  uint64_t half_way = one64 << (precision_digits_count - 1);
  357|  9.21k|  precision_bits *= kDenominator;
  358|  9.21k|  half_way *= kDenominator;
  359|  9.21k|  DiyFp rounded_input(input.f() >> precision_digits_count,
  360|  9.21k|                      input.e() + precision_digits_count);
  361|  9.21k|  if (precision_bits >= half_way + error) {
  ------------------
  |  Branch (361:7): [True: 1.73k, False: 7.47k]
  ------------------
  362|  1.73k|    rounded_input.set_f(rounded_input.f() + 1);
  363|  1.73k|  }
  364|       |  // If the last_bits are too close to the half-way case than we are too
  365|       |  // inaccurate and round down. In this case we return false so that we can
  366|       |  // fall back to a more precise algorithm.
  367|       |
  368|  9.21k|  *result = Double(rounded_input).value();
  369|  9.21k|  if (half_way - error < precision_bits && precision_bits < half_way + error) {
  ------------------
  |  Branch (369:7): [True: 7.75k, False: 1.45k]
  |  Branch (369:44): [True: 6.02k, False: 1.73k]
  ------------------
  370|       |    // Too imprecise. The caller will have to fall back to a slower version.
  371|       |    // However the returned number is guaranteed to be either the correct
  372|       |    // double, or the next-lower double.
  373|  6.02k|    return false;
  374|  6.02k|  } else {
  375|  3.18k|    return true;
  376|  3.18k|  }
  377|  9.21k|}
NumericString.cpp:_ZN22poco_double_conversionL9ReadDiyFpENS_6VectorIKcEEPNS_5DiyFpEPi:
  171|  9.21k|                      int* remaining_decimals) {
  172|  9.21k|  int read_digits;
  173|  9.21k|  uint64_t significand = ReadUint64(buffer, &read_digits);
  174|  9.21k|  if (buffer.length() == read_digits) {
  ------------------
  |  Branch (174:7): [True: 6.71k, False: 2.49k]
  ------------------
  175|  6.71k|    *result = DiyFp(significand, 0);
  176|  6.71k|    *remaining_decimals = 0;
  177|  6.71k|  } else {
  178|       |    // Round the significand.
  179|  2.49k|    if (buffer[read_digits] >= '5') {
  ------------------
  |  Branch (179:9): [True: 1.54k, False: 949]
  ------------------
  180|  1.54k|      significand++;
  181|  1.54k|    }
  182|       |    // Compute the binary exponent.
  183|  2.49k|    int exponent = 0;
  184|  2.49k|    *result = DiyFp(significand, exponent);
  185|  2.49k|    *remaining_decimals = buffer.length() - read_digits;
  186|  2.49k|  }
  187|  9.21k|}
NumericString.cpp:_ZN22poco_double_conversionL20AdjustmentPowerOfTenEi:
  247|  8.30k|static DiyFp AdjustmentPowerOfTen(int exponent) {
  248|  8.30k|  DOUBLE_CONVERSION_ASSERT(0 < exponent);
  ------------------
  |  |   47|  8.30k|    assert(condition)
  ------------------
  249|  8.30k|  DOUBLE_CONVERSION_ASSERT(exponent < PowersOfTenCache::kDecimalExponentDistance);
  ------------------
  |  |   47|  8.30k|    assert(condition)
  ------------------
  250|       |  // Simply hardcode the remaining powers for the given decimal exponent
  251|       |  // distance.
  252|  8.30k|  DOUBLE_CONVERSION_ASSERT(PowersOfTenCache::kDecimalExponentDistance == 8);
  ------------------
  |  |   47|  8.30k|    assert(condition)
  ------------------
  253|  8.30k|  switch (exponent) {
  254|    801|    case 1: return DiyFp(DOUBLE_CONVERSION_UINT64_2PART_C(0xa0000000, 00000000), -60);
  ------------------
  |  |  195|    801|#define DOUBLE_CONVERSION_UINT64_2PART_C(a, b) (((static_cast<uint64_t>(a) << 32) + 0x##b##u))
  ------------------
  |  Branch (254:5): [True: 801, False: 7.50k]
  ------------------
  255|  2.68k|    case 2: return DiyFp(DOUBLE_CONVERSION_UINT64_2PART_C(0xc8000000, 00000000), -57);
  ------------------
  |  |  195|  2.68k|#define DOUBLE_CONVERSION_UINT64_2PART_C(a, b) (((static_cast<uint64_t>(a) << 32) + 0x##b##u))
  ------------------
  |  Branch (255:5): [True: 2.68k, False: 5.62k]
  ------------------
  256|  1.10k|    case 3: return DiyFp(DOUBLE_CONVERSION_UINT64_2PART_C(0xfa000000, 00000000), -54);
  ------------------
  |  |  195|  1.10k|#define DOUBLE_CONVERSION_UINT64_2PART_C(a, b) (((static_cast<uint64_t>(a) << 32) + 0x##b##u))
  ------------------
  |  Branch (256:5): [True: 1.10k, False: 7.19k]
  ------------------
  257|  1.25k|    case 4: return DiyFp(DOUBLE_CONVERSION_UINT64_2PART_C(0x9c400000, 00000000), -50);
  ------------------
  |  |  195|  1.25k|#define DOUBLE_CONVERSION_UINT64_2PART_C(a, b) (((static_cast<uint64_t>(a) << 32) + 0x##b##u))
  ------------------
  |  Branch (257:5): [True: 1.25k, False: 7.05k]
  ------------------
  258|  1.13k|    case 5: return DiyFp(DOUBLE_CONVERSION_UINT64_2PART_C(0xc3500000, 00000000), -47);
  ------------------
  |  |  195|  1.13k|#define DOUBLE_CONVERSION_UINT64_2PART_C(a, b) (((static_cast<uint64_t>(a) << 32) + 0x##b##u))
  ------------------
  |  Branch (258:5): [True: 1.13k, False: 7.17k]
  ------------------
  259|    643|    case 6: return DiyFp(DOUBLE_CONVERSION_UINT64_2PART_C(0xf4240000, 00000000), -44);
  ------------------
  |  |  195|    643|#define DOUBLE_CONVERSION_UINT64_2PART_C(a, b) (((static_cast<uint64_t>(a) << 32) + 0x##b##u))
  ------------------
  |  Branch (259:5): [True: 643, False: 7.66k]
  ------------------
  260|    690|    case 7: return DiyFp(DOUBLE_CONVERSION_UINT64_2PART_C(0x98968000, 00000000), -40);
  ------------------
  |  |  195|    690|#define DOUBLE_CONVERSION_UINT64_2PART_C(a, b) (((static_cast<uint64_t>(a) << 32) + 0x##b##u))
  ------------------
  |  Branch (260:5): [True: 690, False: 7.61k]
  ------------------
  261|      0|    default:
  ------------------
  |  Branch (261:5): [True: 0, False: 8.30k]
  ------------------
  262|      0|      DOUBLE_CONVERSION_UNREACHABLE();
  ------------------
  |  |   77|      0|#define DOUBLE_CONVERSION_UNREACHABLE()   (abort())
  ------------------
  263|  8.30k|  }
  264|  8.30k|}
NumericString.cpp:_ZN22poco_double_conversionL22CompareBufferWithDiyFpENS_6VectorIKcEEiNS_5DiyFpE:
  390|  6.02k|                                  DiyFp diy_fp) {
  391|  6.02k|  DOUBLE_CONVERSION_ASSERT(buffer.length() + exponent <= kMaxDecimalPower + 1);
  ------------------
  |  |   47|  6.02k|    assert(condition)
  ------------------
  392|  6.02k|  DOUBLE_CONVERSION_ASSERT(buffer.length() + exponent > kMinDecimalPower);
  ------------------
  |  |   47|  6.02k|    assert(condition)
  ------------------
  393|  6.02k|  DOUBLE_CONVERSION_ASSERT(buffer.length() <= kMaxSignificantDecimalDigits);
  ------------------
  |  |   47|  6.02k|    assert(condition)
  ------------------
  394|       |  // Make sure that the Bignum will be able to hold all our numbers.
  395|       |  // Our Bignum implementation has a separate field for exponents. Shifts will
  396|       |  // consume at most one bigit (< 64 bits).
  397|       |  // ln(10) == 3.3219...
  398|  6.02k|  DOUBLE_CONVERSION_ASSERT(((kMaxDecimalPower + 1) * 333 / 100) < Bignum::kMaxSignificantBits);
  ------------------
  |  |   47|  6.02k|    assert(condition)
  ------------------
  399|  6.02k|  Bignum buffer_bignum;
  400|  6.02k|  Bignum diy_fp_bignum;
  401|  6.02k|  buffer_bignum.AssignDecimalString(buffer);
  402|  6.02k|  diy_fp_bignum.AssignUInt64(diy_fp.f());
  403|  6.02k|  if (exponent >= 0) {
  ------------------
  |  Branch (403:7): [True: 2.42k, False: 3.59k]
  ------------------
  404|  2.42k|    buffer_bignum.MultiplyByPowerOfTen(exponent);
  405|  3.59k|  } else {
  406|  3.59k|    diy_fp_bignum.MultiplyByPowerOfTen(-exponent);
  407|  3.59k|  }
  408|  6.02k|  if (diy_fp.e() > 0) {
  ------------------
  |  Branch (408:7): [True: 3.34k, False: 2.67k]
  ------------------
  409|  3.34k|    diy_fp_bignum.ShiftLeft(diy_fp.e());
  410|  3.34k|  } else {
  411|  2.67k|    buffer_bignum.ShiftLeft(-diy_fp.e());
  412|  2.67k|  }
  413|  6.02k|  return Bignum::Compare(buffer_bignum, diy_fp_bignum);
  414|  6.02k|}

_ZN22poco_double_conversion17TrimTrailingZerosENS_6VectorIKcEE:
   53|  13.4k|inline Vector<const char> TrimTrailingZeros(Vector<const char> buffer) {
   54|  19.2k|  for (int i = buffer.length() - 1; i >= 0; --i) {
  ------------------
  |  Branch (54:37): [True: 18.4k, False: 818]
  ------------------
   55|  18.4k|    if (buffer[i] != '0') {
  ------------------
  |  Branch (55:9): [True: 12.6k, False: 5.81k]
  ------------------
   56|  12.6k|      return buffer.SubVector(0, i + 1);
   57|  12.6k|    }
   58|  18.4k|  }
   59|    818|  return Vector<const char>(buffer.start(), 0);
   60|  13.4k|}

_ZN22poco_double_conversion7BitCastImdEET_RKT0_:
  395|  10.5k|Dest BitCast(const Source& source) {
  396|       |  // Compile time assertion: sizeof(Dest) == sizeof(Source)
  397|       |  // A compile error here means your Dest and Source have different sizes.
  398|  10.5k|#if __cplusplus >= 201103L
  399|  10.5k|  static_assert(sizeof(Dest) == sizeof(Source),
  400|  10.5k|                "source and destination size mismatch");
  401|       |#else
  402|       |  DOUBLE_CONVERSION_UNUSED
  403|       |  typedef char VerifySizesAreEqual[sizeof(Dest) == sizeof(Source) ? 1 : -1];
  404|       |#endif
  405|       |
  406|  10.5k|  Dest dest;
  407|  10.5k|  memmove(&dest, &source, sizeof(dest));
  408|  10.5k|  return dest;
  409|  10.5k|}
_ZNK22poco_double_conversion6VectorIKcEixEi:
  275|   310k|  T& operator[](int index) const {
  276|   310k|    DOUBLE_CONVERSION_ASSERT(0 <= index && index < length_);
  ------------------
  |  |   47|   310k|    assert(condition)
  ------------------
  277|   310k|    return start_[index];
  278|   310k|  }
_ZN22poco_double_conversion7BitCastIdmEET_RKT0_:
  395|  32.7k|Dest BitCast(const Source& source) {
  396|       |  // Compile time assertion: sizeof(Dest) == sizeof(Source)
  397|       |  // A compile error here means your Dest and Source have different sizes.
  398|  32.7k|#if __cplusplus >= 201103L
  399|  32.7k|  static_assert(sizeof(Dest) == sizeof(Source),
  400|  32.7k|                "source and destination size mismatch");
  401|       |#else
  402|       |  DOUBLE_CONVERSION_UNUSED
  403|       |  typedef char VerifySizesAreEqual[sizeof(Dest) == sizeof(Source) ? 1 : -1];
  404|       |#endif
  405|       |
  406|  32.7k|  Dest dest;
  407|  32.7k|  memmove(&dest, &source, sizeof(dest));
  408|  32.7k|  return dest;
  409|  32.7k|}
_ZN22poco_double_conversion6VectorIKcE9SubVectorEii:
  258|  12.6k|  Vector<T> SubVector(int from, int to) {
  259|  12.6k|    DOUBLE_CONVERSION_ASSERT(to <= length_);
  ------------------
  |  |   47|  12.6k|    assert(condition)
  ------------------
  260|  12.6k|    DOUBLE_CONVERSION_ASSERT(from < to);
  ------------------
  |  |   47|  12.6k|    assert(condition)
  ------------------
  261|  12.6k|    DOUBLE_CONVERSION_ASSERT(0 <= from);
  ------------------
  |  |   47|  12.6k|    assert(condition)
  ------------------
  262|  12.6k|    return Vector<T>(start() + from, to - from);
  263|  12.6k|  }
_ZNK22poco_double_conversion6VectorIKcE5startEv:
  272|  13.4k|  T* start() const { return start_; }
_ZN22poco_double_conversion6VectorIKcEC2EPS1_i:
  252|  26.8k|  Vector(T* data, int len) : start_(data), length_(len) {
  253|  26.8k|    DOUBLE_CONVERSION_ASSERT(len == 0 || (len > 0 && data != DOUBLE_CONVERSION_NULLPTR));
  ------------------
  |  |   47|  26.8k|    assert(condition)
  ------------------
  254|  26.8k|  }
_ZNK22poco_double_conversion6VectorIKcE6lengthEv:
  266|   213k|  int length() const { return length_; }

_ZN4Poco4JSON5Array3addERKNS_7Dynamic3VarE:
  306|  1.16M|{
  307|  1.16M|	_values.push_back(value);
  308|  1.16M|	_modified = true;
  309|  1.16M|	return *this;
  310|  1.16M|}
_ZN4Poco7Dynamic13VarHolderImplINS_9SharedPtrINS_4JSON5ArrayENS_16ReferenceCounterENS_13ReleasePolicyIS4_EEEEEC2ERKS8_:
  340|  1.29M|	{
  341|  1.29M|	}
_ZN4Poco7Dynamic13VarHolderImplINS_9SharedPtrINS_4JSON5ArrayENS_16ReferenceCounterENS_13ReleasePolicyIS4_EEEEED2Ev:
  344|  1.29M|	{
  345|  1.29M|	}
_ZNK4Poco7Dynamic13VarHolderImplINS_9SharedPtrINS_4JSON5ArrayENS_16ReferenceCounterENS_13ReleasePolicyIS4_EEEEE4typeEv:
  348|  2.33M|	{
  349|  2.33M|		return typeid(JSON::Array::Ptr);
  350|  2.33M|	}
_ZNK4Poco7Dynamic13VarHolderImplINS_9SharedPtrINS_4JSON5ArrayENS_16ReferenceCounterENS_13ReleasePolicyIS4_EEEEE5cloneEPNS_11PlaceholderINS0_9VarHolderELj64EEE:
  435|  1.22M|	{
  436|  1.22M|		return cloneHolder(pVarHolder, _val);
  437|  1.22M|	}
_ZNK4Poco7Dynamic13VarHolderImplINS_9SharedPtrINS_4JSON5ArrayENS_16ReferenceCounterENS_13ReleasePolicyIS4_EEEEE5valueEv:
  440|  1.16M|	{
  441|  1.16M|		return _val;
  442|  1.16M|	}

_ZN4Poco7Dynamic13VarHolderImplINS_9SharedPtrINS_4JSON6ObjectENS_16ReferenceCounterENS_13ReleasePolicyIS4_EEEEEC2ERKS8_:
  531|   465k|	{
  532|   465k|	}
_ZN4Poco7Dynamic13VarHolderImplINS_9SharedPtrINS_4JSON6ObjectENS_16ReferenceCounterENS_13ReleasePolicyIS4_EEEEED2Ev:
  535|   465k|	{
  536|   465k|	}
_ZNK4Poco7Dynamic13VarHolderImplINS_9SharedPtrINS_4JSON6ObjectENS_16ReferenceCounterENS_13ReleasePolicyIS4_EEEEE4typeEv:
  539|   915k|	{
  540|   915k|		return typeid(JSON::Object::Ptr);
  541|   915k|	}
_ZNK4Poco7Dynamic13VarHolderImplINS_9SharedPtrINS_4JSON6ObjectENS_16ReferenceCounterENS_13ReleasePolicyIS4_EEEEE5cloneEPNS_11PlaceholderINS0_9VarHolderELj64EEE:
  629|   400k|	{
  630|   400k|		return cloneHolder(pVarHolder, _val);
  631|   400k|	}
_ZNK4Poco7Dynamic13VarHolderImplINS_9SharedPtrINS_4JSON6ObjectENS_16ReferenceCounterENS_13ReleasePolicyIS4_EEEEE5valueEv:
  634|   305k|	{
  635|   305k|		return _val;
  636|   305k|	}

_ZNK4Poco4JSON12ParseHandler5asVarEv:
  110|     78|{
  111|     78|	return _result;
  112|     78|}
_ZN4Poco4JSON12ParseHandler5valueEl:
  129|  1.39M|{
  130|  1.39M|	setValue(v);
  131|  1.39M|}
_ZN4Poco4JSON12ParseHandler5valueEm:
  135|    975|{
  136|    975|	setValue(v);
  137|    975|}
_ZN4Poco4JSON12ParseHandler5valueERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
  142|  1.02k|{
  143|  1.02k|	setValue(s);
  144|  1.02k|}
_ZN4Poco4JSON12ParseHandler5valueEd:
  148|  13.4k|{
  149|  13.4k|	setValue(d);
  150|  13.4k|}
_ZN4Poco4JSON12ParseHandler5valueEb:
  154|    455|{
  155|    455|	setValue(b);
  156|    455|}
_ZN4Poco4JSON12ParseHandler4nullEv:
  160|    988|{
  161|    988|	Poco::Dynamic::Var empty;
  162|    988|	setValue(empty);
  163|    988|}

_ZN4Poco4JSON6Parser5parseERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
  201|  6.26k|{
  202|  6.26k|	return parseImpl(json);
  203|  6.26k|}

_ZNK4Poco4JSON10ParserImpl9asVarImplEv:
  183|     78|{
  184|     78|	if (_pHandler) return _pHandler->asVar();
  ------------------
  |  Branch (184:6): [True: 78, False: 0]
  ------------------
  185|       |
  186|      0|	return Dynamic::Var();
  187|     78|}

_ZN4Poco4JSON5ArrayC2Ei:
   41|  31.1k|{
   42|  31.1k|}
_ZN4Poco4JSON5ArrayD2Ev:
   92|  31.1k|{
   93|  31.1k|}

_ZN4Poco4JSON7HandlerC2Ev:
   24|  6.26k|{
   25|  6.26k|}
_ZN4Poco4JSON7HandlerD2Ev:
   29|  6.26k|{
   30|  6.26k|}

_ZN4Poco4JSON6ObjectC2Ei:
   42|  32.3k|{
   43|  32.3k|}
_ZN4Poco4JSON6ObjectD2Ev:
   71|  32.3k|{
   72|  32.3k|}
_ZN4Poco4JSON6Object3setERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKNS_7Dynamic3VarE:
  210|   305k|{
  211|   305k|	std::pair<ValueMap::iterator, bool> ret = _values.insert(ValueMap::value_type(key, value));
  212|   305k|	if (!ret.second) ret.first->second = value;
  ------------------
  |  Branch (212:6): [True: 263k, False: 41.6k]
  ------------------
  213|   305k|	if (_preserveInsOrder)
  ------------------
  |  Branch (213:6): [True: 0, False: 305k]
  ------------------
  214|      0|	{
  215|      0|		KeyList::iterator it = _keys.begin();
  216|      0|		KeyList::iterator end = _keys.end();
  217|      0|		for (; it != end; ++it)
  ------------------
  |  Branch (217:10): [True: 0, False: 0]
  ------------------
  218|      0|		{
  219|      0|			if (key == (*it)->first) return *this;
  ------------------
  |  Branch (219:8): [True: 0, False: 0]
  ------------------
  220|      0|		}
  221|      0|		_keys.push_back(ret.first);
  222|      0|	}
  223|   305k|	_modified = true;
  224|   305k|	return *this;
  225|   305k|}

_ZN4Poco4JSON12ParseHandlerC2Eb:
   29|  6.26k|{
   30|  6.26k|}
_ZN4Poco4JSON12ParseHandlerD2Ev:
   34|  6.26k|{
   35|  6.26k|}
_ZN4Poco4JSON12ParseHandler11startObjectEv:
   47|  32.3k|{
   48|  32.3k|	Object::Ptr newObj = new Object(_preserveObjectOrder);
   49|  32.3k|	if (_stack.empty()) // The first object
  ------------------
  |  Branch (49:6): [True: 854, False: 31.5k]
  ------------------
   50|    854|	{
   51|    854|		_result = newObj;
   52|    854|	}
   53|  31.5k|	else
   54|  31.5k|	{
   55|  31.5k|		Var parent = _stack.top();
   56|       |
   57|  31.5k|		if (parent.type() == typeid(Array::Ptr))
  ------------------
  |  Branch (57:7): [True: 1.50k, False: 30.0k]
  ------------------
   58|  1.50k|		{
   59|  1.50k|			Array::Ptr arr = parent.extract<Array::Ptr>();
   60|  1.50k|			arr->add(newObj);
   61|  1.50k|		}
   62|  30.0k|		else if (parent.type() == typeid(Object::Ptr))
  ------------------
  |  Branch (62:12): [True: 30.0k, False: 0]
  ------------------
   63|  30.0k|		{
   64|  30.0k|			Object::Ptr obj = parent.extract<Object::Ptr>();
   65|  30.0k|			obj->set(_key, newObj);
   66|  30.0k|			_key.clear();
   67|  30.0k|		}
   68|  31.5k|	}
   69|       |
   70|  32.3k|	_stack.push(newObj);
   71|  32.3k|}
_ZN4Poco4JSON12ParseHandler9endObjectEv:
   75|  27.9k|{
   76|  27.9k|	if (!_stack.empty()) _stack.pop();
  ------------------
  |  Branch (76:6): [True: 27.9k, False: 0]
  ------------------
   77|  27.9k|}
_ZN4Poco4JSON12ParseHandler10startArrayEv:
   81|  31.1k|{
   82|  31.1k|	Array::Ptr newArr = new Array();
   83|       |
   84|  31.1k|	if (_stack.empty()) // The first array
  ------------------
  |  Branch (84:6): [True: 1.19k, False: 29.9k]
  ------------------
   85|  1.19k|	{
   86|  1.19k|		_result = newArr;
   87|  1.19k|	}
   88|  29.9k|	else
   89|  29.9k|	{
   90|  29.9k|		Var parent = _stack.top();
   91|       |
   92|  29.9k|		if (parent.type() == typeid(Array::Ptr))
  ------------------
  |  Branch (92:7): [True: 29.5k, False: 456]
  ------------------
   93|  29.5k|		{
   94|  29.5k|			Array::Ptr arr = parent.extract<Array::Ptr>();
   95|  29.5k|			arr->add(newArr);
   96|  29.5k|		}
   97|    456|		else if (parent.type() == typeid(Object::Ptr))
  ------------------
  |  Branch (97:12): [True: 456, False: 0]
  ------------------
   98|    456|		{
   99|    456|			Object::Ptr obj = parent.extract<Object::Ptr>();
  100|    456|			obj->set(_key, newArr);
  101|    456|			_key.clear();
  102|    456|		}
  103|  29.9k|	}
  104|       |
  105|  31.1k|	_stack.push(newArr);
  106|  31.1k|}
_ZN4Poco4JSON12ParseHandler8endArrayEv:
  110|  20.8k|{
  111|  20.8k|	if (!_stack.empty()) _stack.pop();
  ------------------
  |  Branch (111:6): [True: 20.8k, False: 0]
  ------------------
  112|  20.8k|}
_ZN4Poco4JSON12ParseHandler3keyERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
  116|   305k|{
  117|   305k|	_key = k;
  118|   305k|}
_ZN4Poco4JSON12ParseHandler8setValueERKNS_7Dynamic3VarE:
  122|  1.41M|{
  123|  1.41M|	if (_stack.size())
  ------------------
  |  Branch (123:6): [True: 1.40M, False: 2.18k]
  ------------------
  124|  1.40M|	{
  125|  1.40M|		Var parent = _stack.top();
  126|       |
  127|  1.40M|		if (parent.type() == typeid(Array::Ptr))
  ------------------
  |  Branch (127:7): [True: 1.13M, False: 274k]
  ------------------
  128|  1.13M|		{
  129|  1.13M|			Array::Ptr arr = parent.extract<Array::Ptr>();
  130|  1.13M|			arr->add(value);
  131|  1.13M|		}
  132|   274k|		else if (parent.type() == typeid(Object::Ptr))
  ------------------
  |  Branch (132:12): [True: 274k, False: 0]
  ------------------
  133|   274k|		{
  134|   274k|			Object::Ptr obj = parent.extract<Object::Ptr>();
  135|   274k|			obj->set(_key, value);
  136|   274k|			_key.clear();
  137|   274k|		}
  138|  1.40M|	}
  139|  2.18k|	else throw JSONException("Attempt to set value on an empty stack");
  140|  1.41M|}

_ZN4Poco4JSON6ParserC2ERKNS_9SharedPtrINS0_7HandlerENS_16ReferenceCounterENS_13ReleasePolicyIS3_EEEE:
   34|  6.26k|{
   35|  6.26k|}
_ZN4Poco4JSON6ParserD2Ev:
   39|  6.26k|{
   40|  6.26k|}

_ZN4Poco4JSON10ParserImplC2ERKNS_9SharedPtrINS0_7HandlerENS_16ReferenceCounterENS_13ReleasePolicyIS3_EEEE:
   60|  6.26k|{
   61|  6.26k|}
_ZN4Poco4JSON10ParserImplD2Ev:
   65|  6.26k|{
   66|  6.26k|	delete _pJSON;
   67|  6.26k|}
_ZN4Poco4JSON10ParserImpl6handleERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
   71|  6.26k|{
   72|  6.26k|	if (!_allowNullByte && json.find("\\u0000") != json.npos)
  ------------------
  |  Branch (72:6): [True: 0, False: 6.26k]
  |  Branch (72:25): [True: 0, False: 0]
  ------------------
   73|      0|		throw JSONException("Null bytes in strings not allowed.");
   74|       |
   75|  6.26k|	try
   76|  6.26k|	{
   77|  6.26k|		json_open_buffer(_pJSON, json.data(), json.size());
   78|  6.26k|		checkError();
   79|       |		//////////////////////////////////
   80|       |		// Underlying parser is capable of parsing multiple consecutive JSONs;
   81|       |		// we do not currently support this feature; to force error on
   82|       |		// excessive characters past valid JSON end, this MUST be called
   83|       |		// AFTER opening the buffer - otherwise it is overwritten by
   84|       |		// json_open*() call, which calls internal init()
   85|  6.26k|		json_set_streaming(_pJSON, false);
   86|       |		/////////////////////////////////
   87|  6.26k|		handle();
   88|  6.26k|		checkError();
   89|  6.26k|		if (JSON_DONE != json_next(_pJSON))
  ------------------
  |  Branch (89:7): [True: 19, False: 6.24k]
  ------------------
   90|     19|			throw JSONException("Excess characters found after JSON end.");
   91|  6.24k|		json_close(_pJSON);
   92|  6.24k|	}
   93|  6.26k|	catch (...)
   94|  6.26k|	{
   95|  6.19k|		json_close(_pJSON);
   96|  6.19k|		throw;
   97|  6.19k|	}
   98|  6.26k|}
_ZN4Poco4JSON10ParserImpl9parseImplERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
  123|  6.26k|{
  124|  6.26k|	if (_allowComments)
  ------------------
  |  Branch (124:6): [True: 0, False: 6.26k]
  ------------------
  125|      0|	{
  126|      0|		std::string str = json;
  127|      0|		stripComments(str);
  128|      0|		handle(str);
  129|      0|	}
  130|  6.26k|	else
  131|  6.26k|	{
  132|  6.26k|		handle(json);
  133|  6.26k|	}
  134|       |
  135|  6.26k|	return asVarImpl();
  136|  6.26k|}
_ZN4Poco4JSON10ParserImpl11handleArrayEv:
  195|  31.1k|{
  196|  31.1k|	if (json_get_depth(_pJSON) > _depth)
  ------------------
  |  Branch (196:6): [True: 8, False: 31.1k]
  ------------------
  197|      8|		throw JSONException("Maximum depth exceeded");
  198|       |
  199|  31.1k|	json_type tok = json_peek(_pJSON);
  200|  1.19M|	while (tok != JSON_ARRAY_END && checkError())
  ------------------
  |  Branch (200:9): [True: 1.16M, False: 30.0k]
  |  Branch (200:34): [True: 1.16M, False: 1.09k]
  ------------------
  201|  1.16M|	{
  202|  1.16M|		handle();
  203|  1.16M|		tok = json_peek(_pJSON);
  204|  1.16M|	}
  205|       |
  206|  31.1k|	if (tok == JSON_ARRAY_END)
  ------------------
  |  Branch (206:6): [True: 20.8k, False: 10.3k]
  ------------------
  207|  20.8k|	{
  208|  20.8k|		handle();
  209|  20.8k|	}
  210|  10.3k|	else throw JSONException("JSON array end not found");
  211|  31.1k|}
_ZN4Poco4JSON10ParserImpl12handleObjectEv:
  215|  32.3k|{
  216|  32.3k|	if (json_get_depth(_pJSON) > _depth)
  ------------------
  |  Branch (216:6): [True: 8, False: 32.3k]
  ------------------
  217|      8|		throw JSONException("Maximum depth exceeded");
  218|       |
  219|  32.3k|	json_type tok = json_peek(_pJSON);
  220|   337k|	while (tok != JSON_OBJECT_END && checkError())
  ------------------
  |  Branch (220:9): [True: 306k, False: 31.6k]
  |  Branch (220:35): [True: 305k, False: 711]
  ------------------
  221|   305k|	{
  222|   305k|		json_next(_pJSON);
  223|   305k|		if (_pHandler) _pHandler->key(std::string(json_get_string(_pJSON, NULL)));
  ------------------
  |  Branch (223:7): [True: 305k, False: 0]
  ------------------
  224|   305k|		handle();
  225|   305k|		tok = json_peek(_pJSON);
  226|   305k|	}
  227|       |
  228|  32.3k|	if (tok == JSON_OBJECT_END)
  ------------------
  |  Branch (228:6): [True: 27.9k, False: 4.37k]
  ------------------
  229|  27.9k|	{
  230|  27.9k|		handle();
  231|  27.9k|	}
  232|  4.37k|	else throw JSONException("JSON object end not found");
  233|  32.3k|}
_ZN4Poco4JSON10ParserImpl6handleEv:
  237|  1.52M|{
  238|  1.52M|	enum json_type type = json_next(_pJSON);
  239|  1.52M|	switch (type)
  ------------------
  |  Branch (239:10): [True: 0, False: 1.52M]
  ------------------
  240|  1.52M|	{
  241|      0|	case JSON_DONE:
  ------------------
  |  Branch (241:2): [True: 0, False: 1.52M]
  ------------------
  242|      0|		return;
  243|    988|	case JSON_NULL:
  ------------------
  |  Branch (243:2): [True: 988, False: 1.52M]
  ------------------
  244|    988|		_pHandler->null();
  245|    988|		break;
  246|    261|	case JSON_TRUE:
  ------------------
  |  Branch (246:2): [True: 261, False: 1.52M]
  ------------------
  247|    261|		if (_pHandler) _pHandler->value(true);
  ------------------
  |  Branch (247:7): [True: 261, False: 0]
  ------------------
  248|    261|		break;
  249|    194|	case JSON_FALSE:
  ------------------
  |  Branch (249:2): [True: 194, False: 1.52M]
  ------------------
  250|    194|		if (_pHandler) _pHandler->value(false);
  ------------------
  |  Branch (250:7): [True: 194, False: 0]
  ------------------
  251|    194|		break;
  252|  1.40M|	case JSON_NUMBER:
  ------------------
  |  Branch (252:2): [True: 1.40M, False: 116k]
  ------------------
  253|  1.40M|		if (_pHandler)
  ------------------
  |  Branch (253:7): [True: 1.40M, False: 0]
  ------------------
  254|  1.40M|		{
  255|  1.40M|			std::string str(json_get_string(_pJSON, NULL));
  256|  1.40M|			if (str.find(_decimalPoint) != str.npos || str.find('e') != str.npos || str.find('E') != str.npos)
  ------------------
  |  Branch (256:8): [True: 6.11k, False: 1.40M]
  |  Branch (256:47): [True: 4.28k, False: 1.39M]
  |  Branch (256:76): [True: 3.29k, False: 1.39M]
  ------------------
  257|  13.6k|			{
  258|  13.6k|				_pHandler->value(NumberParser::parseFloat(str));
  259|  13.6k|			}
  260|  1.39M|			else
  261|  1.39M|			{
  262|  1.39M|				Poco::Int64 val;
  263|  1.39M|				if (NumberParser::tryParse64(str, val))
  ------------------
  |  Branch (263:9): [True: 1.39M, False: 1.03k]
  ------------------
  264|  1.39M|					_pHandler->value(val);
  265|  1.03k|				else
  266|  1.03k|					_pHandler->value(NumberParser::parseUnsigned64(str));
  267|  1.39M|			}
  268|  1.40M|		}
  269|  1.40M|		break;
  270|  1.02k|	case JSON_STRING:
  ------------------
  |  Branch (270:2): [True: 1.02k, False: 1.52M]
  ------------------
  271|  1.02k|		if (_pHandler)
  ------------------
  |  Branch (271:7): [True: 1.02k, False: 0]
  ------------------
  272|  1.02k|		{
  273|  1.02k|			std::size_t length = 0;
  274|  1.02k|			const char* val = json_get_string(_pJSON, &length);
  275|  1.02k|			_pHandler->value(std::string(val, length == 0 ? 0 : length - 1)); // Decrease the length by 1 because it also contains the terminating null character
  ------------------
  |  Branch (275:38): [True: 0, False: 1.02k]
  ------------------
  276|  1.02k|		}
  277|  1.02k|		break;
  278|  32.3k|	case JSON_OBJECT:
  ------------------
  |  Branch (278:2): [True: 32.3k, False: 1.49M]
  ------------------
  279|  32.3k|		if (_pHandler) _pHandler->startObject();
  ------------------
  |  Branch (279:7): [True: 32.3k, False: 0]
  ------------------
  280|  32.3k|		handleObject();
  281|  32.3k|		break;
  282|  27.9k|	case JSON_OBJECT_END:
  ------------------
  |  Branch (282:2): [True: 27.9k, False: 1.49M]
  ------------------
  283|  27.9k|		if (_pHandler) _pHandler->endObject();
  ------------------
  |  Branch (283:7): [True: 27.9k, False: 0]
  ------------------
  284|  27.9k|		return;
  285|  31.1k|	case JSON_ARRAY:
  ------------------
  |  Branch (285:2): [True: 31.1k, False: 1.49M]
  ------------------
  286|  31.1k|		if (_pHandler) _pHandler->startArray();
  ------------------
  |  Branch (286:7): [True: 31.1k, False: 0]
  ------------------
  287|  31.1k|		handleArray();
  288|  31.1k|		break;
  289|  20.8k|	case JSON_ARRAY_END:
  ------------------
  |  Branch (289:2): [True: 20.8k, False: 1.50M]
  ------------------
  290|  20.8k|		if (_pHandler) _pHandler->endArray();
  ------------------
  |  Branch (290:7): [True: 20.8k, False: 0]
  ------------------
  291|  20.8k|		return;
  292|  1.90k|	case JSON_ERROR:
  ------------------
  |  Branch (292:2): [True: 1.90k, False: 1.52M]
  ------------------
  293|  1.90k|		{
  294|  1.90k|			const char* pErr = json_get_error(_pJSON);
  295|  1.90k|			std::string err(pErr ? pErr : "JSON parser error.");
  ------------------
  |  Branch (295:20): [True: 1.90k, False: 0]
  ------------------
  296|  1.90k|			throw JSONException(err);
  297|      0|		}
  298|  1.52M|	}
  299|  1.52M|}
_ZN4Poco4JSON10ParserImpl10checkErrorEv:
  303|  1.47M|{
  304|  1.47M|	const char* err = json_get_error(_pJSON);
  305|  1.47M|	if (err) throw Poco::JSON::JSONException(err);
  ------------------
  |  Branch (305:6): [True: 1.80k, False: 1.47M]
  ------------------
  306|  1.47M|	return true;
  307|  1.47M|}

json_isspace:
  609|  3.55M|{
  610|  3.55M|    switch (c) {
  ------------------
  |  Branch (610:13): [True: 3.54M, False: 5.09k]
  ------------------
  611|  1.21k|    case 0x09:
  ------------------
  |  Branch (611:5): [True: 1.21k, False: 3.55M]
  ------------------
  612|  2.38k|    case 0x0a:
  ------------------
  |  Branch (612:5): [True: 1.17k, False: 3.55M]
  ------------------
  613|  3.72k|    case 0x0d:
  ------------------
  |  Branch (613:5): [True: 1.33k, False: 3.55M]
  ------------------
  614|  5.09k|    case 0x20:
  ------------------
  |  Branch (614:5): [True: 1.37k, False: 3.55M]
  ------------------
  615|  5.09k|        return true;
  616|  3.55M|    }
  617|       |
  618|  3.54M|    return false;
  619|  3.55M|}
json_peek:
  672|  1.52M|{
  673|  1.52M|    enum json_type next;
  674|  1.52M|    if (json->next)
  ------------------
  |  Branch (674:9): [True: 0, False: 1.52M]
  ------------------
  675|      0|        next = json->next;
  676|  1.52M|    else
  677|  1.52M|        next = json->next = json_next(json);
  678|  1.52M|    return next;
  679|  1.52M|}
json_next:
  682|  3.35M|{
  683|  3.35M|    if (json->flags & JSON_FLAG_ERROR)
  ------------------
  |  |   15|  3.35M|#define JSON_FLAG_ERROR      (1u << 0)
  ------------------
  |  Branch (683:9): [True: 0, False: 3.35M]
  ------------------
  684|      0|        return JSON_ERROR;
  685|  3.35M|    if (json->next != 0) {
  ------------------
  |  Branch (685:9): [True: 1.51M, False: 1.83M]
  ------------------
  686|  1.51M|        enum json_type next = json->next;
  687|  1.51M|        json->next = (enum json_type)0;
  688|  1.51M|        return next;
  689|  1.51M|    }
  690|  1.83M|    if (json->ntokens > 0 && json->stack_top == (size_t)-1) {
  ------------------
  |  Branch (690:9): [True: 1.82M, False: 6.26k]
  |  Branch (690:30): [True: 97, False: 1.82M]
  ------------------
  691|       |
  692|       |        /* In the streaming mode leave any trailing whitespaces in the stream.
  693|       |         * This allows the user to validate any desired separation between
  694|       |         * values (such as newlines) using json_source_get/peek() with any
  695|       |         * remaining whitespaces ignored as leading when we parse the next
  696|       |         * value. */
  697|     97|        if (!(json->flags & JSON_FLAG_STREAMING)) {
  ------------------
  |  |   16|     97|#define JSON_FLAG_STREAMING  (1u << 1)
  ------------------
  |  Branch (697:13): [True: 97, False: 0]
  ------------------
  698|     97|            int c;
  699|       |
  700|    873|            do {
  701|    873|                c = json->source.peek(&json->source);
  702|    873|                if (json_isspace(c)) {
  ------------------
  |  Branch (702:21): [True: 776, False: 97]
  ------------------
  703|    776|                    c = json->source.get(&json->source);
  704|    776|                }
  705|    873|            } while (json_isspace(c));
  ------------------
  |  Branch (705:22): [True: 776, False: 97]
  ------------------
  706|       |
  707|     97|            if (c != EOF) {
  ------------------
  |  Branch (707:17): [True: 19, False: 78]
  ------------------
  708|     19|                json_error(json, "expected end of text instead of byte '%c'", c);
  ------------------
  |  |   32|     19|    if (!(json->flags & JSON_FLAG_ERROR)) {                       \
  |  |  ------------------
  |  |  |  |   15|     19|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |  |  Branch (32:9): [True: 19, False: 0]
  |  |  ------------------
  |  |   33|     19|        json->flags |= JSON_FLAG_ERROR;                           \
  |  |  ------------------
  |  |  |  |   15|     19|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |   34|     19|        snprintf(json->errmsg, sizeof(json->errmsg),              \
  |  |   35|     19|                 format,                                          \
  |  |   36|     19|                 __VA_ARGS__);                                    \
  |  |   37|     19|    }                                                             \
  ------------------
  709|     19|                return JSON_ERROR;
  710|     19|            }
  711|     97|        }
  712|       |
  713|     78|        return JSON_DONE;
  714|     97|    }
  715|  1.83M|    int c = next(json);
  716|  1.83M|    if (json->stack_top == (size_t)-1) {
  ------------------
  |  Branch (716:9): [True: 6.26k, False: 1.82M]
  ------------------
  717|  6.26k|        if (c == EOF && (json->flags & JSON_FLAG_STREAMING))
  ------------------
  |  |   16|     33|#define JSON_FLAG_STREAMING  (1u << 1)
  ------------------
  |  Branch (717:13): [True: 33, False: 6.23k]
  |  Branch (717:25): [True: 0, False: 33]
  ------------------
  718|      0|            return JSON_DONE;
  719|       |
  720|  6.26k|        return read_value(json, c);
  721|  6.26k|    }
  722|  1.82M|    if (json->stack[json->stack_top].type == JSON_ARRAY) {
  ------------------
  |  Branch (722:9): [True: 1.18M, False: 639k]
  ------------------
  723|  1.18M|        if (json->stack[json->stack_top].count == 0) {
  ------------------
  |  Branch (723:13): [True: 31.1k, False: 1.15M]
  ------------------
  724|  31.1k|            if (c == ']') {
  ------------------
  |  Branch (724:17): [True: 949, False: 30.2k]
  ------------------
  725|    949|                return pop(json, c, JSON_ARRAY);
  726|    949|            }
  727|  30.2k|            json->stack[json->stack_top].count++;
  728|  30.2k|            return read_value(json, c);
  729|  1.15M|        } else if (c == ',') {
  ------------------
  |  Branch (729:20): [True: 1.13M, False: 20.7k]
  ------------------
  730|  1.13M|            json->stack[json->stack_top].count++;
  731|  1.13M|            return read_value(json, next(json));
  732|  1.13M|        } else if (c == ']') {
  ------------------
  |  Branch (732:20): [True: 19.8k, False: 870]
  ------------------
  733|  19.8k|            return pop(json, c, JSON_ARRAY);
  734|  19.8k|        } else {
  735|    870|            json_error(json, "unexpected byte '%c'", c);
  ------------------
  |  |   32|    870|    if (!(json->flags & JSON_FLAG_ERROR)) {                       \
  |  |  ------------------
  |  |  |  |   15|    870|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |  |  Branch (32:9): [True: 870, False: 0]
  |  |  ------------------
  |  |   33|    870|        json->flags |= JSON_FLAG_ERROR;                           \
  |  |  ------------------
  |  |  |  |   15|    870|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |   34|    870|        snprintf(json->errmsg, sizeof(json->errmsg),              \
  |  |   35|    870|                 format,                                          \
  |  |   36|    870|                 __VA_ARGS__);                                    \
  |  |   37|    870|    }                                                             \
  ------------------
  736|    870|            return JSON_ERROR;
  737|    870|        }
  738|  1.18M|    } else if (json->stack[json->stack_top].type == JSON_OBJECT) {
  ------------------
  |  Branch (738:16): [True: 639k, False: 0]
  ------------------
  739|   639k|        if (json->stack[json->stack_top].count == 0) {
  ------------------
  |  Branch (739:13): [True: 32.3k, False: 607k]
  ------------------
  740|  32.3k|            if (c == '}') {
  ------------------
  |  Branch (740:17): [True: 1.63k, False: 30.7k]
  ------------------
  741|  1.63k|                return pop(json, c, JSON_OBJECT);
  742|  1.63k|            }
  743|       |
  744|       |            /* No member name/value pairs yet. */
  745|  30.7k|            enum json_type value = read_value(json, c);
  746|  30.7k|            if (value != JSON_STRING) {
  ------------------
  |  Branch (746:17): [True: 213, False: 30.5k]
  ------------------
  747|    213|                if (value != JSON_ERROR)
  ------------------
  |  Branch (747:21): [True: 13, False: 200]
  ------------------
  748|     13|                    json_error(json, "%s", "expected member name or '}'");
  ------------------
  |  |   32|     13|    if (!(json->flags & JSON_FLAG_ERROR)) {                       \
  |  |  ------------------
  |  |  |  |   15|     13|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |  |  Branch (32:9): [True: 13, False: 0]
  |  |  ------------------
  |  |   33|     13|        json->flags |= JSON_FLAG_ERROR;                           \
  |  |  ------------------
  |  |  |  |   15|     13|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |   34|     13|        snprintf(json->errmsg, sizeof(json->errmsg),              \
  |  |   35|     13|                 format,                                          \
  |  |   36|     13|                 __VA_ARGS__);                                    \
  |  |   37|     13|    }                                                             \
  ------------------
  749|    213|                return JSON_ERROR;
  750|  30.5k|            } else {
  751|  30.5k|                json->stack[json->stack_top].count++;
  752|  30.5k|                return value;
  753|  30.5k|            }
  754|   607k|        } else if ((json->stack[json->stack_top].count % 2) == 0) {
  ------------------
  |  Branch (754:20): [True: 301k, False: 305k]
  ------------------
  755|       |            /* Expecting comma followed by member name. */
  756|   301k|            if (c != ',' && c != '}') {
  ------------------
  |  Branch (756:17): [True: 26.8k, False: 274k]
  |  Branch (756:29): [True: 447, False: 26.3k]
  ------------------
  757|    447|                json_error(json, "%s", "expected ',' or '}' after member value");
  ------------------
  |  |   32|    447|    if (!(json->flags & JSON_FLAG_ERROR)) {                       \
  |  |  ------------------
  |  |  |  |   15|    447|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |  |  Branch (32:9): [True: 447, False: 0]
  |  |  ------------------
  |  |   33|    447|        json->flags |= JSON_FLAG_ERROR;                           \
  |  |  ------------------
  |  |  |  |   15|    447|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |   34|    447|        snprintf(json->errmsg, sizeof(json->errmsg),              \
  |  |   35|    447|                 format,                                          \
  |  |   36|    447|                 __VA_ARGS__);                                    \
  |  |   37|    447|    }                                                             \
  ------------------
  758|    447|                return JSON_ERROR;
  759|   301k|            } else if (c == '}') {
  ------------------
  |  Branch (759:24): [True: 26.3k, False: 274k]
  ------------------
  760|  26.3k|                return pop(json, c, JSON_OBJECT);
  761|   274k|            } else {
  762|   274k|                enum json_type value = read_value(json, next(json));
  763|   274k|                if (value != JSON_STRING) {
  ------------------
  |  Branch (763:21): [True: 51, False: 274k]
  ------------------
  764|     51|                    if (value != JSON_ERROR)
  ------------------
  |  Branch (764:25): [True: 4, False: 47]
  ------------------
  765|      4|                        json_error(json, "%s", "expected member name");
  ------------------
  |  |   32|      4|    if (!(json->flags & JSON_FLAG_ERROR)) {                       \
  |  |  ------------------
  |  |  |  |   15|      4|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |  |  Branch (32:9): [True: 4, False: 0]
  |  |  ------------------
  |  |   33|      4|        json->flags |= JSON_FLAG_ERROR;                           \
  |  |  ------------------
  |  |  |  |   15|      4|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |   34|      4|        snprintf(json->errmsg, sizeof(json->errmsg),              \
  |  |   35|      4|                 format,                                          \
  |  |   36|      4|                 __VA_ARGS__);                                    \
  |  |   37|      4|    }                                                             \
  ------------------
  766|     51|                    return JSON_ERROR;
  767|   274k|                } else {
  768|   274k|                    json->stack[json->stack_top].count++;
  769|   274k|                    return value;
  770|   274k|                }
  771|   274k|            }
  772|   305k|        } else if ((json->stack[json->stack_top].count % 2) == 1) {
  ------------------
  |  Branch (772:20): [True: 305k, False: 0]
  ------------------
  773|       |            /* Expecting colon followed by value. */
  774|   305k|            if (c != ':') {
  ------------------
  |  Branch (774:17): [True: 72, False: 305k]
  ------------------
  775|     72|                json_error(json, "%s", "expected ':' after member name");
  ------------------
  |  |   32|     72|    if (!(json->flags & JSON_FLAG_ERROR)) {                       \
  |  |  ------------------
  |  |  |  |   15|     72|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |  |  Branch (32:9): [True: 72, False: 0]
  |  |  ------------------
  |  |   33|     72|        json->flags |= JSON_FLAG_ERROR;                           \
  |  |  ------------------
  |  |  |  |   15|     72|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |   34|     72|        snprintf(json->errmsg, sizeof(json->errmsg),              \
  |  |   35|     72|                 format,                                          \
  |  |   36|     72|                 __VA_ARGS__);                                    \
  |  |   37|     72|    }                                                             \
  ------------------
  776|     72|                return JSON_ERROR;
  777|   305k|            } else {
  778|   305k|                json->stack[json->stack_top].count++;
  779|   305k|                return read_value(json, next(json));
  780|   305k|            }
  781|   305k|        }
  782|   639k|    }
  783|      0|    json_error(json, "%s", "invalid parser state");
  ------------------
  |  |   32|      0|    if (!(json->flags & JSON_FLAG_ERROR)) {                       \
  |  |  ------------------
  |  |  |  |   15|      0|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |  |  Branch (32:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   33|      0|        json->flags |= JSON_FLAG_ERROR;                           \
  |  |  ------------------
  |  |  |  |   15|      0|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |   34|      0|        snprintf(json->errmsg, sizeof(json->errmsg),              \
  |  |   35|      0|                 format,                                          \
  |  |   36|      0|                 __VA_ARGS__);                                    \
  |  |   37|      0|    }                                                             \
  ------------------
  784|      0|    return JSON_ERROR;
  785|  1.82M|}
json_get_string:
  838|  1.71M|{
  839|  1.71M|    if (length != NULL)
  ------------------
  |  Branch (839:9): [True: 1.02k, False: 1.71M]
  ------------------
  840|  1.02k|        *length = json->data.string_fill;
  841|  1.71M|    if (json->data.string == NULL)
  ------------------
  |  Branch (841:9): [True: 0, False: 1.71M]
  ------------------
  842|      0|        return "";
  843|  1.71M|    else
  844|  1.71M|        return json->data.string;
  845|  1.71M|}
json_get_error:
  854|  1.48M|{
  855|  1.48M|    return json->flags & JSON_FLAG_ERROR ? json->errmsg : NULL;
  ------------------
  |  |   15|  1.48M|#define JSON_FLAG_ERROR      (1u << 0)
  ------------------
  |  Branch (855:12): [True: 3.71k, False: 1.47M]
  ------------------
  856|  1.48M|}
json_get_depth:
  869|  63.5k|{
  870|  63.5k|    return json->stack_top + 1;
  871|  63.5k|}
json_open_buffer:
  907|  6.26k|{
  908|  6.26k|    init(json);
  909|  6.26k|    json->source.get = buffer_get;
  910|  6.26k|    json->source.peek = buffer_peek;
  911|  6.26k|    json->source.source.buffer.buffer = (const char *)buffer;
  912|  6.26k|    json->source.source.buffer.length = size;
  913|  6.26k|}
json_set_streaming:
  954|  6.26k|{
  955|  6.26k|    if (streaming)
  ------------------
  |  Branch (955:9): [True: 0, False: 6.26k]
  ------------------
  956|      0|        json->flags |= JSON_FLAG_STREAMING;
  ------------------
  |  |   16|      0|#define JSON_FLAG_STREAMING  (1u << 1)
  ------------------
  957|  6.26k|    else
  958|  6.26k|        json->flags &= ~JSON_FLAG_STREAMING;
  ------------------
  |  |   16|  6.26k|#define JSON_FLAG_STREAMING  (1u << 1)
  ------------------
  959|  6.26k|}
json_close:
  962|  6.26k|{
  963|  6.26k|    json->alloc.free(json->stack);
  964|  6.26k|    json->alloc.free(json->data.string);
  965|  6.26k|}
pdjson.c:next:
  623|  3.54M|{
  624|  3.54M|   int c;
  625|  3.55M|   while (json_isspace(c = json->source.get(&json->source)))
  ------------------
  |  Branch (625:11): [True: 3.54k, False: 3.54M]
  ------------------
  626|  3.54k|       if (c == '\n')
  ------------------
  |  Branch (626:12): [True: 785, False: 2.76k]
  ------------------
  627|    785|           json->lineno++;
  628|  3.54M|   return c;
  629|  3.54M|}
pdjson.c:read_value:
  633|  1.78M|{
  634|  1.78M|    json->ntokens++;
  635|  1.78M|    switch (c) {
  636|    449|    case EOF:
  ------------------
  |  Branch (636:5): [True: 449, False: 1.78M]
  ------------------
  637|    449|        json_error(json, "%s", "unexpected end of text");
  ------------------
  |  |   32|    449|    if (!(json->flags & JSON_FLAG_ERROR)) {                       \
  |  |  ------------------
  |  |  |  |   15|    449|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |  |  Branch (32:9): [True: 449, False: 0]
  |  |  ------------------
  |  |   33|    449|        json->flags |= JSON_FLAG_ERROR;                           \
  |  |  ------------------
  |  |  |  |   15|    449|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |   34|    449|        snprintf(json->errmsg, sizeof(json->errmsg),              \
  |  |   35|    449|                 format,                                          \
  |  |   36|    449|                 __VA_ARGS__);                                    \
  |  |   37|    449|    }                                                             \
  ------------------
  638|    449|        return JSON_ERROR;
  639|  32.3k|    case '{':
  ------------------
  |  Branch (639:5): [True: 32.3k, False: 1.75M]
  ------------------
  640|  32.3k|        return push(json, JSON_OBJECT);
  641|  31.1k|    case '[':
  ------------------
  |  Branch (641:5): [True: 31.1k, False: 1.75M]
  ------------------
  642|  31.1k|        return push(json, JSON_ARRAY);
  643|   307k|    case '"':
  ------------------
  |  Branch (643:5): [True: 307k, False: 1.47M]
  ------------------
  644|   307k|        return read_string(json);
  645|  1.03k|    case 'n':
  ------------------
  |  Branch (645:5): [True: 1.03k, False: 1.78M]
  ------------------
  646|  1.03k|        return is_match(json, "ull", JSON_NULL);
  647|    267|    case 'f':
  ------------------
  |  Branch (647:5): [True: 267, False: 1.78M]
  ------------------
  648|    267|        return is_match(json, "alse", JSON_FALSE);
  649|    319|    case 't':
  ------------------
  |  Branch (649:5): [True: 319, False: 1.78M]
  ------------------
  650|    319|        return is_match(json, "rue", JSON_TRUE);
  651|   998k|    case '0':
  ------------------
  |  Branch (651:5): [True: 998k, False: 783k]
  ------------------
  652|  1.11M|    case '1':
  ------------------
  |  Branch (652:5): [True: 118k, False: 1.66M]
  ------------------
  653|  1.18M|    case '2':
  ------------------
  |  Branch (653:5): [True: 71.7k, False: 1.71M]
  ------------------
  654|  1.21M|    case '3':
  ------------------
  |  Branch (654:5): [True: 24.2k, False: 1.75M]
  ------------------
  655|  1.21M|    case '4':
  ------------------
  |  Branch (655:5): [True: 1.29k, False: 1.78M]
  ------------------
  656|  1.28M|    case '5':
  ------------------
  |  Branch (656:5): [True: 75.4k, False: 1.70M]
  ------------------
  657|  1.29M|    case '6':
  ------------------
  |  Branch (657:5): [True: 2.41k, False: 1.78M]
  ------------------
  658|  1.29M|    case '7':
  ------------------
  |  Branch (658:5): [True: 1.81k, False: 1.78M]
  ------------------
  659|  1.33M|    case '8':
  ------------------
  |  Branch (659:5): [True: 45.5k, False: 1.73M]
  ------------------
  660|  1.40M|    case '9':
  ------------------
  |  Branch (660:5): [True: 68.5k, False: 1.71M]
  ------------------
  661|  1.40M|    case '-':
  ------------------
  |  Branch (661:5): [True: 644, False: 1.78M]
  ------------------
  662|  1.40M|        if (init_string(json) != 0)
  ------------------
  |  Branch (662:13): [True: 0, False: 1.40M]
  ------------------
  663|      0|            return JSON_ERROR;
  664|  1.40M|        return read_number(json, c);
  665|     55|    default:
  ------------------
  |  Branch (665:5): [True: 55, False: 1.78M]
  ------------------
  666|     55|        json_error(json, "unexpected byte '%c' in value", c);
  ------------------
  |  |   32|     55|    if (!(json->flags & JSON_FLAG_ERROR)) {                       \
  |  |  ------------------
  |  |  |  |   15|     55|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |  |  Branch (32:9): [True: 55, False: 0]
  |  |  ------------------
  |  |   33|     55|        json->flags |= JSON_FLAG_ERROR;                           \
  |  |  ------------------
  |  |  |  |   15|     55|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |   34|     55|        snprintf(json->errmsg, sizeof(json->errmsg),              \
  |  |   35|     55|                 format,                                          \
  |  |   36|     55|                 __VA_ARGS__);                                    \
  |  |   37|     55|    }                                                             \
  ------------------
  667|     55|        return JSON_ERROR;
  668|  1.78M|    }
  669|  1.78M|}
pdjson.c:push:
   53|  63.5k|{
   54|  63.5k|    json->stack_top++;
   55|       |
   56|       |#ifdef PDJSON_STACK_MAX
   57|       |    if (json->stack_top > PDJSON_STACK_MAX) {
   58|       |        json_error(json, "%s", "maximum depth of nesting reached");
   59|       |        return JSON_ERROR;
   60|       |    }
   61|       |#endif
   62|       |
   63|  63.5k|    if (json->stack_top >= json->stack_size) {
  ------------------
  |  Branch (63:9): [True: 5.52k, False: 58.0k]
  ------------------
   64|  5.52k|        struct json_stack *stack;
   65|  5.52k|        size_t size = (json->stack_size + PDJSON_STACK_INC) * sizeof(*json->stack);
  ------------------
  |  |   43|  5.52k|#  define PDJSON_STACK_INC 4
  ------------------
   66|  5.52k|        stack = (struct json_stack *)json->alloc.realloc(json->stack, size);
   67|  5.52k|        if (stack == NULL) {
  ------------------
  |  Branch (67:13): [True: 0, False: 5.52k]
  ------------------
   68|      0|            json_error(json, "%s", "out of memory");
  ------------------
  |  |   32|      0|    if (!(json->flags & JSON_FLAG_ERROR)) {                       \
  |  |  ------------------
  |  |  |  |   15|      0|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |  |  Branch (32:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   33|      0|        json->flags |= JSON_FLAG_ERROR;                           \
  |  |  ------------------
  |  |  |  |   15|      0|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |   34|      0|        snprintf(json->errmsg, sizeof(json->errmsg),              \
  |  |   35|      0|                 format,                                          \
  |  |   36|      0|                 __VA_ARGS__);                                    \
  |  |   37|      0|    }                                                             \
  ------------------
   69|      0|            return JSON_ERROR;
   70|      0|        }
   71|       |
   72|  5.52k|        json->stack_size += PDJSON_STACK_INC;
  ------------------
  |  |   43|  5.52k|#  define PDJSON_STACK_INC 4
  ------------------
   73|  5.52k|        json->stack = stack;
   74|  5.52k|    }
   75|       |
   76|  63.5k|    json->stack[json->stack_top].type = type;
   77|  63.5k|    json->stack[json->stack_top].count = 0;
   78|       |
   79|  63.5k|    return type;
   80|  63.5k|}
pdjson.c:read_string:
  487|   307k|{
  488|   307k|    if (init_string(json) != 0)
  ------------------
  |  Branch (488:9): [True: 0, False: 307k]
  ------------------
  489|      0|        return JSON_ERROR;
  490|  33.1M|    while (1) {
  ------------------
  |  Branch (490:12): [Folded - Ignored]
  ------------------
  491|  33.1M|        int c = json->source.get(&json->source);
  492|  33.1M|        if (c == EOF) {
  ------------------
  |  Branch (492:13): [True: 646, False: 33.1M]
  ------------------
  493|    646|            json_error(json, "%s", "unterminated string literal");
  ------------------
  |  |   32|    646|    if (!(json->flags & JSON_FLAG_ERROR)) {                       \
  |  |  ------------------
  |  |  |  |   15|    646|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |  |  Branch (32:9): [True: 646, False: 0]
  |  |  ------------------
  |  |   33|    646|        json->flags |= JSON_FLAG_ERROR;                           \
  |  |  ------------------
  |  |  |  |   15|    646|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |   34|    646|        snprintf(json->errmsg, sizeof(json->errmsg),              \
  |  |   35|    646|                 format,                                          \
  |  |   36|    646|                 __VA_ARGS__);                                    \
  |  |   37|    646|    }                                                             \
  ------------------
  494|    646|            return JSON_ERROR;
  495|  33.1M|        } else if (c == '"') {
  ------------------
  |  Branch (495:20): [True: 306k, False: 32.8M]
  ------------------
  496|   306k|            if (pushchar(json, '\0') == 0)
  ------------------
  |  Branch (496:17): [True: 306k, False: 0]
  ------------------
  497|   306k|                return JSON_STRING;
  498|      0|            else
  499|      0|                return JSON_ERROR;
  500|  32.8M|        } else if (c == '\\') {
  ------------------
  |  Branch (500:20): [True: 65.3k, False: 32.7M]
  ------------------
  501|  65.3k|            if (read_escaped(json) != 0)
  ------------------
  |  Branch (501:17): [True: 682, False: 64.6k]
  ------------------
  502|    682|                return JSON_ERROR;
  503|  32.7M|        } else if ((unsigned) c >= 0x80) {
  ------------------
  |  Branch (503:20): [True: 101k, False: 32.6M]
  ------------------
  504|   101k|            if (read_utf8(json, c) != 0)
  ------------------
  |  Branch (504:17): [True: 153, False: 101k]
  ------------------
  505|    153|                return JSON_ERROR;
  506|  32.6M|        } else {
  507|  32.6M|            if (char_needs_escaping(c)) {
  ------------------
  |  Branch (507:17): [True: 9, False: 32.6M]
  ------------------
  508|      9|                json_error(json, "%s", "unescaped control character in string");
  ------------------
  |  |   32|      9|    if (!(json->flags & JSON_FLAG_ERROR)) {                       \
  |  |  ------------------
  |  |  |  |   15|      9|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |  |  Branch (32:9): [True: 9, False: 0]
  |  |  ------------------
  |  |   33|      9|        json->flags |= JSON_FLAG_ERROR;                           \
  |  |  ------------------
  |  |  |  |   15|      9|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |   34|      9|        snprintf(json->errmsg, sizeof(json->errmsg),              \
  |  |   35|      9|                 format,                                          \
  |  |   36|      9|                 __VA_ARGS__);                                    \
  |  |   37|      9|    }                                                             \
  ------------------
  509|      9|                return JSON_ERROR;
  510|      9|            }
  511|       |
  512|  32.6M|            if (pushchar(json, c) != 0)
  ------------------
  |  Branch (512:17): [True: 0, False: 32.6M]
  ------------------
  513|      0|                return JSON_ERROR;
  514|  32.6M|        }
  515|  33.1M|    }
  516|      0|    return JSON_ERROR;
  517|   307k|}
pdjson.c:pushchar:
  157|  52.8M|{
  158|  52.8M|    if (json->data.string_fill == json->data.string_size) {
  ------------------
  |  Branch (158:9): [True: 1.91k, False: 52.8M]
  ------------------
  159|  1.91k|        size_t size = json->data.string_size * 2;
  160|  1.91k|        char *buffer = (char *)json->alloc.realloc(json->data.string, size);
  161|  1.91k|        if (buffer == NULL) {
  ------------------
  |  Branch (161:13): [True: 0, False: 1.91k]
  ------------------
  162|      0|            json_error(json, "%s", "out of memory");
  ------------------
  |  |   32|      0|    if (!(json->flags & JSON_FLAG_ERROR)) {                       \
  |  |  ------------------
  |  |  |  |   15|      0|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |  |  Branch (32:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   33|      0|        json->flags |= JSON_FLAG_ERROR;                           \
  |  |  ------------------
  |  |  |  |   15|      0|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |   34|      0|        snprintf(json->errmsg, sizeof(json->errmsg),              \
  |  |   35|      0|                 format,                                          \
  |  |   36|      0|                 __VA_ARGS__);                                    \
  |  |   37|      0|    }                                                             \
  ------------------
  163|      0|            return -1;
  164|  1.91k|        } else {
  165|  1.91k|            json->data.string_size = size;
  166|  1.91k|            json->data.string = buffer;
  167|  1.91k|        }
  168|  1.91k|    }
  169|  52.8M|    json->data.string[json->data.string_fill++] = c;
  170|  52.8M|    return 0;
  171|  52.8M|}
pdjson.c:read_escaped:
  325|  65.3k|{
  326|  65.3k|    int c = json->source.get(&json->source);
  327|  65.3k|    if (c == EOF) {
  ------------------
  |  Branch (327:9): [True: 5, False: 65.3k]
  ------------------
  328|      5|        json_error(json, "%s", "unterminated string literal in escape");
  ------------------
  |  |   32|      5|    if (!(json->flags & JSON_FLAG_ERROR)) {                       \
  |  |  ------------------
  |  |  |  |   15|      5|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |  |  Branch (32:9): [True: 5, False: 0]
  |  |  ------------------
  |  |   33|      5|        json->flags |= JSON_FLAG_ERROR;                           \
  |  |  ------------------
  |  |  |  |   15|      5|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |   34|      5|        snprintf(json->errmsg, sizeof(json->errmsg),              \
  |  |   35|      5|                 format,                                          \
  |  |   36|      5|                 __VA_ARGS__);                                    \
  |  |   37|      5|    }                                                             \
  ------------------
  329|      5|        return -1;
  330|  65.3k|    } else if (c == 'u') {
  ------------------
  |  Branch (330:16): [True: 41.3k, False: 23.9k]
  ------------------
  331|  41.3k|        if (read_unicode(json) != 0)
  ------------------
  |  Branch (331:13): [True: 664, False: 40.7k]
  ------------------
  332|    664|            return -1;
  333|  41.3k|    } else {
  334|  23.9k|        switch (c) {
  335|  1.14k|        case '\\':
  ------------------
  |  Branch (335:9): [True: 1.14k, False: 22.8k]
  ------------------
  336|  22.4k|        case 'b':
  ------------------
  |  Branch (336:9): [True: 21.3k, False: 2.65k]
  ------------------
  337|  22.7k|        case 'f':
  ------------------
  |  Branch (337:9): [True: 281, False: 23.6k]
  ------------------
  338|  22.9k|        case 'n':
  ------------------
  |  Branch (338:9): [True: 194, False: 23.7k]
  ------------------
  339|  23.1k|        case 'r':
  ------------------
  |  Branch (339:9): [True: 247, False: 23.7k]
  ------------------
  340|  23.4k|        case 't':
  ------------------
  |  Branch (340:9): [True: 206, False: 23.7k]
  ------------------
  341|  23.5k|        case '/':
  ------------------
  |  Branch (341:9): [True: 197, False: 23.7k]
  ------------------
  342|  23.9k|        case '"':
  ------------------
  |  Branch (342:9): [True: 366, False: 23.6k]
  ------------------
  343|  23.9k|            {
  344|  23.9k|                const char *codes = "\\bfnrt/\"";
  345|  23.9k|                const char *p = strchr(codes, c);
  346|  23.9k|                if (pushchar(json, "\\\b\f\n\r\t/\""[p - codes]) != 0)
  ------------------
  |  Branch (346:21): [True: 0, False: 23.9k]
  ------------------
  347|      0|                    return -1;
  348|  23.9k|            }
  349|  23.9k|            break;
  350|  23.9k|        default:
  ------------------
  |  Branch (350:9): [True: 13, False: 23.9k]
  ------------------
  351|     13|            json_error(json, "invalid escaped byte '%c'", c);
  ------------------
  |  |   32|     13|    if (!(json->flags & JSON_FLAG_ERROR)) {                       \
  |  |  ------------------
  |  |  |  |   15|     13|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |  |  Branch (32:9): [True: 13, False: 0]
  |  |  ------------------
  |  |   33|     13|        json->flags |= JSON_FLAG_ERROR;                           \
  |  |  ------------------
  |  |  |  |   15|     13|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |   34|     13|        snprintf(json->errmsg, sizeof(json->errmsg),              \
  |  |   35|     13|                 format,                                          \
  |  |   36|     13|                 __VA_ARGS__);                                    \
  |  |   37|     13|    }                                                             \
  ------------------
  352|     13|            return -1;
  353|  23.9k|        }
  354|  23.9k|    }
  355|  64.6k|    return 0;
  356|  65.3k|}
pdjson.c:read_unicode:
  271|  41.3k|{
  272|  41.3k|    long cp, h, l;
  273|       |
  274|  41.3k|    if ((cp = read_unicode_cp(json)) == -1) {
  ------------------
  |  Branch (274:9): [True: 540, False: 40.8k]
  ------------------
  275|    540|        return -1;
  276|    540|    }
  277|       |
  278|  40.8k|    if (cp >= 0xd800 && cp <= 0xdbff) {
  ------------------
  |  Branch (278:9): [True: 3.48k, False: 37.3k]
  |  Branch (278:25): [True: 733, False: 2.74k]
  ------------------
  279|       |        /* This is the high portion of a surrogate pair; we need to read the
  280|       |         * lower portion to get the codepoint
  281|       |         */
  282|    733|        h = cp;
  283|       |
  284|    733|        int c = json->source.get(&json->source);
  285|    733|        if (c == EOF) {
  ------------------
  |  Branch (285:13): [True: 12, False: 721]
  ------------------
  286|     12|            json_error(json, "%s", "unterminated string literal in Unicode");
  ------------------
  |  |   32|     12|    if (!(json->flags & JSON_FLAG_ERROR)) {                       \
  |  |  ------------------
  |  |  |  |   15|     12|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |  |  Branch (32:9): [True: 12, False: 0]
  |  |  ------------------
  |  |   33|     12|        json->flags |= JSON_FLAG_ERROR;                           \
  |  |  ------------------
  |  |  |  |   15|     12|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |   34|     12|        snprintf(json->errmsg, sizeof(json->errmsg),              \
  |  |   35|     12|                 format,                                          \
  |  |   36|     12|                 __VA_ARGS__);                                    \
  |  |   37|     12|    }                                                             \
  ------------------
  287|     12|            return -1;
  288|    721|        } else if (c != '\\') {
  ------------------
  |  Branch (288:20): [True: 25, False: 696]
  ------------------
  289|     25|            json_error(json, "invalid continuation for surrogate pair '%c', "
  ------------------
  |  |   32|     25|    if (!(json->flags & JSON_FLAG_ERROR)) {                       \
  |  |  ------------------
  |  |  |  |   15|     25|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |  |  Branch (32:9): [True: 25, False: 0]
  |  |  ------------------
  |  |   33|     25|        json->flags |= JSON_FLAG_ERROR;                           \
  |  |  ------------------
  |  |  |  |   15|     25|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |   34|     25|        snprintf(json->errmsg, sizeof(json->errmsg),              \
  |  |   35|     25|                 format,                                          \
  |  |   36|     25|                 __VA_ARGS__);                                    \
  |  |   37|     25|    }                                                             \
  ------------------
  290|     25|                             "expected '\\'", c);
  291|     25|            return -1;
  292|     25|        }
  293|       |
  294|    696|        c = json->source.get(&json->source);
  295|    696|        if (c == EOF) {
  ------------------
  |  Branch (295:13): [True: 1, False: 695]
  ------------------
  296|      1|            json_error(json, "%s", "unterminated string literal in Unicode");
  ------------------
  |  |   32|      1|    if (!(json->flags & JSON_FLAG_ERROR)) {                       \
  |  |  ------------------
  |  |  |  |   15|      1|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |  |  Branch (32:9): [True: 1, False: 0]
  |  |  ------------------
  |  |   33|      1|        json->flags |= JSON_FLAG_ERROR;                           \
  |  |  ------------------
  |  |  |  |   15|      1|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |   34|      1|        snprintf(json->errmsg, sizeof(json->errmsg),              \
  |  |   35|      1|                 format,                                          \
  |  |   36|      1|                 __VA_ARGS__);                                    \
  |  |   37|      1|    }                                                             \
  ------------------
  297|      1|            return -1;
  298|    695|        } else if (c != 'u') {
  ------------------
  |  Branch (298:20): [True: 26, False: 669]
  ------------------
  299|     26|            json_error(json, "invalid continuation for surrogate pair '%c', "
  ------------------
  |  |   32|     26|    if (!(json->flags & JSON_FLAG_ERROR)) {                       \
  |  |  ------------------
  |  |  |  |   15|     26|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |  |  Branch (32:9): [True: 26, False: 0]
  |  |  ------------------
  |  |   33|     26|        json->flags |= JSON_FLAG_ERROR;                           \
  |  |  ------------------
  |  |  |  |   15|     26|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |   34|     26|        snprintf(json->errmsg, sizeof(json->errmsg),              \
  |  |   35|     26|                 format,                                          \
  |  |   36|     26|                 __VA_ARGS__);                                    \
  |  |   37|     26|    }                                                             \
  ------------------
  300|     26|                             "expected 'u'", c);
  301|     26|            return -1;
  302|     26|        }
  303|       |
  304|    669|        if ((l = read_unicode_cp(json)) == -1) {
  ------------------
  |  Branch (304:13): [True: 11, False: 658]
  ------------------
  305|     11|            return -1;
  306|     11|        }
  307|       |
  308|    658|        if (l < 0xdc00 || l > 0xdfff) {
  ------------------
  |  Branch (308:13): [True: 25, False: 633]
  |  Branch (308:27): [True: 11, False: 622]
  ------------------
  309|     36|            json_error(json, "surrogate pair continuation \\u%04lx out "
  ------------------
  |  |   32|     36|    if (!(json->flags & JSON_FLAG_ERROR)) {                       \
  |  |  ------------------
  |  |  |  |   15|     36|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |  |  Branch (32:9): [True: 36, False: 0]
  |  |  ------------------
  |  |   33|     36|        json->flags |= JSON_FLAG_ERROR;                           \
  |  |  ------------------
  |  |  |  |   15|     36|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |   34|     36|        snprintf(json->errmsg, sizeof(json->errmsg),              \
  |  |   35|     36|                 format,                                          \
  |  |   36|     36|                 __VA_ARGS__);                                    \
  |  |   37|     36|    }                                                             \
  ------------------
  310|     36|                             "of range (dc00-dfff)", l);
  311|     36|            return -1;
  312|     36|        }
  313|       |
  314|    622|        cp = ((h - 0xd800) * 0x400) + ((l - 0xdc00) + 0x10000);
  315|  40.1k|    } else if (cp >= 0xdc00 && cp <= 0xdfff) {
  ------------------
  |  Branch (315:16): [True: 2.74k, False: 37.3k]
  |  Branch (315:32): [True: 13, False: 2.73k]
  ------------------
  316|     13|            json_error(json, "dangling surrogate \\u%04lx", cp);
  ------------------
  |  |   32|     13|    if (!(json->flags & JSON_FLAG_ERROR)) {                       \
  |  |  ------------------
  |  |  |  |   15|     13|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |  |  Branch (32:9): [True: 13, False: 0]
  |  |  ------------------
  |  |   33|     13|        json->flags |= JSON_FLAG_ERROR;                           \
  |  |  ------------------
  |  |  |  |   15|     13|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |   34|     13|        snprintf(json->errmsg, sizeof(json->errmsg),              \
  |  |   35|     13|                 format,                                          \
  |  |   36|     13|                 __VA_ARGS__);                                    \
  |  |   37|     13|    }                                                             \
  ------------------
  317|     13|            return -1;
  318|     13|    }
  319|       |
  320|  40.7k|    return encode_utf8(json, cp);
  321|  40.8k|}
pdjson.c:read_unicode_cp:
  246|  42.0k|{
  247|  42.0k|    long cp = 0;
  248|  42.0k|    int shift = 12;
  249|       |
  250|   209k|    for (size_t i = 0; i < 4; i++) {
  ------------------
  |  Branch (250:24): [True: 167k, False: 41.5k]
  ------------------
  251|   167k|        int c = json->source.get(&json->source);
  252|   167k|        int hc;
  253|       |
  254|   167k|        if (c == EOF) {
  ------------------
  |  Branch (254:13): [True: 513, False: 167k]
  ------------------
  255|    513|            json_error(json, "%s", "unterminated string literal in Unicode");
  ------------------
  |  |   32|    513|    if (!(json->flags & JSON_FLAG_ERROR)) {                       \
  |  |  ------------------
  |  |  |  |   15|    513|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |  |  Branch (32:9): [True: 513, False: 0]
  |  |  ------------------
  |  |   33|    513|        json->flags |= JSON_FLAG_ERROR;                           \
  |  |  ------------------
  |  |  |  |   15|    513|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |   34|    513|        snprintf(json->errmsg, sizeof(json->errmsg),              \
  |  |   35|    513|                 format,                                          \
  |  |   36|    513|                 __VA_ARGS__);                                    \
  |  |   37|    513|    }                                                             \
  ------------------
  256|    513|            return -1;
  257|   167k|        } else if ((hc = hexchar(c)) == -1) {
  ------------------
  |  Branch (257:20): [True: 38, False: 167k]
  ------------------
  258|     38|            json_error(json, "invalid escape Unicode byte '%c'", c);
  ------------------
  |  |   32|     38|    if (!(json->flags & JSON_FLAG_ERROR)) {                       \
  |  |  ------------------
  |  |  |  |   15|     38|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |  |  Branch (32:9): [True: 38, False: 0]
  |  |  ------------------
  |  |   33|     38|        json->flags |= JSON_FLAG_ERROR;                           \
  |  |  ------------------
  |  |  |  |   15|     38|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |   34|     38|        snprintf(json->errmsg, sizeof(json->errmsg),              \
  |  |   35|     38|                 format,                                          \
  |  |   36|     38|                 __VA_ARGS__);                                    \
  |  |   37|     38|    }                                                             \
  ------------------
  259|     38|            return -1;
  260|     38|        }
  261|       |
  262|   167k|        cp += hc * (1 << shift);
  263|   167k|        shift -= 4;
  264|   167k|    }
  265|       |
  266|       |
  267|  41.5k|    return cp;
  268|  42.0k|}
pdjson.c:hexchar:
  215|   167k|{
  216|   167k|    switch (c) {
  217|  25.0k|    case '0': return 0;
  ------------------
  |  Branch (217:5): [True: 25.0k, False: 142k]
  ------------------
  218|  14.9k|    case '1': return 1;
  ------------------
  |  Branch (218:5): [True: 14.9k, False: 152k]
  ------------------
  219|  2.40k|    case '2': return 2;
  ------------------
  |  Branch (219:5): [True: 2.40k, False: 164k]
  ------------------
  220|  16.4k|    case '3': return 3;
  ------------------
  |  Branch (220:5): [True: 16.4k, False: 150k]
  ------------------
  221|  5.00k|    case '4': return 4;
  ------------------
  |  Branch (221:5): [True: 5.00k, False: 162k]
  ------------------
  222|  2.26k|    case '5': return 5;
  ------------------
  |  Branch (222:5): [True: 2.26k, False: 164k]
  ------------------
  223|  4.48k|    case '6': return 6;
  ------------------
  |  Branch (223:5): [True: 4.48k, False: 162k]
  ------------------
  224|  20.5k|    case '7': return 7;
  ------------------
  |  Branch (224:5): [True: 20.5k, False: 146k]
  ------------------
  225|  17.4k|    case '8': return 8;
  ------------------
  |  Branch (225:5): [True: 17.4k, False: 149k]
  ------------------
  226|  2.48k|    case '9': return 9;
  ------------------
  |  Branch (226:5): [True: 2.48k, False: 164k]
  ------------------
  227|  13.6k|    case 'a':
  ------------------
  |  Branch (227:5): [True: 13.6k, False: 153k]
  ------------------
  228|  15.8k|    case 'A': return 10;
  ------------------
  |  Branch (228:5): [True: 2.20k, False: 164k]
  ------------------
  229|  2.88k|    case 'b':
  ------------------
  |  Branch (229:5): [True: 2.88k, False: 164k]
  ------------------
  230|  6.04k|    case 'B': return 11;
  ------------------
  |  Branch (230:5): [True: 3.15k, False: 163k]
  ------------------
  231|  2.56k|    case 'c':
  ------------------
  |  Branch (231:5): [True: 2.56k, False: 164k]
  ------------------
  232|  5.22k|    case 'C': return 12;
  ------------------
  |  Branch (232:5): [True: 2.65k, False: 164k]
  ------------------
  233|  3.67k|    case 'd':
  ------------------
  |  Branch (233:5): [True: 3.67k, False: 163k]
  ------------------
  234|  6.89k|    case 'D': return 13;
  ------------------
  |  Branch (234:5): [True: 3.22k, False: 163k]
  ------------------
  235|  3.56k|    case 'e':
  ------------------
  |  Branch (235:5): [True: 3.56k, False: 163k]
  ------------------
  236|  17.4k|    case 'E': return 14;
  ------------------
  |  Branch (236:5): [True: 13.9k, False: 153k]
  ------------------
  237|  2.30k|    case 'f':
  ------------------
  |  Branch (237:5): [True: 2.30k, False: 164k]
  ------------------
  238|  4.34k|    case 'F': return 15;
  ------------------
  |  Branch (238:5): [True: 2.04k, False: 165k]
  ------------------
  239|     38|    default:
  ------------------
  |  Branch (239:5): [True: 38, False: 167k]
  ------------------
  240|     38|        return -1;
  241|   167k|    }
  242|   167k|}
pdjson.c:encode_utf8:
  189|  40.7k|{
  190|  40.7k|    if (c < 0x80UL) {
  ------------------
  |  Branch (190:9): [True: 717, False: 40.0k]
  ------------------
  191|    717|        return pushchar(json, c);
  192|  40.0k|    } else if (c < 0x0800UL) {
  ------------------
  |  Branch (192:16): [True: 15.0k, False: 24.9k]
  ------------------
  193|  15.0k|        return !((pushchar(json, (c >> 6 & 0x1F) | 0xC0) == 0) &&
  ------------------
  |  Branch (193:18): [True: 15.0k, False: 0]
  ------------------
  194|  15.0k|                 (pushchar(json, (c >> 0 & 0x3F) | 0x80) == 0));
  ------------------
  |  Branch (194:18): [True: 15.0k, False: 0]
  ------------------
  195|  24.9k|    } else if (c < 0x010000UL) {
  ------------------
  |  Branch (195:16): [True: 24.3k, False: 622]
  ------------------
  196|  24.3k|        if (c >= 0xd800 && c <= 0xdfff) {
  ------------------
  |  Branch (196:13): [True: 2.73k, False: 21.6k]
  |  Branch (196:28): [True: 0, False: 2.73k]
  ------------------
  197|      0|            json_error(json, "invalid codepoint %06lx", c);
  ------------------
  |  |   32|      0|    if (!(json->flags & JSON_FLAG_ERROR)) {                       \
  |  |  ------------------
  |  |  |  |   15|      0|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |  |  Branch (32:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   33|      0|        json->flags |= JSON_FLAG_ERROR;                           \
  |  |  ------------------
  |  |  |  |   15|      0|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |   34|      0|        snprintf(json->errmsg, sizeof(json->errmsg),              \
  |  |   35|      0|                 format,                                          \
  |  |   36|      0|                 __VA_ARGS__);                                    \
  |  |   37|      0|    }                                                             \
  ------------------
  198|      0|            return -1;
  199|      0|        }
  200|  24.3k|        return !((pushchar(json, (c >> 12 & 0x0F) | 0xE0) == 0) &&
  ------------------
  |  Branch (200:18): [True: 24.3k, False: 0]
  ------------------
  201|  24.3k|                 (pushchar(json, (c >>  6 & 0x3F) | 0x80) == 0) &&
  ------------------
  |  Branch (201:18): [True: 24.3k, False: 0]
  ------------------
  202|  24.3k|                 (pushchar(json, (c >>  0 & 0x3F) | 0x80) == 0));
  ------------------
  |  Branch (202:18): [True: 24.3k, False: 0]
  ------------------
  203|  24.3k|    } else if (c < 0x110000UL) {
  ------------------
  |  Branch (203:16): [True: 622, False: 0]
  ------------------
  204|    622|        return !((pushchar(json, (c >> 18 & 0x07) | 0xF0) == 0) &&
  ------------------
  |  Branch (204:18): [True: 622, False: 0]
  ------------------
  205|    622|                (pushchar(json, (c >> 12 & 0x3F) | 0x80) == 0) &&
  ------------------
  |  Branch (205:17): [True: 622, False: 0]
  ------------------
  206|    622|                (pushchar(json, (c >> 6  & 0x3F) | 0x80) == 0) &&
  ------------------
  |  Branch (206:17): [True: 622, False: 0]
  ------------------
  207|    622|                (pushchar(json, (c >> 0  & 0x3F) | 0x80) == 0));
  ------------------
  |  Branch (207:17): [True: 622, False: 0]
  ------------------
  208|    622|    } else {
  209|      0|        json_error(json, "unable to encode %06lx as UTF-8", c);
  ------------------
  |  |   32|      0|    if (!(json->flags & JSON_FLAG_ERROR)) {                       \
  |  |  ------------------
  |  |  |  |   15|      0|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |  |  Branch (32:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   33|      0|        json->flags |= JSON_FLAG_ERROR;                           \
  |  |  ------------------
  |  |  |  |   15|      0|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |   34|      0|        snprintf(json->errmsg, sizeof(json->errmsg),              \
  |  |   35|      0|                 format,                                          \
  |  |   36|      0|                 __VA_ARGS__);                                    \
  |  |   37|      0|    }                                                             \
  ------------------
  210|      0|        return -1;
  211|      0|    }
  212|  40.7k|}
pdjson.c:read_utf8:
  455|   101k|{
  456|   101k|    int count = utf8_seq_length(next_char);
  457|   101k|    if (!count)
  ------------------
  |  Branch (457:9): [True: 24, False: 101k]
  ------------------
  458|     24|    {
  459|     24|        json_error(json, "%s", "invalid UTF-8 character");
  ------------------
  |  |   32|     24|    if (!(json->flags & JSON_FLAG_ERROR)) {                       \
  |  |  ------------------
  |  |  |  |   15|     24|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |  |  Branch (32:9): [True: 24, False: 0]
  |  |  ------------------
  |  |   33|     24|        json->flags |= JSON_FLAG_ERROR;                           \
  |  |  ------------------
  |  |  |  |   15|     24|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |   34|     24|        snprintf(json->errmsg, sizeof(json->errmsg),              \
  |  |   35|     24|                 format,                                          \
  |  |   36|     24|                 __VA_ARGS__);                                    \
  |  |   37|     24|    }                                                             \
  ------------------
  460|     24|        return -1;
  461|     24|    }
  462|       |
  463|   101k|    char buffer[4];
  464|   101k|    buffer[0] = next_char;
  465|   101k|    int i;
  466|   224k|    for (i = 1; i < count; ++i)
  ------------------
  |  Branch (466:17): [True: 123k, False: 101k]
  ------------------
  467|   123k|    {
  468|   123k|        buffer[i] = json->source.get(&json->source);;
  469|   123k|    }
  470|       |
  471|   101k|    if (!is_legal_utf8((unsigned char*) buffer, count))
  ------------------
  |  Branch (471:9): [True: 129, False: 101k]
  ------------------
  472|    129|    {
  473|    129|        json_error(json, "%s", "invalid UTF-8 text");
  ------------------
  |  |   32|    129|    if (!(json->flags & JSON_FLAG_ERROR)) {                       \
  |  |  ------------------
  |  |  |  |   15|    129|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |  |  Branch (32:9): [True: 129, False: 0]
  |  |  ------------------
  |  |   33|    129|        json->flags |= JSON_FLAG_ERROR;                           \
  |  |  ------------------
  |  |  |  |   15|    129|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |   34|    129|        snprintf(json->errmsg, sizeof(json->errmsg),              \
  |  |   35|    129|                 format,                                          \
  |  |   36|    129|                 __VA_ARGS__);                                    \
  |  |   37|    129|    }                                                             \
  ------------------
  474|    129|        return -1;
  475|    129|    }
  476|       |
  477|   325k|    for (i = 0; i < count; ++i)
  ------------------
  |  Branch (477:17): [True: 224k, False: 101k]
  ------------------
  478|   224k|    {
  479|   224k|        if (pushchar(json, buffer[i]) != 0)
  ------------------
  |  Branch (479:13): [True: 0, False: 224k]
  ------------------
  480|      0|            return -1;
  481|   224k|    }
  482|   101k|    return 0;
  483|   101k|}
pdjson.c:utf8_seq_length:
  370|   101k|{
  371|   101k|    unsigned char u = (unsigned char) byte;
  372|   101k|    if (u < 0x80) return 1;
  ------------------
  |  Branch (372:9): [True: 0, False: 101k]
  ------------------
  373|       |
  374|   101k|    if (0x80 <= u && u <= 0xBF)
  ------------------
  |  Branch (374:9): [True: 101k, False: 0]
  |  Branch (374:22): [True: 12, False: 101k]
  ------------------
  375|     12|    {
  376|       |        // second, third or fourth byte of a multi-byte
  377|       |        // sequence, i.e. a "continuation byte"
  378|     12|        return 0;
  379|     12|    }
  380|   101k|    else if (u == 0xC0 || u == 0xC1)
  ------------------
  |  Branch (380:14): [True: 2, False: 101k]
  |  Branch (380:27): [True: 3, False: 101k]
  ------------------
  381|      5|    {
  382|       |        // overlong encoding of an ASCII byte
  383|      5|        return 0;
  384|      5|    }
  385|   101k|    else if (0xC2 <= u && u <= 0xDF)
  ------------------
  |  Branch (385:14): [True: 101k, False: 0]
  |  Branch (385:27): [True: 83.3k, False: 18.1k]
  ------------------
  386|  83.3k|    {
  387|       |        // 2-byte sequence
  388|  83.3k|        return 2;
  389|  83.3k|    }
  390|  18.1k|    else if (0xE0 <= u && u <= 0xEF)
  ------------------
  |  Branch (390:14): [True: 18.1k, False: 0]
  |  Branch (390:27): [True: 14.2k, False: 3.92k]
  ------------------
  391|  14.2k|    {
  392|       |        // 3-byte sequence
  393|  14.2k|        return 3;
  394|  14.2k|    }
  395|  3.92k|    else if (0xF0 <= u && u <= 0xF4)
  ------------------
  |  Branch (395:14): [True: 3.92k, False: 0]
  |  Branch (395:27): [True: 3.91k, False: 7]
  ------------------
  396|  3.91k|    {
  397|       |        // 4-byte sequence
  398|  3.91k|        return 4;
  399|  3.91k|    }
  400|      7|    else
  401|      7|    {
  402|       |        // u >= 0xF5
  403|       |        // Restricted (start of 4-, 5- or 6-byte sequence) or invalid UTF-8
  404|      7|        return 0;
  405|      7|    }
  406|   101k|}
pdjson.c:is_legal_utf8:
  410|   101k|{
  411|   101k|    if (0 == bytes || 0 == length) return 0;
  ------------------
  |  Branch (411:9): [True: 0, False: 101k]
  |  Branch (411:23): [True: 0, False: 101k]
  ------------------
  412|       |
  413|   101k|    unsigned char a;
  414|   101k|    const unsigned char* srcptr = bytes + length;
  415|   101k|    switch (length)
  416|   101k|    {
  417|      0|    default:
  ------------------
  |  Branch (417:5): [True: 0, False: 101k]
  ------------------
  418|      0|        return 0;
  419|       |        // Everything else falls through when true.
  420|  3.91k|    case 4:
  ------------------
  |  Branch (420:5): [True: 3.91k, False: 97.5k]
  ------------------
  421|  3.91k|        if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return 0;
  ------------------
  |  Branch (421:13): [True: 3, False: 3.91k]
  |  Branch (421:41): [True: 30, False: 3.88k]
  ------------------
  422|       |        /* FALLTHRU */
  423|  18.1k|    case 3:
  ------------------
  |  Branch (423:5): [True: 14.2k, False: 87.2k]
  ------------------
  424|  18.1k|        if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return 0;
  ------------------
  |  Branch (424:13): [True: 1, False: 18.1k]
  |  Branch (424:41): [True: 18, False: 18.0k]
  ------------------
  425|       |        /* FALLTHRU */
  426|   101k|    case 2:
  ------------------
  |  Branch (426:5): [True: 83.3k, False: 18.1k]
  ------------------
  427|   101k|        a = (*--srcptr);
  428|   101k|        switch (*bytes)
  429|   101k|        {
  430|  1.85k|        case 0xE0:
  ------------------
  |  Branch (430:9): [True: 1.85k, False: 99.5k]
  ------------------
  431|  1.85k|            if (a < 0xA0 || a > 0xBF) return 0;
  ------------------
  |  Branch (431:17): [True: 10, False: 1.84k]
  |  Branch (431:29): [True: 6, False: 1.83k]
  ------------------
  432|  1.83k|            break;
  433|  9.67k|        case 0xED:
  ------------------
  |  Branch (433:9): [True: 9.67k, False: 91.7k]
  ------------------
  434|  9.67k|            if (a < 0x80 || a > 0x9F) return 0;
  ------------------
  |  Branch (434:17): [True: 2, False: 9.66k]
  |  Branch (434:29): [True: 10, False: 9.65k]
  ------------------
  435|  9.65k|            break;
  436|  9.65k|        case 0xF0:
  ------------------
  |  Branch (436:9): [True: 246, False: 101k]
  ------------------
  437|    246|            if (a < 0x90 || a > 0xBF) return 0;
  ------------------
  |  Branch (437:17): [True: 11, False: 235]
  |  Branch (437:29): [True: 4, False: 231]
  ------------------
  438|    231|            break;
  439|    581|        case 0xF4:
  ------------------
  |  Branch (439:9): [True: 581, False: 100k]
  ------------------
  440|    581|            if (a < 0x80 || a > 0x8F) return 0;
  ------------------
  |  Branch (440:17): [True: 3, False: 578]
  |  Branch (440:29): [True: 7, False: 571]
  ------------------
  441|    571|            break;
  442|  89.0k|        default:
  ------------------
  |  Branch (442:9): [True: 89.0k, False: 12.3k]
  ------------------
  443|  89.0k|            if (a < 0x80 || a > 0xBF) return 0;
  ------------------
  |  Branch (443:17): [True: 3, False: 89.0k]
  |  Branch (443:29): [True: 21, False: 89.0k]
  ------------------
  444|  89.0k|            break;
  445|   101k|        }
  446|       |        /* FALLTHRU */
  447|   101k|    case 1:
  ------------------
  |  Branch (447:5): [True: 0, False: 101k]
  ------------------
  448|   101k|        if (*bytes >= 0x80 && *bytes < 0xC2) return 0;
  ------------------
  |  Branch (448:13): [True: 101k, False: 0]
  |  Branch (448:31): [True: 0, False: 101k]
  ------------------
  449|   101k|    }
  450|   101k|    return *bytes <= 0xF4;
  451|   101k|}
pdjson.c:char_needs_escaping:
  360|  32.6M|{
  361|  32.6M|    if ((c >= 0) && (c < 0x20 || c == 0x22 || c == 0x5c)) {
  ------------------
  |  Branch (361:9): [True: 32.6M, False: 0]
  |  Branch (361:22): [True: 9, False: 32.6M]
  |  Branch (361:34): [True: 0, False: 32.6M]
  |  Branch (361:47): [True: 0, False: 32.6M]
  ------------------
  362|      9|        return 1;
  363|      9|    }
  364|       |
  365|  32.6M|    return 0;
  366|  32.6M|}
pdjson.c:is_match:
  145|  1.62k|{
  146|  1.62k|    int c;
  147|  6.35k|    for (const char *p = pattern; *p; p++) {
  ------------------
  |  Branch (147:35): [True: 4.91k, False: 1.44k]
  ------------------
  148|  4.91k|        if (*p != (c = json->source.get(&json->source))) {
  ------------------
  |  Branch (148:13): [True: 180, False: 4.73k]
  ------------------
  149|    180|            json_error(json, "expected '%c' instead of byte '%c'", *p, c);
  ------------------
  |  |   32|    180|    if (!(json->flags & JSON_FLAG_ERROR)) {                       \
  |  |  ------------------
  |  |  |  |   15|    180|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |  |  Branch (32:9): [True: 180, False: 0]
  |  |  ------------------
  |  |   33|    180|        json->flags |= JSON_FLAG_ERROR;                           \
  |  |  ------------------
  |  |  |  |   15|    180|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |   34|    180|        snprintf(json->errmsg, sizeof(json->errmsg),              \
  |  |   35|    180|                 format,                                          \
  |  |   36|    180|                 __VA_ARGS__);                                    \
  |  |   37|    180|    }                                                             \
  ------------------
  150|    180|            return JSON_ERROR;
  151|    180|        }
  152|  4.91k|    }
  153|  1.44k|    return type;
  154|  1.62k|}
pdjson.c:init_string:
  174|  1.71M|{
  175|  1.71M|    json->data.string_fill = 0;
  176|  1.71M|    if (json->data.string == NULL) {
  ------------------
  |  Branch (176:9): [True: 5.73k, False: 1.71M]
  ------------------
  177|  5.73k|        json->data.string_size = 1024;
  178|  5.73k|        json->data.string = (char *)json->alloc.malloc(json->data.string_size);
  179|  5.73k|        if (json->data.string == NULL) {
  ------------------
  |  Branch (179:13): [True: 0, False: 5.73k]
  ------------------
  180|      0|            json_error(json, "%s", "out of memory");
  ------------------
  |  |   32|      0|    if (!(json->flags & JSON_FLAG_ERROR)) {                       \
  |  |  ------------------
  |  |  |  |   15|      0|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |  |  Branch (32:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   33|      0|        json->flags |= JSON_FLAG_ERROR;                           \
  |  |  ------------------
  |  |  |  |   15|      0|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |   34|      0|        snprintf(json->errmsg, sizeof(json->errmsg),              \
  |  |   35|      0|                 format,                                          \
  |  |   36|      0|                 __VA_ARGS__);                                    \
  |  |   37|      0|    }                                                             \
  ------------------
  181|      0|            return -1;
  182|      0|        }
  183|  5.73k|    }
  184|  1.71M|    json->data.string[0] = '\0';
  185|  1.71M|    return 0;
  186|  1.71M|}
pdjson.c:read_number:
  547|  1.40M|{
  548|  1.40M|    if (pushchar(json, c) != 0)
  ------------------
  |  Branch (548:9): [True: 0, False: 1.40M]
  ------------------
  549|      0|        return JSON_ERROR;
  550|  1.40M|    if (c == '-') {
  ------------------
  |  Branch (550:9): [True: 644, False: 1.40M]
  ------------------
  551|    644|        c = json->source.get(&json->source);
  552|    644|        if (is_digit(c)) {
  ------------------
  |  Branch (552:13): [True: 616, False: 28]
  ------------------
  553|    616|            return read_number(json, c);
  554|    616|        } else {
  555|     28|            json_error(json, "unexpected byte '%c' in number", c);
  ------------------
  |  |   32|     28|    if (!(json->flags & JSON_FLAG_ERROR)) {                       \
  |  |  ------------------
  |  |  |  |   15|     28|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |  |  Branch (32:9): [True: 28, False: 0]
  |  |  ------------------
  |  |   33|     28|        json->flags |= JSON_FLAG_ERROR;                           \
  |  |  ------------------
  |  |  |  |   15|     28|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |   34|     28|        snprintf(json->errmsg, sizeof(json->errmsg),              \
  |  |   35|     28|                 format,                                          \
  |  |   36|     28|                 __VA_ARGS__);                                    \
  |  |   37|     28|    }                                                             \
  ------------------
  556|     28|            return JSON_ERROR;
  557|     28|        }
  558|  1.40M|    } else if (c >= '1' && c <= '9') {
  ------------------
  |  Branch (558:16): [True: 410k, False: 998k]
  |  Branch (558:28): [True: 410k, False: 0]
  ------------------
  559|   410k|        c = json->source.peek(&json->source);
  560|   410k|        if (is_digit(c)) {
  ------------------
  |  Branch (560:13): [True: 28.5k, False: 381k]
  ------------------
  561|  28.5k|            if (read_digits(json) != 0)
  ------------------
  |  Branch (561:17): [True: 0, False: 28.5k]
  ------------------
  562|      0|                return JSON_ERROR;
  563|  28.5k|        }
  564|   410k|    }
  565|       |    /* Up to decimal or exponent has been read. */
  566|  1.40M|    c = json->source.peek(&json->source);
  567|  1.40M|    if (strchr(".eE", c) == NULL) {
  ------------------
  |  Branch (567:9): [True: 1.39M, False: 13.8k]
  ------------------
  568|  1.39M|        if (pushchar(json, '\0') != 0)
  ------------------
  |  Branch (568:13): [True: 0, False: 1.39M]
  ------------------
  569|      0|            return JSON_ERROR;
  570|  1.39M|        else
  571|  1.39M|            return JSON_NUMBER;
  572|  1.39M|    }
  573|  13.8k|    if (c == '.') {
  ------------------
  |  Branch (573:9): [True: 6.15k, False: 7.65k]
  ------------------
  574|  6.15k|        json->source.get(&json->source); // consume .
  575|  6.15k|        if (pushchar(json, c) != 0)
  ------------------
  |  Branch (575:13): [True: 0, False: 6.15k]
  ------------------
  576|      0|            return JSON_ERROR;
  577|  6.15k|        if (read_digits(json) != 0)
  ------------------
  |  Branch (577:13): [True: 39, False: 6.11k]
  ------------------
  578|     39|            return JSON_ERROR;
  579|  6.15k|    }
  580|       |    /* Check for exponent. */
  581|  13.7k|    c = json->source.peek(&json->source);
  582|  13.7k|    if (c == 'e' || c == 'E') {
  ------------------
  |  Branch (582:9): [True: 4.85k, False: 8.91k]
  |  Branch (582:21): [True: 3.69k, False: 5.22k]
  ------------------
  583|  8.54k|        json->source.get(&json->source); // consume e/E
  584|  8.54k|        if (pushchar(json, c) != 0)
  ------------------
  |  Branch (584:13): [True: 0, False: 8.54k]
  ------------------
  585|      0|            return JSON_ERROR;
  586|  8.54k|        c = json->source.peek(&json->source);
  587|  8.54k|        if (c == '+' || c == '-') {
  ------------------
  |  Branch (587:13): [True: 229, False: 8.32k]
  |  Branch (587:25): [True: 3.25k, False: 5.06k]
  ------------------
  588|  3.48k|            json->source.get(&json->source); // consume
  589|  3.48k|            if (pushchar(json, c) != 0)
  ------------------
  |  Branch (589:17): [True: 0, False: 3.48k]
  ------------------
  590|      0|                return JSON_ERROR;
  591|  3.48k|            if (read_digits(json) != 0)
  ------------------
  |  Branch (591:17): [True: 11, False: 3.47k]
  ------------------
  592|     11|                return JSON_ERROR;
  593|  5.06k|        } else if (is_digit(c)) {
  ------------------
  |  Branch (593:20): [True: 5.01k, False: 55]
  ------------------
  594|  5.01k|            if (read_digits(json) != 0)
  ------------------
  |  Branch (594:17): [True: 0, False: 5.01k]
  ------------------
  595|      0|                return JSON_ERROR;
  596|  5.01k|        } else {
  597|     55|            json_error(json, "unexpected byte '%c' in number", c);
  ------------------
  |  |   32|     55|    if (!(json->flags & JSON_FLAG_ERROR)) {                       \
  |  |  ------------------
  |  |  |  |   15|     55|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |  |  Branch (32:9): [True: 55, False: 0]
  |  |  ------------------
  |  |   33|     55|        json->flags |= JSON_FLAG_ERROR;                           \
  |  |  ------------------
  |  |  |  |   15|     55|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |   34|     55|        snprintf(json->errmsg, sizeof(json->errmsg),              \
  |  |   35|     55|                 format,                                          \
  |  |   36|     55|                 __VA_ARGS__);                                    \
  |  |   37|     55|    }                                                             \
  ------------------
  598|     55|            return JSON_ERROR;
  599|     55|        }
  600|  8.54k|    }
  601|  13.7k|    if (pushchar(json, '\0') != 0)
  ------------------
  |  Branch (601:9): [True: 0, False: 13.7k]
  ------------------
  602|      0|        return JSON_ERROR;
  603|  13.7k|    else
  604|  13.7k|        return JSON_NUMBER;
  605|  13.7k|}
pdjson.c:is_digit:
  521|  17.0M|{
  522|  17.0M|    return c >= 48 /*0*/ && c <= 57 /*9*/;
  ------------------
  |  Branch (522:12): [True: 16.6M, False: 416k]
  |  Branch (522:29): [True: 16.6M, False: 8.09k]
  ------------------
  523|  17.0M|}
pdjson.c:read_digits:
  527|  43.1k|{
  528|  43.1k|    int c;
  529|  43.1k|    unsigned nread = 0;
  530|  16.6M|    while (is_digit(c = json->source.peek(&json->source))) {
  ------------------
  |  Branch (530:12): [True: 16.6M, False: 43.1k]
  ------------------
  531|  16.6M|        if (pushchar(json, json->source.get(&json->source)) != 0)
  ------------------
  |  Branch (531:13): [True: 0, False: 16.6M]
  ------------------
  532|      0|            return -1;
  533|       |
  534|  16.6M|        nread++;
  535|  16.6M|    }
  536|       |
  537|  43.1k|    if (nread == 0) {
  ------------------
  |  Branch (537:9): [True: 50, False: 43.1k]
  ------------------
  538|     50|        json_error(json, "expected digit instead of byte '%c'", c);
  ------------------
  |  |   32|     50|    if (!(json->flags & JSON_FLAG_ERROR)) {                       \
  |  |  ------------------
  |  |  |  |   15|     50|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |  |  Branch (32:9): [True: 50, False: 0]
  |  |  ------------------
  |  |   33|     50|        json->flags |= JSON_FLAG_ERROR;                           \
  |  |  ------------------
  |  |  |  |   15|     50|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |   34|     50|        snprintf(json->errmsg, sizeof(json->errmsg),              \
  |  |   35|     50|                 format,                                          \
  |  |   36|     50|                 __VA_ARGS__);                                    \
  |  |   37|     50|    }                                                             \
  ------------------
  539|     50|        return -1;
  540|     50|    }
  541|       |
  542|  43.1k|    return 0;
  543|  43.1k|}
pdjson.c:pop:
   84|  48.8k|{
   85|  48.8k|    if (json->stack == NULL || json->stack[json->stack_top].type != expected) {
  ------------------
  |  Branch (85:9): [True: 0, False: 48.8k]
  |  Branch (85:32): [True: 0, False: 48.8k]
  ------------------
   86|      0|        json_error(json, "unexpected byte '%c'", c);
  ------------------
  |  |   32|      0|    if (!(json->flags & JSON_FLAG_ERROR)) {                       \
  |  |  ------------------
  |  |  |  |   15|      0|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |  |  Branch (32:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   33|      0|        json->flags |= JSON_FLAG_ERROR;                           \
  |  |  ------------------
  |  |  |  |   15|      0|#define JSON_FLAG_ERROR      (1u << 0)
  |  |  ------------------
  |  |   34|      0|        snprintf(json->errmsg, sizeof(json->errmsg),              \
  |  |   35|      0|                 format,                                          \
  |  |   36|      0|                 __VA_ARGS__);                                    \
  |  |   37|      0|    }                                                             \
  ------------------
   87|      0|        return JSON_ERROR;
   88|      0|    }
   89|  48.8k|    json->stack_top--;
   90|  48.8k|    return expected == JSON_ARRAY ? JSON_ARRAY_END : JSON_OBJECT_END;
  ------------------
  |  Branch (90:12): [True: 20.8k, False: 27.9k]
  ------------------
   91|  48.8k|}
pdjson.c:init:
  122|  6.26k|{
  123|  6.26k|    json->lineno = 1;
  124|  6.26k|    json->flags = JSON_FLAG_STREAMING;
  ------------------
  |  |   16|  6.26k|#define JSON_FLAG_STREAMING  (1u << 1)
  ------------------
  125|  6.26k|    json->errmsg[0] = '\0';
  126|  6.26k|    json->ntokens = 0;
  127|  6.26k|    json->next = (enum json_type)0;
  128|       |
  129|  6.26k|    json->stack = NULL;
  130|  6.26k|    json->stack_top = -1;
  131|  6.26k|    json->stack_size = 0;
  132|       |
  133|  6.26k|    json->data.string = NULL;
  134|  6.26k|    json->data.string_size = 0;
  135|  6.26k|    json->data.string_fill = 0;
  136|  6.26k|    json->source.position = 0;
  137|       |
  138|  6.26k|    json->alloc.malloc = malloc;
  139|  6.26k|    json->alloc.realloc = realloc;
  140|  6.26k|    json->alloc.free = free;
  141|  6.26k|}
pdjson.c:buffer_get:
  102|  53.7M|{
  103|  53.7M|    int c = source->peek(source);
  104|  53.7M|    source->position++;
  105|  53.7M|    return c;
  106|  53.7M|}
pdjson.c:buffer_peek:
   94|  72.2M|{
   95|  72.2M|    if (source->position < source->source.buffer.length)
  ------------------
  |  Branch (95:9): [True: 72.2M, False: 8.46k]
  ------------------
   96|  72.2M|        return source->source.buffer.buffer[source->position];
   97|  8.46k|    else
   98|  8.46k|        return EOF;
   99|  72.2M|}