LLVMFuzzerTestOneInput:
   39|  5.02k|{
   40|  5.02k|	lt::error_code ec;
   41|  5.02k|	auto ret = lt::read_resume_data({reinterpret_cast<char const*>(data), int(size)}, ec);
   42|  5.02k|	auto buf = write_resume_data_buf(ret);
   43|  5.02k|	return 0;
   44|  5.02k|}

bdecode.cpp:_ZN10libtorrent3aux31uninitialized_default_constructIPNS_12_GLOBAL__N_111stack_frameEEEvT_S5_:
   47|  5.02k|{
   48|  5.02k|	using Value = typename std::iterator_traits<ForwardIt>::value_type;
   49|  5.02k|	ForwardIt current = first;
   50|  5.02k|	try {
   51|   507k|		for (; current != last; ++current) {
  ------------------
  |  Branch (51:10): [True: 502k, False: 5.02k]
  ------------------
   52|   502k|			::new (static_cast<void*>(std::addressof(*current))) Value;
   53|   502k|		}
   54|  5.02k|	}  catch (...) {
   55|      0|		for (; first != current; ++first) {
  ------------------
  |  Branch (55:10): [True: 0, False: 0]
  ------------------
   56|      0|			first->~Value();
   57|      0|		}
   58|      0|		throw;
   59|      0|	}
   60|  5.02k|}
bdecode.cpp:_ZN10libtorrent3aux17alloca_destructorINS_12_GLOBAL__N_111stack_frameEED2Ev:
   69|  5.02k|	{
   70|  5.02k|		if (objects.size() > cutoff)
  ------------------
  |  Branch (70:7): [True: 0, False: 5.02k]
  ------------------
   71|      0|		{
   72|      0|			delete [] objects.data();
   73|      0|		}
   74|  5.02k|		else
   75|  5.02k|		{
   76|  5.02k|			for (auto& o : objects)
  ------------------
  |  Branch (76:17): [True: 502k, False: 5.02k]
  ------------------
   77|   502k|			{
   78|   502k|				TORRENT_UNUSED(o);
  ------------------
  |  |  415|   502k|#define TORRENT_UNUSED(x) (void)(x)
  ------------------
   79|   502k|				o.~T();
   80|   502k|			}
   81|  5.02k|		}
   82|  5.02k|	}

_ZN10libtorrent3aux15host_to_networkEj:
   60|  19.9M|{ return htonl(x); }

_ZN10libtorrent3aux17container_wrapperINSt3__16vectorINS_8digest32ILl256EEENS2_9allocatorIS5_EEEENS0_14strong_typedefIiNS0_14file_index_tagEvEENS3_IS8_NS6_IS8_EEEEE7reserveIivEEvi:
  122|     62|		{
  123|     62|			TORRENT_ASSERT(s >= 0);
  ------------------
  |  |   95|     62|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|     62|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 62]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 62, False: 0]
  |  |  ------------------
  ------------------
  124|     62|			this->Base::reserve(std::size_t(s));
  125|     62|		}
_ZN10libtorrent3aux17container_wrapperINSt3__16vectorIbNS2_9allocatorIbEEEENS0_14strong_typedefIiNS0_14file_index_tagEvEENS3_IS6_NS4_IS6_EEEEE7reserveIivEEvi:
  122|    124|		{
  123|    124|			TORRENT_ASSERT(s >= 0);
  ------------------
  |  |   95|    124|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|    124|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 124]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 124, False: 0]
  |  |  ------------------
  ------------------
  124|    124|			this->Base::reserve(std::size_t(s));
  125|    124|		}
_ZN10libtorrent3aux17container_wrapperINS_14announce_entryEiNSt3__16vectorIS2_NS3_9allocatorIS2_EEEEEC2Ev:
   54|     98|		container_wrapper() = default;
_ZN10libtorrent3aux17container_wrapperINS_8digest32ILl160EEEiNSt3__16vectorIS3_NS4_9allocatorIS3_EEEEEC2Ev:
   54|     98|		container_wrapper() = default;
_ZN10libtorrent3aux17container_wrapperINS1_IciNSt3__16vectorIcNS2_9allocatorIcEEEEEENS0_14strong_typedefIiNS0_14file_index_tagEvEENS3_IS7_NS4_IS7_EEEEEC2Ev:
   54|     98|		container_wrapper() = default;
_ZN10libtorrent3aux17container_wrapperINSt3__16vectorINS_8digest32ILl256EEENS2_9allocatorIS5_EEEENS0_14strong_typedefIiNS0_14file_index_tagEvEENS3_IS8_NS6_IS8_EEEEEC2Ev:
   54|  5.02k|		container_wrapper() = default;
_ZN10libtorrent3aux17container_wrapperINSt3__16vectorIbNS2_9allocatorIbEEEENS0_14strong_typedefIiNS0_14file_index_tagEvEENS3_IS6_NS4_IS6_EEEEEC2Ev:
   54|  10.0k|		container_wrapper() = default;
_ZN10libtorrent3aux17container_wrapperINS0_10file_entryENS0_14strong_typedefIiNS0_14file_index_tagEvEENSt3__16vectorIS2_NS6_9allocatorIS2_EEEEEC2Ev:
   54|     98|		container_wrapper() = default;
_ZN10libtorrent3aux17container_wrapperIPKcNS0_14strong_typedefIiNS0_14file_index_tagEvEENSt3__16vectorIS3_NS7_9allocatorIS3_EEEEEC2Ev:
   54|     98|		container_wrapper() = default;
_ZN10libtorrent3aux17container_wrapperIlNS0_14strong_typedefIiNS0_14file_index_tagEvEENSt3__16vectorIlNS5_9allocatorIlEEEEEC2Ev:
   54|     98|		container_wrapper() = default;
_ZN10libtorrent3aux17container_wrapperINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS0_14strong_typedefIjNS0_14path_index_tagEvEENS2_6vectorIS8_NS6_IS8_EEEEEC2Ev:
   54|     98|		container_wrapper() = default;

_ZN10libtorrent3aux5is_v6IN5boost4asio2ip14basic_endpointINS4_3tcpEEEEEbRKT_:
   59|   127k|	{
   60|   127k|		return ep.protocol() == Endpoint::protocol_type::v6();
   61|   127k|	}

_ZN10libtorrent3aux16noexcept_movableINSt3__16vectorINS0_13bdecode_tokenENS2_9allocatorIS4_EEEEEC2Ev:
   59|  15.3M|		noexcept_movable() = default;
_ZN10libtorrent3aux16noexcept_movableINSt3__16vectorINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS7_IS9_EEEEEC2Ev:
   59|  15.0k|		noexcept_movable() = default;
_ZN10libtorrent3aux16noexcept_movableINSt3__16vectorIiNS2_9allocatorIiEEEEEC2Ev:
   59|  5.02k|		noexcept_movable() = default;
_ZN10libtorrent3aux16noexcept_movableINSt3__16vectorINS2_4pairINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEiEENS8_ISB_EEEEEC2Ev:
   59|  5.02k|		noexcept_movable() = default;
_ZN10libtorrent3aux16noexcept_movableINSt3__16vectorINS0_14strong_typedefIhNS_21download_priority_tagEvEENS2_9allocatorIS6_EEEEEC2Ev:
   59|  10.0k|		noexcept_movable() = default;
_ZN10libtorrent3aux16noexcept_movableINSt3__16vectorINS2_8functionIFNS2_10shared_ptrINS_14torrent_pluginEEERKNS_14torrent_handleENS_13client_data_tEEEENS2_9allocatorISD_EEEEEC2Ev:
   59|  5.02k|		noexcept_movable() = default;
_ZN10libtorrent3aux16noexcept_movableINSt3__16vectorIN5boost4asio2ip14basic_endpointINS6_3tcpEEENS2_9allocatorIS9_EEEEEC2Ev:
   59|  10.0k|		noexcept_movable() = default;
_ZN10libtorrent3aux16noexcept_movableINSt3__13mapINS0_14strong_typedefIiNS0_15piece_index_tagEvEENS_8bitfieldENS2_4lessIS6_EENS2_9allocatorINS2_4pairIKS6_S7_EEEEEEEC2Ev:
   59|  5.02k|		noexcept_movable() = default;
_ZN10libtorrent3aux16noexcept_movableINSt3__16vectorINS_8digest32ILl160EEENS2_9allocatorIS5_EEEEEC2Ev:
   59|  5.02k|		noexcept_movable() = default;
_ZN10libtorrent3aux16noexcept_movableINSt3__13mapINS0_14strong_typedefIiNS0_14file_index_tagEvEENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS2_4lessIS6_EENSA_INS2_4pairIKS6_SC_EEEEEEEC2Ev:
   59|  5.02k|		noexcept_movable() = default;
_ZN10libtorrent3aux16noexcept_movableINSt3__16vectorIcNS2_9allocatorIcEEEEEC2Ev:
   59|  5.02k|		noexcept_movable() = default;
_ZN10libtorrent3aux16noexcept_movableINSt3__16vectorINS0_13bdecode_tokenENS2_9allocatorIS4_EEEEEC2EOS8_:
   72|  2.38k|			: T(std::forward<T>(rhs)) {}

_ZN10libtorrent3aux12numeric_castImivEET_T0_:
   49|   602k|	{
   50|   602k|		T r = static_cast<T>(v);
   51|   602k|		TORRENT_ASSERT(v == static_cast<In>(r));
  ------------------
  |  |   95|   602k|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|   602k|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 602k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 602k, False: 0]
  |  |  ------------------
  ------------------
   52|   602k|		TORRENT_ASSERT(std::is_unsigned<In>::value || std::is_signed<T>::value
  ------------------
  |  |   95|  2.40M|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|   602k|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 602k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [Folded, False: 0]
  |  |  |  Branch (95:11): [Folded, False: 0]
  |  |  |  Branch (95:11): [True: 602k, False: 0]
  |  |  ------------------
  ------------------
   53|   602k|			|| std::int64_t(v) >= 0);
   54|   602k|		TORRENT_ASSERT(std::is_signed<In>::value || std::is_unsigned<T>::value
  ------------------
  |  |   95|  1.80M|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|   602k|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 602k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 602k, Folded]
  |  |  |  Branch (95:11): [True: 0, Folded]
  |  |  |  Branch (95:11): [True: 0, False: 0]
  |  |  ------------------
  ------------------
   55|   602k|			|| std::size_t(v) <= std::size_t((std::numeric_limits<T>::max)()));
   56|   602k|		return r;
   57|   602k|	}
_ZN10libtorrent3aux5clampIhEET_S2_S2_S2_:
   62|  7.66k|	{
   63|  7.66k|		TORRENT_ASSERT(lo <= hi);
  ------------------
  |  |   95|  7.66k|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|  7.66k|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 7.66k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 7.66k, False: 0]
  |  |  ------------------
  ------------------
   64|  7.66k|		if (v < lo) return lo;
  ------------------
  |  Branch (64:7): [True: 0, False: 7.66k]
  ------------------
   65|  7.66k|		if (hi < v) return hi;
  ------------------
  |  Branch (65:7): [True: 7.09k, False: 571]
  ------------------
   66|    571|		return v;
   67|  7.66k|	}
_ZN10libtorrent3aux5clampImEET_S2_S2_S2_:
   62|  3.38M|	{
   63|  3.38M|		TORRENT_ASSERT(lo <= hi);
  ------------------
  |  |   95|  3.38M|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|  3.38M|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 3.38M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 3.38M, False: 0]
  |  |  ------------------
  ------------------
   64|  3.38M|		if (v < lo) return lo;
  ------------------
  |  Branch (64:7): [True: 0, False: 3.38M]
  ------------------
   65|  3.38M|		if (hi < v) return hi;
  ------------------
  |  Branch (65:7): [True: 718k, False: 2.66M]
  ------------------
   66|  2.66M|		return v;
   67|  3.38M|	}
_ZN10libtorrent3aux12numeric_castIlivEET_T0_:
   49|  5.02k|	{
   50|  5.02k|		T r = static_cast<T>(v);
   51|  5.02k|		TORRENT_ASSERT(v == static_cast<In>(r));
  ------------------
  |  |   95|  5.02k|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|  5.02k|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 5.02k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 5.02k, False: 0]
  |  |  ------------------
  ------------------
   52|  5.02k|		TORRENT_ASSERT(std::is_unsigned<In>::value || std::is_signed<T>::value
  ------------------
  |  |   95|  15.0k|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|  5.02k|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 5.02k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [Folded, False: 0]
  |  |  |  Branch (95:11): [True: 0, Folded]
  |  |  |  Branch (95:11): [True: 0, False: 0]
  |  |  ------------------
  ------------------
   53|  5.02k|			|| std::int64_t(v) >= 0);
   54|  5.02k|		TORRENT_ASSERT(std::is_signed<In>::value || std::is_unsigned<T>::value
  ------------------
  |  |   95|  15.0k|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|  5.02k|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 5.02k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 5.02k, Folded]
  |  |  |  Branch (95:11): [Folded, False: 0]
  |  |  |  Branch (95:11): [True: 0, False: 0]
  |  |  ------------------
  ------------------
   55|  5.02k|			|| std::size_t(v) <= std::size_t((std::numeric_limits<T>::max)()));
   56|  5.02k|		return r;
   57|  5.02k|	}
_ZN10libtorrent3aux12numeric_castIjivEET_T0_:
   49|    432|	{
   50|    432|		T r = static_cast<T>(v);
   51|    432|		TORRENT_ASSERT(v == static_cast<In>(r));
  ------------------
  |  |   95|    432|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|    432|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 432]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 432, False: 0]
  |  |  ------------------
  ------------------
   52|    432|		TORRENT_ASSERT(std::is_unsigned<In>::value || std::is_signed<T>::value
  ------------------
  |  |   95|  1.72k|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|    432|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 432]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [Folded, False: 0]
  |  |  |  Branch (95:11): [Folded, False: 0]
  |  |  |  Branch (95:11): [True: 432, False: 0]
  |  |  ------------------
  ------------------
   53|    432|			|| std::int64_t(v) >= 0);
   54|    432|		TORRENT_ASSERT(std::is_signed<In>::value || std::is_unsigned<T>::value
  ------------------
  |  |   95|  1.29k|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|    432|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 432]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 432, Folded]
  |  |  |  Branch (95:11): [True: 0, Folded]
  |  |  |  Branch (95:11): [True: 0, False: 0]
  |  |  ------------------
  ------------------
   55|    432|			|| std::size_t(v) <= std::size_t((std::numeric_limits<T>::max)()));
   56|    432|		return r;
   57|    432|	}

_ZNK10libtorrent3aux12strview_lessclINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEES9_EEbRKT_RKT0_:
   47|  2.31M|		{ return rhs < lhs; }

_ZNK10libtorrent3aux10unique_ptrIA_jlEixEl:
   58|  12.9M|		{
   59|  12.9M|			TORRENT_ASSERT(idx >= IndexType(0));
  ------------------
  |  |   95|  12.9M|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|  12.9M|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 12.9M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 12.9M, False: 0]
  |  |  ------------------
  ------------------
   60|  12.9M|			return this->base::operator[](std::size_t(static_cast<underlying_index>(idx)));
   61|  12.9M|		}
_ZN10libtorrent3aux10unique_ptrIA_jlEC2Ev:
   54|  10.0k|		unique_ptr() = default;
_ZN10libtorrent3aux10unique_ptrIA_jlEC2EPj:
   55|    425|		explicit unique_ptr(T* arr) : base(arr) {}

_ZN10libtorrent3aux13bdecode_tokenC2ElNS1_6type_tE:
  188|  32.7M|		: offset(std::uint32_t(off))
  189|  32.7M|		, type(t)
  190|  32.7M|		, next_item(0)
  191|  32.7M|		, header(0)
  192|  32.7M|	{
  193|  32.7M|		TORRENT_ASSERT(off >= 0);
  ------------------
  |  |   95|  32.7M|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|  32.7M|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 32.7M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 32.7M, False: 0]
  |  |  ------------------
  ------------------
  194|  32.7M|		TORRENT_ASSERT(off <= max_offset);
  ------------------
  |  |   95|  32.7M|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|  32.7M|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 32.7M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 32.7M, False: 0]
  |  |  ------------------
  ------------------
  195|  32.7M|		TORRENT_ASSERT(t <= end);
  ------------------
  |  |   95|  32.7M|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|  32.7M|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 32.7M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 32.7M, False: 0]
  |  |  ------------------
  ------------------
  196|  32.7M|		static_assert(std::is_unsigned<std::underlying_type<bdecode_token::type_t>::type>::value
  197|  32.7M|			, "we need to assert t >= 0 here");
  198|  32.7M|	}
_ZN10libtorrent3aux13bdecode_tokenC2EljNS1_6type_tEj:
  202|  33.3M|		: offset(std::uint32_t(off))
  203|  33.3M|		, type(t == string && header_size > aux::bdecode_token::short_string_max_header ? long_string : t)
  ------------------
  |  Branch (203:10): [True: 668k, False: 32.7M]
  |  Branch (203:25): [True: 8.65k, False: 659k]
  ------------------
  204|  33.3M|		, next_item(next)
  205|  33.3M|		, header(type == string ? std::uint32_t(header_size - 2)
  ------------------
  |  Branch (205:12): [True: 659k, False: 32.7M]
  ------------------
  206|  33.3M|			: type == long_string ? std::uint32_t(header_size - 8 - 2) : 0)
  ------------------
  |  Branch (206:6): [True: 8.65k, False: 32.7M]
  ------------------
  207|  33.3M|	{
  208|  33.3M|		TORRENT_ASSERT((type != string && type != long_string) || header_size >= 2);
  ------------------
  |  |   95|   133M|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|  33.3M|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 33.3M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 32.7M, False: 659k]
  |  |  |  Branch (95:11): [True: 32.7M, False: 8.65k]
  |  |  |  Branch (95:11): [True: 668k, False: 0]
  |  |  ------------------
  ------------------
  209|  33.3M|		TORRENT_ASSERT(off >= 0);
  ------------------
  |  |   95|  33.3M|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|  33.3M|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 33.3M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 33.3M, False: 0]
  |  |  ------------------
  ------------------
  210|  33.3M|		TORRENT_ASSERT(off <= max_offset);
  ------------------
  |  |   95|  33.3M|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|  33.3M|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 33.3M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 33.3M, False: 0]
  |  |  ------------------
  ------------------
  211|  33.3M|		TORRENT_ASSERT(next <= max_next_item);
  ------------------
  |  |   95|  33.3M|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|  33.3M|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 33.3M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 33.3M, False: 0]
  |  |  ------------------
  ------------------
  212|       |		// the string has 2 implied header bytes, to allow for longer prefixes
  213|  33.3M|		TORRENT_ASSERT(header_size < 8
  ------------------
  |  |   95|   100M|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|  33.3M|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 33.3M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 9.40k, False: 8.65k]
  |  |  |  Branch (95:11): [True: 9.40k, False: 0]
  |  |  |  Branch (95:11): [True: 33.3M, False: 18.0k]
  |  |  |  Branch (95:11): [True: 8.65k, False: 0]
  |  |  |  Branch (95:11): [True: 8.65k, False: 0]
  |  |  ------------------
  ------------------
  214|  33.3M|			|| (type == string && header_size < 10)
  215|  33.3M|			|| (type == long_string && header_size < 18));
  216|  33.3M|		TORRENT_ASSERT(t <= end);
  ------------------
  |  |   95|  33.3M|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|  33.3M|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 33.3M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 33.3M, False: 0]
  |  |  ------------------
  ------------------
  217|  33.3M|		static_assert(std::is_unsigned<std::underlying_type<bdecode_token::type_t>::type>::value
  218|  33.3M|			, "we need to assert t >= 0 here");
  219|  33.3M|	}
_ZNK10libtorrent3aux13bdecode_token12start_offsetEv:
  222|  2.01M|	{
  223|  2.01M|		TORRENT_ASSERT(type == string || type == long_string);
  ------------------
  |  |   95|  4.13M|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|  2.01M|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 2.01M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 1.90M, False: 105k]
  |  |  |  Branch (95:11): [True: 105k, False: 0]
  |  |  ------------------
  ------------------
  224|  2.01M|		if (type == string)
  ------------------
  |  Branch (224:7): [True: 1.90M, False: 105k]
  ------------------
  225|  1.90M|			return int(header) + 2;
  226|   105k|		else
  227|   105k|			return int(header) + 8 + 2;
  228|  2.01M|	}
_ZN10libtorrent12bdecode_nodeC2Ev:
  290|   736k|	bdecode_node() = default;

_ZN10libtorrent7bencodeINSt3__120back_insert_iteratorINS1_6vectorIcNS1_9allocatorIcEEEEEEEEiT_RKNS_5entryE:
  375|  5.02k|	{
  376|  5.02k|		return aux::bencode_recursive(out, e);
  377|  5.02k|	}
_ZN10libtorrent3aux17bencode_recursiveINSt3__120back_insert_iteratorINS2_6vectorIcNS2_9allocatorIcEEEEEEEEiRT_RKNS_5entryE:
  142|  11.6M|	{
  143|  11.6M|		int ret = 0;
  144|  11.6M|		switch(e.type())
  ------------------
  |  Branch (144:10): [True: 11.6M, False: 0]
  ------------------
  145|  11.6M|		{
  146|   155k|		case entry::int_t:
  ------------------
  |  Branch (146:3): [True: 155k, False: 11.4M]
  ------------------
  147|   155k|			write_char(out, 'i');
  148|   155k|			ret += write_integer(out, e.integer());
  149|   155k|			write_char(out, 'e');
  150|   155k|			ret += 2;
  151|   155k|			break;
  152|  3.98M|		case entry::string_t:
  ------------------
  |  Branch (152:3): [True: 3.98M, False: 7.64M]
  ------------------
  153|  3.98M|			ret += write_integer(out, e.string().length());
  154|  3.98M|			write_char(out, ':');
  155|  3.98M|			ret += write_string(e.string(), out);
  156|  3.98M|			ret += 1;
  157|  3.98M|			break;
  158|  23.3k|		case entry::list_t:
  ------------------
  |  Branch (158:3): [True: 23.3k, False: 11.6M]
  ------------------
  159|  23.3k|			write_char(out, 'l');
  160|  23.3k|			for (auto const& i : e.list())
  ------------------
  |  Branch (160:23): [True: 11.4M, False: 23.3k]
  ------------------
  161|  11.4M|				ret += bencode_recursive(out, i);
  162|  23.3k|			write_char(out, 'e');
  163|  23.3k|			ret += 2;
  164|  23.3k|			break;
  165|  5.02k|		case entry::dictionary_t:
  ------------------
  |  Branch (165:3): [True: 5.02k, False: 11.6M]
  ------------------
  166|  5.02k|			write_char(out, 'd');
  167|  5.02k|			for (auto const& i : e.dict())
  ------------------
  |  Branch (167:23): [True: 206k, False: 5.02k]
  ------------------
  168|   206k|			{
  169|       |				// write key
  170|   206k|				ret += write_integer(out, i.first.length());
  171|   206k|				write_char(out, ':');
  172|   206k|				ret += write_string(i.first, out);
  173|       |				// write value
  174|   206k|				ret += bencode_recursive(out, i.second);
  175|   206k|				ret += 1;
  176|   206k|			}
  177|  5.02k|			write_char(out, 'e');
  178|  5.02k|			ret += 2;
  179|  5.02k|			break;
  180|     98|		case entry::preformatted_t:
  ------------------
  |  Branch (180:3): [True: 98, False: 11.6M]
  ------------------
  181|     98|			std::copy(e.preformatted().begin(), e.preformatted().end(), out);
  182|     98|			ret += static_cast<int>(e.preformatted().size());
  183|     98|			break;
  184|  7.46M|		case entry::undefined_t:
  ------------------
  |  Branch (184:3): [True: 7.46M, False: 4.16M]
  ------------------
  185|       |
  186|       |			// empty string
  187|  7.46M|			write_char(out, '0');
  188|  7.46M|			write_char(out, ':');
  189|       |
  190|  7.46M|			ret += 2;
  191|  7.46M|			break;
  192|  11.6M|		}
  193|  11.6M|		return ret;
  194|  11.6M|	}
_ZN10libtorrent3aux10write_charINSt3__120back_insert_iteratorINS2_6vectorIcNS2_9allocatorIcEEEEEEEEvRT_c:
   97|  19.4M|	{
   98|  19.4M|		*out = c;
   99|  19.4M|		++out;
  100|  19.4M|	}
_ZN10libtorrent3aux13write_integerINSt3__120back_insert_iteratorINS2_6vectorIcNS2_9allocatorIcEEEEEElvEEiRT_T0_:
   77|   155k|	{
   78|   155k|		entry::integer_type const val = entry::integer_type(data);
   79|   155k|		TORRENT_ASSERT(data == In(val));
  ------------------
  |  |   95|   155k|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|   155k|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 155k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 155k, False: 0]
  |  |  ------------------
  ------------------
   80|       |		// the stack allocated buffer for keeping the
   81|       |		// decimal representation of the number can
   82|       |		// not hold number bigger than this:
   83|   155k|		static_assert(sizeof(entry::integer_type) <= 8, "64 bit integers required");
   84|   155k|		static_assert(sizeof(data) <= sizeof(entry::integer_type), "input data too big, see entry::integer_type");
   85|   155k|		std::array<char, 21> buf;
   86|   155k|		auto const str = integer_to_str(buf, val);
   87|   155k|		for (char const c : str)
  ------------------
  |  Branch (87:21): [True: 194k, False: 155k]
  ------------------
   88|   194k|		{
   89|   194k|			*out = c;
   90|   194k|			++out;
   91|   194k|		}
   92|   155k|		return static_cast<int>(str.size());
   93|   155k|	}
_ZN10libtorrent3aux13write_integerINSt3__120back_insert_iteratorINS2_6vectorIcNS2_9allocatorIcEEEEEEmvEEiRT_T0_:
   77|  4.19M|	{
   78|  4.19M|		entry::integer_type const val = entry::integer_type(data);
   79|  4.19M|		TORRENT_ASSERT(data == In(val));
  ------------------
  |  |   95|  4.19M|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|  4.19M|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 4.19M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 4.19M, False: 0]
  |  |  ------------------
  ------------------
   80|       |		// the stack allocated buffer for keeping the
   81|       |		// decimal representation of the number can
   82|       |		// not hold number bigger than this:
   83|  4.19M|		static_assert(sizeof(entry::integer_type) <= 8, "64 bit integers required");
   84|  4.19M|		static_assert(sizeof(data) <= sizeof(entry::integer_type), "input data too big, see entry::integer_type");
   85|  4.19M|		std::array<char, 21> buf;
   86|  4.19M|		auto const str = integer_to_str(buf, val);
   87|  4.19M|		for (char const c : str)
  ------------------
  |  Branch (87:21): [True: 4.37M, False: 4.19M]
  ------------------
   88|  4.37M|		{
   89|  4.37M|			*out = c;
   90|  4.37M|			++out;
   91|  4.37M|		}
   92|  4.19M|		return static_cast<int>(str.size());
   93|  4.19M|	}

_ZN10libtorrent8bitfield6assignEPKci:
   72|    166|		{
   73|    166|			resize(bits);
   74|    166|			if (bits > 0)
  ------------------
  |  Branch (74:8): [True: 158, False: 8]
  ------------------
   75|    158|			{
   76|    158|				std::memcpy(buf(), b, std::size_t((bits + 7) / 8));
   77|    158|				clear_trailing_bits();
   78|    158|			}
   79|    166|		}
_ZN10libtorrent8bitfield9clear_bitEi:
   93|  3.31M|		{
   94|  3.31M|			TORRENT_ASSERT(index >= 0);
  ------------------
  |  |   95|  3.31M|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|  3.31M|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 3.31M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 3.31M, False: 0]
  |  |  ------------------
  ------------------
   95|  3.31M|			TORRENT_ASSERT(index < size());
  ------------------
  |  |   95|  3.31M|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|  3.31M|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 3.31M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 3.31M, False: 0]
  |  |  ------------------
  ------------------
   96|  3.31M|			buf()[index / 32] &= aux::host_to_network(~(0x80000000 >> (index & 31)));
   97|  3.31M|		}
_ZN10libtorrent8bitfield7set_bitEi:
   99|  1.87M|		{
  100|  1.87M|			TORRENT_ASSERT(index >= 0);
  ------------------
  |  |   95|  1.87M|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|  1.87M|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 1.87M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 1.87M, False: 0]
  |  |  ------------------
  ------------------
  101|  1.87M|			TORRENT_ASSERT(index < size());
  ------------------
  |  |   95|  1.87M|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|  1.87M|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 1.87M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 1.87M, False: 0]
  |  |  ------------------
  ------------------
  102|  1.87M|			buf()[index / 32] |= aux::host_to_network(0x80000000 >> (index & 31));
  103|  1.87M|		}
_ZNK10libtorrent8bitfield4sizeEv:
  124|  7.80M|		{
  125|  7.80M|			int const bits = m_buf == nullptr ? 0 : int(m_buf[0]);
  ------------------
  |  Branch (125:21): [True: 20.2k, False: 7.78M]
  ------------------
  126|  7.80M|			TORRENT_ASSERT(bits >= 0);
  ------------------
  |  |   95|  7.80M|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|  7.80M|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 7.80M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 7.80M, False: 0]
  |  |  ------------------
  ------------------
  127|  7.80M|			return bits;
  128|  7.80M|		}
_ZNK10libtorrent8bitfield9num_wordsEv:
  133|  1.26k|		{
  134|  1.26k|			return (size() + 31) / 32;
  135|  1.26k|		}
_ZN10libtorrent8bitfield14const_iteratordeEv:
  194|  14.7M|			bool operator*() noexcept { return (*buf & aux::host_to_network(bit)) != 0; }
_ZN10libtorrent8bitfield14const_iteratorppEv:
  195|  14.7M|			const_iterator& operator++() noexcept { inc(); return *this; }
_ZNK10libtorrent8bitfield14const_iteratorneERKS1_:
  207|  14.7M|			{ return buf != rhs.buf || bit != rhs.bit; }
  ------------------
  |  Branch (207:13): [True: 14.7M, False: 14.6k]
  |  Branch (207:31): [True: 4.64k, False: 10.0k]
  ------------------
_ZN10libtorrent8bitfield14const_iterator3incEv:
  211|  14.7M|			{
  212|  14.7M|				TORRENT_ASSERT(buf);
  ------------------
  |  |   95|  14.7M|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|  14.7M|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 14.7M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 14.7M, False: 0]
  |  |  ------------------
  ------------------
  213|  14.7M|				if (bit == 0x01)
  ------------------
  |  Branch (213:9): [True: 460k, False: 14.2M]
  ------------------
  214|   460k|				{
  215|   460k|					bit = 0x80000000;
  216|   460k|					++buf;
  217|   460k|				}
  218|  14.2M|				else
  219|  14.2M|				{
  220|  14.2M|					bit >>= 1;
  221|  14.2M|				}
  222|  14.7M|			}
_ZN10libtorrent8bitfield14const_iteratorC2EPKji:
  237|  20.0k|				: buf(ptr), bit(0x80000000 >> offset) {}
_ZNK10libtorrent8bitfield5beginEv:
  243|  10.0k|		const_iterator begin() const noexcept { return const_iterator(m_buf ? buf() : nullptr, 0); }
  ------------------
  |  Branch (243:65): [True: 365, False: 9.67k]
  ------------------
_ZNK10libtorrent8bitfield3endEv:
  245|  10.0k|		{
  246|  10.0k|			if (m_buf)
  ------------------
  |  Branch (246:8): [True: 365, False: 9.67k]
  ------------------
  247|    365|				return const_iterator(buf() + num_words() - (((size() & 31) == 0) ? 0 : 1), size() & 31);
  ------------------
  |  Branch (247:50): [True: 75, False: 290]
  ------------------
  248|  9.67k|			else
  249|  9.67k|				return const_iterator(nullptr, size() & 31);
  250|  10.0k|		}
_ZN10libtorrent8bitfield5clearEv:
  271|     44|		void clear() noexcept { m_buf.reset(); }
_ZNK10libtorrent8bitfield3bufEv:
  275|    730|		std::uint32_t const* buf() const noexcept { TORRENT_ASSERT(m_buf); return &m_buf[1]; }
  ------------------
  |  |   95|    730|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|    730|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 730]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 730, False: 0]
  |  |  ------------------
  ------------------
_ZN10libtorrent8bitfield3bufEv:
  276|  5.18M|		std::uint32_t* buf() noexcept { TORRENT_ASSERT(m_buf); return &m_buf[1]; }
  ------------------
  |  |   95|  5.18M|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|  5.18M|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 5.18M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 5.18M, False: 0]
  |  |  ------------------
  ------------------
_ZN10libtorrent8bitfield19clear_trailing_bitsEv:
  278|    590|		{
  279|       |			// clear the tail bits in the last byte
  280|    590|			if (size() & 31) buf()[num_words() - 1] &= aux::host_to_network(0xffffffff << (32 - (size() & 31)));
  ------------------
  |  Branch (280:8): [True: 465, False: 125]
  ------------------
  281|    590|		}
_ZNK10libtorrent14typed_bitfieldINS_3aux14strong_typedefIiNS1_15piece_index_tagEvEEE9end_indexEv:
  331|  2.59M|		IndexType end_index() const noexcept { return IndexType(this->size()); }
_ZN10libtorrent14typed_bitfieldINS_3aux14strong_typedefIiNS1_15piece_index_tagEvEEE7set_bitES4_:
  329|  1.87M|		{ this->bitfield::set_bit(static_cast<int>(index)); }
_ZN10libtorrent14typed_bitfieldINS_3aux14strong_typedefIiNS1_15piece_index_tagEvEEE9clear_bitES4_:
  326|  3.31M|		{ this->bitfield::clear_bit(static_cast<int>(index)); }
_ZN10libtorrent8bitfieldC2Ev:
   62|  10.0k|		bitfield() noexcept = default;
_ZN10libtorrent14typed_bitfieldINS_3aux14strong_typedefIiNS1_15piece_index_tagEvEEEC2Ev:
  291|  10.0k|		typed_bitfield() noexcept {}

_ZN10libtorrent13client_data_tC2Ev:
   47|  5.02k|	client_data_t() = default;

_ZN10libtorrent8copy_ptrIKNS_12file_storageEEC2Ev:
   44|     98|		copy_ptr() = default;

_ZN10libtorrent5entryC2INSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEvEET_:
  134|  3.88M|			: m_type(undefined_t)
  135|  3.88M|		{
  136|  3.88M|#if TORRENT_USE_ASSERTS
  137|  3.88M|			m_type_queried = true;
  138|  3.88M|#endif
  139|  3.88M|			new(&data) string_type(std::move(v));
  140|  3.88M|			m_type = string_t;
  141|  3.88M|		}
_ZNR10libtorrent5entryaSIPKcvEERS0_T_:
  176|  15.0k|		{
  177|  15.0k|			destruct();
  178|  15.0k|			new(&data) string_type(std::move(v));
  179|  15.0k|			m_type = string_t;
  180|  15.0k|#if TORRENT_USE_ASSERTS
  181|  15.0k|			m_type_queried = true;
  182|  15.0k|#endif
  183|  15.0k|			return *this;
  184|  15.0k|		}
_ZNR10libtorrent5entryaSINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEvEERS0_T_:
  176|  66.8k|		{
  177|  66.8k|			destruct();
  178|  66.8k|			new(&data) string_type(std::move(v));
  179|  66.8k|			m_type = string_t;
  180|  66.8k|#if TORRENT_USE_ASSERTS
  181|  66.8k|			m_type_queried = true;
  182|  66.8k|#endif
  183|  66.8k|			return *this;
  184|  66.8k|		}

_ZN10libtorrent5flagsanENS0_13bitfield_flagImNS_17torrent_flags_tagEvEES3_:
  109|   111k|	{
  110|   111k|		return bitfield_flag(lhs.m_val & rhs.m_val);
  111|   111k|	}
_ZN10libtorrent5flags13bitfield_flagImNS_17torrent_flags_tagEvEC2Em:
   65|   150k|	explicit constexpr bitfield_flag(UnderlyingType const val) noexcept : m_val(val) {}
_ZNK10libtorrent5flags13bitfield_flagImNS_17torrent_flags_tagEvEcvbEv:
   72|   111k|	explicit constexpr operator bool() const noexcept { return m_val != 0; }
_ZNK10libtorrent5flags13bitfield_flagImNS_17torrent_flags_tagEvEcoEv:
  119|  38.7k|	{
  120|       |		// technically, m_val is promoted to int before applying operator~, which
  121|       |		// means the result may not fit into the underlying type again. So,
  122|       |		// explicitly cast it
  123|  38.7k|		return bitfield_flag(static_cast<UnderlyingType>(~m_val));
  124|  38.7k|	}
_ZNR10libtorrent5flags13bitfield_flagImNS_17torrent_flags_tagEvEaNES3_:
   92|  38.7k|	{
   93|  38.7k|		m_val &= f.m_val;
   94|  38.7k|		return *this;
   95|  38.7k|	}
_ZNR10libtorrent5flags13bitfield_flagImNS_17torrent_flags_tagEvEoRES3_:
   86|  12.8k|	{
   87|  12.8k|		m_val |= f.m_val;
   88|  12.8k|		return *this;
   89|  12.8k|	}
_ZN10libtorrent5flags13bitfield_flagIhNS_22torrent_info_flags_tagEvEC2Ev:
   64|     98|	constexpr bitfield_flag() noexcept : m_val(0) {}

_ZN10libtorrent11info_hash_tC2ENS_8digest32ILl160EEENS1_ILl256EEE:
   87|    216|			: v1(h1), v2(h2) {}
_ZNK10libtorrent11info_hash_t6has_v1Ev:
   95|    216|		bool has_v1() const { return !v1.is_all_zeros(); }
_ZNK10libtorrent11info_hash_t6has_v2Ev:
   96|  3.73k|		bool has_v2() const { return !v2.is_all_zeros(); }
_ZNK10libtorrent11info_hash_t3getENS_16protocol_versionE:
  105|    114|		{
  106|    114|			TORRENT_ASSERT(v != protocol_version::NUM);
  ------------------
  |  |   95|    114|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|    114|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 114]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 114, False: 0]
  |  |  ------------------
  ------------------
  107|    114|			return v == protocol_version::V1 ? v1 : sha1_hash(v2.data());
  ------------------
  |  Branch (107:11): [True: 0, False: 114]
  ------------------
  108|    114|		}
_ZNK10libtorrent11info_hash_t8get_bestEv:
  113|  3.58k|		{
  114|  3.58k|			return has_v2() ? get(protocol_version::V2) : v1;
  ------------------
  |  Branch (114:11): [True: 114, False: 3.46k]
  ------------------
  115|  3.58k|		}
_ZN10libtorrent11info_hash_tC2Ev:
   83|  5.02k|		info_hash_t() noexcept = default;

_ZN10libtorrent3aux11read_uint32IPKcEEjRT_:
  118|   109k|	{ return read_impl(start, type<std::uint32_t>()); }
_ZN10libtorrent3aux9read_implIjPKcEET_RT0_NS0_4typeIS4_EE:
   55|   109k|	{
   56|   109k|		T ret = 0;
   57|   545k|		for (int i = 0; i < int(sizeof(T)); ++i)
  ------------------
  |  Branch (57:19): [True: 436k, False: 109k]
  ------------------
   58|   436k|		{
   59|   436k|			ret <<= 8;
   60|   436k|			ret |= static_cast<std::uint8_t>(*start);
   61|   436k|			++start;
   62|   436k|		}
   63|   109k|		return ret;
   64|   109k|	}
_ZN10libtorrent3aux11read_uint16IPKcEEtRT_:
  130|   127k|	{ return read_impl(start, type<std::uint16_t>()); }
_ZN10libtorrent3aux9read_implItPKcEET_RT0_NS0_4typeIS4_EE:
   55|   127k|	{
   56|   127k|		T ret = 0;
   57|   383k|		for (int i = 0; i < int(sizeof(T)); ++i)
  ------------------
  |  Branch (57:19): [True: 255k, False: 127k]
  ------------------
   58|   255k|		{
   59|   255k|			ret <<= 8;
   60|   255k|			ret |= static_cast<std::uint8_t>(*start);
   61|   255k|			++start;
   62|   255k|		}
   63|   127k|		return ret;
   64|   127k|	}
_ZN10libtorrent3aux10read_uint8IPKcEEhRT_:
  138|   302k|	{ return read_impl(start, type<std::uint8_t>()); }
_ZN10libtorrent3aux9read_implIPKcEEhRT_NS0_4typeIhEE:
   68|   302k|	{
   69|   302k|		return static_cast<std::uint8_t>(*start++);
   70|   302k|	}
_ZN10libtorrent3aux12write_uint32IjNSt3__120back_insert_iteratorINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEvT_RT0_:
  151|   109k|	{ write_impl<std::uint32_t>(val, start); }
_ZN10libtorrent3aux10write_implIjjNSt3__120back_insert_iteratorINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEENS2_9enable_ifIXooaasr3std11is_integralIT0_EE5valuentsr3std7is_sameISC_bEE5valuesr3std7is_enumISC_EE5valueEvE4typeESC_RT1_:
   83|   109k|	{
   84|       |		// Note: the test for [OutItT==void] below is necessary because
   85|       |		// in C++11 std::back_insert_iterator::value_type is void.
   86|       |		// This could change in C++17 or above
   87|   109k|		using OutItT = typename std::iterator_traits<OutIt>::value_type;
   88|   109k|		using Byte = typename std::conditional<
   89|   109k|			std::is_same<OutItT, void>::value, char, OutItT>::type;
   90|   109k|		static_assert(sizeof(Byte) == 1, "wrong iterator or pointer type");
   91|       |
   92|   109k|		T val = static_cast<T>(data);
   93|   109k|		TORRENT_ASSERT(data == static_cast<In>(val));
  ------------------
  |  |   95|   109k|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|   109k|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 109k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 109k, False: 0]
  |  |  ------------------
  ------------------
   94|   545k|		for (int i = int(sizeof(T)) - 1; i >= 0; --i)
  ------------------
  |  Branch (94:36): [True: 436k, False: 109k]
  ------------------
   95|   436k|		{
   96|   436k|			*start = static_cast<Byte>((val >> (i * 8)) & 0xff);
   97|   436k|			++start;
   98|   436k|		}
   99|   109k|	}
_ZN10libtorrent3aux11write_uint8IhNSt3__120back_insert_iteratorINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEvT_RT0_:
  167|   302k|	{ write_impl<std::uint8_t>(val, start); }
_ZN10libtorrent3aux10write_implIhhNSt3__120back_insert_iteratorINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEENS2_9enable_ifIXooaasr3std11is_integralIT0_EE5valuentsr3std7is_sameISC_bEE5valuesr3std7is_enumISC_EE5valueEvE4typeESC_RT1_:
   83|   302k|	{
   84|       |		// Note: the test for [OutItT==void] below is necessary because
   85|       |		// in C++11 std::back_insert_iterator::value_type is void.
   86|       |		// This could change in C++17 or above
   87|   302k|		using OutItT = typename std::iterator_traits<OutIt>::value_type;
   88|   302k|		using Byte = typename std::conditional<
   89|   302k|			std::is_same<OutItT, void>::value, char, OutItT>::type;
   90|   302k|		static_assert(sizeof(Byte) == 1, "wrong iterator or pointer type");
   91|       |
   92|   302k|		T val = static_cast<T>(data);
   93|   302k|		TORRENT_ASSERT(data == static_cast<In>(val));
  ------------------
  |  |   95|   302k|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|   302k|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 302k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 302k, False: 0]
  |  |  ------------------
  ------------------
   94|   604k|		for (int i = int(sizeof(T)) - 1; i >= 0; --i)
  ------------------
  |  Branch (94:36): [True: 302k, False: 302k]
  ------------------
   95|   302k|		{
   96|   302k|			*start = static_cast<Byte>((val >> (i * 8)) & 0xff);
   97|   302k|			++start;
   98|   302k|		}
   99|   302k|	}
_ZN10libtorrent3aux12write_uint16ItNSt3__120back_insert_iteratorINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEvT_RT0_:
  159|   127k|	{ write_impl<std::uint16_t>(val, start); }
_ZN10libtorrent3aux10write_implIttNSt3__120back_insert_iteratorINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEENS2_9enable_ifIXooaasr3std11is_integralIT0_EE5valuentsr3std7is_sameISC_bEE5valuesr3std7is_enumISC_EE5valueEvE4typeESC_RT1_:
   83|   127k|	{
   84|       |		// Note: the test for [OutItT==void] below is necessary because
   85|       |		// in C++11 std::back_insert_iterator::value_type is void.
   86|       |		// This could change in C++17 or above
   87|   127k|		using OutItT = typename std::iterator_traits<OutIt>::value_type;
   88|   127k|		using Byte = typename std::conditional<
   89|   127k|			std::is_same<OutItT, void>::value, char, OutItT>::type;
   90|   127k|		static_assert(sizeof(Byte) == 1, "wrong iterator or pointer type");
   91|       |
   92|   127k|		T val = static_cast<T>(data);
   93|   127k|		TORRENT_ASSERT(data == static_cast<In>(val));
  ------------------
  |  |   95|   127k|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|   127k|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 127k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 127k, False: 0]
  |  |  ------------------
  ------------------
   94|   383k|		for (int i = int(sizeof(T)) - 1; i >= 0; --i)
  ------------------
  |  Branch (94:36): [True: 255k, False: 127k]
  ------------------
   95|   255k|		{
   96|   255k|			*start = static_cast<Byte>((val >> (i * 8)) & 0xff);
   97|   255k|			++start;
   98|   255k|		}
   99|   127k|	}
_ZN10libtorrent3aux12write_stringINSt3__120back_insert_iteratorINS2_6vectorIcNS2_9allocatorIcEEEEEEEEiRKNS2_12basic_stringIcNS2_11char_traitsIcEES6_EERT_:
  182|  4.19M|	{
  183|  29.3M|		for (auto const c : val) *out++ = c;
  ------------------
  |  Branch (183:21): [True: 29.3M, False: 4.19M]
  ------------------
  184|  4.19M|		return int(val.length());
  185|  4.19M|	}

_ZN10libtorrent11piece_blockC2ENS_3aux14strong_typedefIiNS1_15piece_index_tagEvEEi:
   48|      2|			: piece_index(p_index)
   49|      2|			, block_index(b_index)
   50|      2|		{
   51|      2|		}

_ZN10libtorrent8digest32ILl256EE5clearEv:
  138|  5.43k|		void clear() noexcept { m_number.fill(0); }
_ZN10libtorrent8digest32ILl160EE5clearEv:
  138|  10.3k|		void clear() noexcept { m_number.fill(0); }
_ZNK10libtorrent8digest32ILl160EE12is_all_zerosEv:
  142|    216|		{
  143|    216|			return std::all_of(m_number.begin(), m_number.end()
  144|    216|				, [](std::uint32_t v) { return v == 0; });
  145|    216|		}
_ZNK10libtorrent8digest32ILl256EE12is_all_zerosEv:
  142|  3.73k|		{
  143|  3.73k|			return std::all_of(m_number.begin(), m_number.end()
  144|  3.73k|				, [](std::uint32_t v) { return v == 0; });
  145|  3.73k|		}
_ZNK10libtorrent8digest32ILl256EE4dataEv:
  134|  5.13k|		char const* data() const noexcept { return reinterpret_cast<char const*>(m_number.data()); }
_ZN10libtorrent8digest32ILl160EE4sizeEv:
   79|  12.2k|		static constexpr difference_type size() noexcept { return N / bits_in_byte; }
_ZNK10libtorrent8digest32ILl160EEeqERKS1_:
  153|     63|		{
  154|     63|			return std::equal(n.m_number.begin(), n.m_number.end(), m_number.begin());
  155|     63|		}
_ZNK10libtorrent8digest32ILl256EEeqERKS1_:
  153|     55|		{
  154|     55|			return std::equal(n.m_number.begin(), n.m_number.end(), m_number.begin());
  155|     55|		}
_ZNK10libtorrent8digest32ILl160EE4dataEv:
  134|  5.02k|		char const* data() const noexcept { return reinterpret_cast<char const*>(m_number.data()); }
_ZN10libtorrent8digest32ILl256EE4sizeEv:
   79|  5.28k|		static constexpr difference_type size() noexcept { return N / bits_in_byte; }
_ZZNK10libtorrent8digest32ILl160EE12is_all_zerosEvENKUljE_clEj:
  144|    846|				, [](std::uint32_t v) { return v == 0; });
_ZZNK10libtorrent8digest32ILl256EE12is_all_zerosEvENKUljE_clEj:
  144|  28.7k|				, [](std::uint32_t v) { return v == 0; });
_ZN10libtorrent8digest32ILl160EEC2EPKc:
  111|    114|		{
  112|    114|			if (s == nullptr) clear();
  ------------------
  |  Branch (112:8): [True: 0, False: 114]
  ------------------
  113|    114|			else std::memcpy(m_number.data(), s, size());
  114|    114|		}
_ZN10libtorrent8digest32ILl160EE6assignEPKc:
  132|  3.47k|		void assign(char const* str) noexcept { std::memcpy(m_number.data(), str, size()); }
_ZN10libtorrent8digest32ILl256EE6assignEPKc:
  132|    114|		void assign(char const* str) noexcept { std::memcpy(m_number.data(), str, size()); }
_ZN10libtorrent8digest32ILl160EEC2Ev:
   82|  10.3k|		digest32() noexcept { clear(); }
_ZN10libtorrent8digest32ILl256EEC2Ev:
   82|  5.33k|		digest32() noexcept { clear(); }
_ZN10libtorrent8digest32ILl160EE4dataEv:
  135|    314|		char* data() noexcept { return reinterpret_cast<char*>(m_number.data()); }
_ZN10libtorrent8digest32ILl256EE4dataEv:
  135|    314|		char* data() noexcept { return reinterpret_cast<char*>(m_number.data()); }

_ZN10libtorrent3aux16read_v4_endpointIN5boost4asio2ip14basic_endpointINS4_3tcpEEERPKcEET_OT0_:
  110|   109k|		{
  111|   109k|			address addr = read_v4_address(in);
  112|   109k|			std::uint16_t port = read_uint16(in);
  113|   109k|			return Endpoint(addr, port);
  114|   109k|		}
_ZN10libtorrent3aux15read_v4_addressIRPKcEEN5boost4asio2ip10address_v4EOT_:
   87|   109k|		{
   88|   109k|			std::uint32_t const ip = read_uint32(in);
   89|   109k|			return address_v4(ip);
   90|   109k|		}
_ZN10libtorrent3aux16read_v6_endpointIN5boost4asio2ip14basic_endpointINS4_3tcpEEERPKcEET_OT0_:
  118|  18.9k|		{
  119|  18.9k|			address addr = read_v6_address(in);
  120|  18.9k|			std::uint16_t port = read_uint16(in);
  121|  18.9k|			return Endpoint(addr, port);
  122|  18.9k|		}
_ZN10libtorrent3aux15read_v6_addressIRPKcEEN5boost4asio2ip10address_v6EOT_:
   94|  18.9k|		{
   95|  18.9k|			address_v6::bytes_type bytes;
   96|  18.9k|			for (auto& b : bytes)
  ------------------
  |  Branch (96:17): [True: 302k, False: 18.9k]
  ------------------
   97|   302k|				b = read_uint8(in);
   98|  18.9k|			return address_v6(bytes);
   99|  18.9k|		}
_ZN10libtorrent3aux14write_endpointIN5boost4asio2ip14basic_endpointINS4_3tcpEEERNSt3__120back_insert_iteratorINS8_12basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEEEEEEvRKT_OT0_:
  103|   127k|		{
  104|   127k|			write_address(e.address(), out);
  105|   127k|			write_uint16(e.port(), out);
  106|   127k|		}
_ZN10libtorrent3aux13write_addressIRNSt3__120back_insert_iteratorINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEvRKN5boost4asio2ip7addressEOT_:
   73|   127k|		{
   74|   127k|			if (a.is_v4())
  ------------------
  |  Branch (74:8): [True: 109k, False: 18.9k]
  ------------------
   75|   109k|			{
   76|   109k|				write_uint32(a.to_v4().to_uint(), out);
   77|   109k|			}
   78|  18.9k|			else if (a.is_v6())
  ------------------
  |  Branch (78:13): [True: 18.9k, False: 0]
  ------------------
   79|  18.9k|			{
   80|  18.9k|				for (auto b : a.to_v6().to_bytes())
  ------------------
  |  Branch (80:17): [True: 302k, False: 18.9k]
  ------------------
   81|   302k|					write_uint8(b, out);
   82|  18.9k|			}
   83|   127k|		}

_ZN10libtorrent4spanIKcEC2EPS1_l:
   82|  5.74k|		span(T* p, difference_type const l) noexcept : m_ptr(p), m_len(l) // NOLINT
   83|  5.74k|		{ TORRENT_ASSERT(l >= 0); }
  ------------------
  |  |   95|  5.74k|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|  5.74k|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 5.74k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 5.74k, False: 0]
  |  |  ------------------
  ------------------
_ZNK10libtorrent4spanIKcE4sizeEv:
  124|  27.2k|		index_type size() const noexcept { return m_len; }
_ZNK10libtorrent4spanIKcE4dataEv:
  126|  21.8k|		T* data() const noexcept { return m_ptr; }
_ZN10libtorrent4spanIKcEC2IS2_S1_vEERT_:
  104|  5.84k|			: m_ptr(c.data()), m_len(static_cast<difference_type>(c.size())) {}
_ZN10libtorrent4spanIKcEC2INS_8digest32ILl160EEEcvEERKT_:
  113|  5.02k|			: m_ptr(c.data()), m_len(static_cast<difference_type>(c.size())) {}
_ZN10libtorrent4spanIKcEC2INS_8digest32ILl256EEEcvEERKT_:
  113|  5.02k|			: m_ptr(c.data()), m_len(static_cast<difference_type>(c.size())) {}
_ZNK10libtorrent4spanIKcE5emptyEv:
  125|    412|		bool empty() const noexcept { return m_len == 0; }
_ZNK10libtorrent4spanIKcEixEl:
  168|    196|		{
  169|    196|			TORRENT_ASSERT(idx < m_len);
  ------------------
  |  |   95|    196|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|    196|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 196]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 196, False: 0]
  |  |  ------------------
  ------------------
  170|    196|			TORRENT_ASSERT(idx >= 0);
  ------------------
  |  |   95|    196|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|    196|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 196]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 196, False: 0]
  |  |  ------------------
  ------------------
  171|    196|			return m_ptr[idx];
  172|    196|		}
bdecode.cpp:_ZN10libtorrent4spanINS_12_GLOBAL__N_111stack_frameEEC2Ev:
   74|  5.02k|		span() noexcept : m_ptr(nullptr), m_len(0) {}
bdecode.cpp:_ZN10libtorrent4spanINS_12_GLOBAL__N_111stack_frameEEC2EPS2_l:
   82|  5.02k|		span(T* p, difference_type const l) noexcept : m_ptr(p), m_len(l) // NOLINT
   83|  5.02k|		{ TORRENT_ASSERT(l >= 0); }
  ------------------
  |  |   95|  5.02k|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|  5.02k|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 5.02k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 5.02k, False: 0]
  |  |  ------------------
  ------------------
bdecode.cpp:_ZNK10libtorrent4spanINS_12_GLOBAL__N_111stack_frameEE5beginEv:
  133|  10.0k|		T* begin() const noexcept { return m_ptr; }
bdecode.cpp:_ZNK10libtorrent4spanINS_12_GLOBAL__N_111stack_frameEE3endEv:
  134|  10.0k|		T* end() const noexcept { return m_ptr + m_len; }
bdecode.cpp:_ZN10libtorrent4spanINS_12_GLOBAL__N_111stack_frameEEC2IS3_S2_vEERT_:
  104|  5.02k|			: m_ptr(c.data()), m_len(static_cast<difference_type>(c.size())) {}
bdecode.cpp:_ZNK10libtorrent4spanINS_12_GLOBAL__N_111stack_frameEE4dataEv:
  126|  5.02k|		T* data() const noexcept { return m_ptr; }
bdecode.cpp:_ZNK10libtorrent4spanINS_12_GLOBAL__N_111stack_frameEE4sizeEv:
  124|  10.0k|		index_type size() const noexcept { return m_len; }
bdecode.cpp:_ZNK10libtorrent4spanINS_12_GLOBAL__N_111stack_frameEEixEl:
  168|   320M|		{
  169|   320M|			TORRENT_ASSERT(idx < m_len);
  ------------------
  |  |   95|   320M|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|   320M|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 320M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 320M, False: 0]
  |  |  ------------------
  ------------------
  170|   320M|			TORRENT_ASSERT(idx >= 0);
  ------------------
  |  |   95|   320M|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|   320M|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 320M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 320M, False: 0]
  |  |  ------------------
  ------------------
  171|   320M|			return m_ptr[idx];
  172|   320M|		}

_ZN10libtorrent8is_digitEc:
   60|  13.8k|	{ return c >= '0' && c <= '9'; }
  ------------------
  |  Branch (60:11): [True: 13.3k, False: 466]
  |  Branch (60:23): [True: 12.9k, False: 422]
  ------------------

_ZNK10libtorrent12torrent_info13creation_dateEv:
  568|     98|		{ return m_creation_date; }
_ZNK10libtorrent12torrent_info7creatorEv:
  573|     98|		{ return m_created_by; }
_ZNK10libtorrent12torrent_info7commentEv:
  579|     98|		{ return m_comment; }
_ZNK10libtorrent12torrent_info12info_sectionEv:
  616|     98|		{ return span<char const>(m_info_section.get(), m_info_section_size); }

_ZNK10libtorrent3aux14strong_typedefIiNS0_14file_index_tagEvEcviEv:
   73|  4.86M|		constexpr operator UnderlyingType() const { return m_val; }
_ZNK10libtorrent3aux14strong_typedefIiNS0_15piece_index_tagEvEcviEv:
   73|  16.5M|		constexpr operator UnderlyingType() const { return m_val; }
_ZN10libtorrent3aux14strong_typedefIiNS0_14file_index_tagEvEC2Ei:
   72|  61.7k|		constexpr strong_typedef(UnderlyingType val) : m_val(val) {}
_ZNK10libtorrent3aux14strong_typedefIhNS_21download_priority_tagEvEcvhEv:
   73|  22.9k|		constexpr operator UnderlyingType() const { return m_val; }
_ZN10libtorrent3aux14strong_typedefIhNS_21download_priority_tagEvEC2Eh:
   72|  7.66k|		constexpr strong_typedef(UnderlyingType val) : m_val(val) {}
_ZN10libtorrent3aux14strong_typedefIiNS0_15piece_index_tagEvEC2Ei:
   72|  3.58M|		constexpr strong_typedef(UnderlyingType val) : m_val(val) {}
_ZN10libtorrent3aux14strong_typedefIiNS0_15piece_index_tagEvEppEv:
   84|  2.59M|		strong_typedef& operator++() { ++m_val; return *this; }
_ZNSt3__114numeric_limitsIN10libtorrent3aux14strong_typedefIiNS2_15piece_index_tagEvEEE3maxEv:
  167|      2|		{ return type((std::numeric_limits<UnderlyingType>::max)()); }

_ZN10libtorrent18add_torrent_paramsC2Ev:
   38|  5.02k|	add_torrent_params::add_torrent_params() = default;
_ZN10libtorrent18add_torrent_paramsD2Ev:
   39|  5.02k|	add_torrent_params::~add_torrent_params() = default;

_ZN10libtorrent9parse_intEPKcS1_cRlRNS_14bdecode_errors15error_code_enumE:
  163|   670k|	{
  164|   670k|		TORRENT_ASSERT(val >= 0);
  ------------------
  |  |   95|   670k|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|   670k|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 670k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 670k, False: 0]
  |  |  ------------------
  ------------------
  165|  5.28M|		while (start < end && *start != delimiter)
  ------------------
  |  Branch (165:10): [True: 5.28M, False: 146]
  |  Branch (165:25): [True: 4.61M, False: 670k]
  ------------------
  166|  4.61M|		{
  167|  4.61M|			char const c = *start;
  168|  4.61M|			if (!numeric(c))
  ------------------
  |  Branch (168:8): [True: 22, False: 4.61M]
  ------------------
  169|     22|			{
  170|     22|				ec = bdecode_errors::expected_digit;
  171|     22|				return start;
  172|     22|			}
  173|  4.61M|			if (val > std::numeric_limits<std::int64_t>::max() / 10)
  ------------------
  |  Branch (173:8): [True: 19, False: 4.61M]
  ------------------
  174|     19|			{
  175|     19|				ec = bdecode_errors::overflow;
  176|     19|				return start;
  177|     19|			}
  178|  4.61M|			val *= 10;
  179|  4.61M|			int const digit = c - '0';
  180|  4.61M|			if (val > std::numeric_limits<std::int64_t>::max() - digit)
  ------------------
  |  Branch (180:8): [True: 7, False: 4.61M]
  ------------------
  181|      7|			{
  182|      7|				ec = bdecode_errors::overflow;
  183|      7|				return start;
  184|      7|			}
  185|  4.61M|			val += digit;
  186|  4.61M|			++start;
  187|  4.61M|		}
  188|   670k|		return start;
  189|   670k|	}
_ZN10libtorrent16bdecode_categoryEv:
  225|    846|	{
  226|    846|		static bdecode_error_category bdecode_category;
  227|    846|		return bdecode_category;
  228|    846|	}
_ZN10libtorrent14bdecode_errors15make_error_codeENS0_15error_code_enumE:
  233|    846|		{
  234|    846|			return {e, bdecode_category()};
  235|    846|		}
_ZN10libtorrent12bdecode_nodeC2EOS0_:
  271|  2.38k|	bdecode_node::bdecode_node(bdecode_node&&) noexcept = default;
_ZN10libtorrent12bdecode_nodeC2EPKNS_3aux13bdecode_tokenEPKcii:
  275|  14.5M|		: m_root_tokens(tokens)
  276|  14.5M|		, m_buffer(buf)
  277|  14.5M|		, m_buffer_size(len)
  278|  14.5M|		, m_token_idx(idx)
  279|  14.5M|	{
  280|  14.5M|		TORRENT_ASSERT(tokens != nullptr);
  ------------------
  |  |   95|  14.5M|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|  14.5M|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 14.5M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 14.5M, False: 0]
  |  |  ------------------
  ------------------
  281|  14.5M|		TORRENT_ASSERT(idx >= 0);
  ------------------
  |  |   95|  14.5M|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|  14.5M|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 14.5M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 14.5M, False: 0]
  |  |  ------------------
  ------------------
  282|  14.5M|	}
_ZNK10libtorrent12bdecode_node4typeEv:
  403|  46.8M|	{
  404|  46.8M|		if (m_token_idx == -1) return none_t;
  ------------------
  |  Branch (404:7): [True: 676k, False: 46.2M]
  ------------------
  405|  46.2M|		if (m_root_tokens[m_token_idx].type == bdecode_token::long_string)
  ------------------
  |  Branch (405:7): [True: 95.9k, False: 46.1M]
  ------------------
  406|  95.9k|			return bdecode_node::string_t;
  407|  46.1M|		return static_cast<bdecode_node::type_t>(m_root_tokens[m_token_idx].type);
  408|  46.2M|	}
_ZNK10libtorrent12bdecode_nodecvbEv:
  411|  1.69M|	{ return m_token_idx != -1; }
_ZNK10libtorrent12bdecode_node12data_sectionEv:
  414|    628|	{
  415|    628|		if (m_token_idx == -1) return {};
  ------------------
  |  Branch (415:7): [True: 0, False: 628]
  ------------------
  416|       |
  417|    628|		TORRENT_ASSERT(m_token_idx != -1);
  ------------------
  |  |   95|    628|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|    628|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 628]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 628, False: 0]
  |  |  ------------------
  ------------------
  418|    628|		bdecode_token const& t = m_root_tokens[m_token_idx];
  419|    628|		bdecode_token const& next = m_root_tokens[m_token_idx + t.next_item];
  420|    628|		return {m_buffer + t.offset, static_cast<std::ptrdiff_t>(next.offset - t.offset)};
  421|    628|	}
_ZNK10libtorrent12bdecode_node11data_offsetEv:
  424|     98|	{
  425|     98|		TORRENT_ASSERT_PRECOND(m_token_idx != -1);
  ------------------
  |  |   92|     98|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 1); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|     98|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 98]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (92:11): [True: 98, False: 0]
  |  |  ------------------
  ------------------
  426|     98|		if (m_token_idx == -1) return -1;
  ------------------
  |  Branch (426:7): [True: 0, False: 98]
  ------------------
  427|     98|		bdecode_token const& t = m_root_tokens[m_token_idx];
  428|     98|		return t.offset;
  429|     98|	}
_ZNK10libtorrent12bdecode_node7list_atEi:
  432|  14.5M|	{
  433|  14.5M|		TORRENT_ASSERT(type() == list_t);
  ------------------
  |  |   95|  14.5M|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|  14.5M|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 14.5M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 14.5M, False: 0]
  |  |  ------------------
  ------------------
  434|  14.5M|		TORRENT_ASSERT(i >= 0);
  ------------------
  |  |   95|  14.5M|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|  14.5M|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 14.5M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 14.5M, False: 0]
  |  |  ------------------
  ------------------
  435|       |
  436|       |		// make sure this is a list.
  437|  14.5M|		bdecode_token const* tokens = m_root_tokens;
  438|       |
  439|       |		// this is the first item
  440|  14.5M|		int token = m_token_idx + 1;
  441|  14.5M|		int item = 0;
  442|       |
  443|       |		// do we have a lookup cached?
  444|  14.5M|		if (m_last_index <= i && m_last_index != -1)
  ------------------
  |  Branch (444:7): [True: 14.5M, False: 0]
  |  Branch (444:28): [True: 14.5M, False: 13.5k]
  ------------------
  445|  14.5M|		{
  446|  14.5M|			token = m_last_token;
  447|  14.5M|			item = m_last_index;
  448|  14.5M|		}
  449|       |
  450|  29.1M|		while (item < i)
  ------------------
  |  Branch (450:10): [True: 14.5M, False: 14.5M]
  ------------------
  451|  14.5M|		{
  452|  14.5M|			token += tokens[token].next_item;
  453|  14.5M|			++item;
  454|       |
  455|       |			// index 'i' out of range
  456|  14.5M|			TORRENT_ASSERT(tokens[token].type != bdecode_token::end);
  ------------------
  |  |   95|  14.5M|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|  14.5M|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 14.5M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 14.5M, False: 0]
  |  |  ------------------
  ------------------
  457|  14.5M|		}
  458|       |
  459|  14.5M|		m_last_token = token;
  460|  14.5M|		m_last_index = i;
  461|       |
  462|  14.5M|		return bdecode_node(tokens, m_buffer, m_buffer_size, token);
  463|  14.5M|	}
_ZNK10libtorrent12bdecode_node20list_string_value_atEiN5boost17basic_string_viewIcNSt3__111char_traitsIcEEEE:
  467|  12.4M|	{
  468|  12.4M|		bdecode_node const n = list_at(i);
  469|  12.4M|		if (n.type() != bdecode_node::string_t) return default_val;
  ------------------
  |  Branch (469:7): [True: 11.8M, False: 588k]
  ------------------
  470|   588k|		return n.string_value();
  471|  12.4M|	}
_ZNK10libtorrent12bdecode_node9list_sizeEv:
  482|  15.6M|	{
  483|  15.6M|		TORRENT_ASSERT(type() == list_t);
  ------------------
  |  |   95|  15.6M|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|  15.6M|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 15.6M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 15.6M, False: 0]
  |  |  ------------------
  ------------------
  484|       |
  485|  15.6M|		if (m_size != -1) return m_size;
  ------------------
  |  Branch (485:7): [True: 14.5M, False: 1.08M]
  ------------------
  486|       |
  487|       |		// make sure this is a list.
  488|  1.08M|		bdecode_token const* tokens = m_root_tokens;
  489|  1.08M|		TORRENT_ASSERT(tokens[m_token_idx].type == bdecode_token::list);
  ------------------
  |  |   95|  1.08M|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|  1.08M|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 1.08M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 1.08M, False: 0]
  |  |  ------------------
  ------------------
  490|       |
  491|       |		// this is the first item
  492|  1.08M|		int token = m_token_idx + 1;
  493|  1.08M|		int ret = 0;
  494|       |
  495|       |		// do we have a lookup cached?
  496|  1.08M|		if (m_last_index != -1)
  ------------------
  |  Branch (496:7): [True: 0, False: 1.08M]
  ------------------
  497|      0|		{
  498|      0|			token = m_last_token;
  499|      0|			ret = m_last_index;
  500|      0|		}
  501|  16.9M|		while (tokens[token].type != bdecode_token::end)
  ------------------
  |  Branch (501:10): [True: 15.8M, False: 1.08M]
  ------------------
  502|  15.8M|		{
  503|  15.8M|			token += tokens[token].next_item;
  504|  15.8M|			++ret;
  505|  15.8M|		}
  506|       |
  507|  1.08M|		m_size = ret;
  508|       |
  509|  1.08M|		return ret;
  510|  15.6M|	}
_ZNK10libtorrent12bdecode_node9dict_findEN5boost17basic_string_viewIcNSt3__111char_traitsIcEEEE:
  610|   687k|	{
  611|   687k|		TORRENT_ASSERT(type() == dict_t);
  ------------------
  |  |   95|   687k|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|   687k|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 687k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 687k, False: 0]
  |  |  ------------------
  ------------------
  612|       |
  613|   687k|		bdecode_token const* const tokens = m_root_tokens;
  614|       |
  615|       |		// this is the first item
  616|   687k|		int token = m_token_idx + 1;
  617|       |
  618|  1.30M|		while (tokens[token].type != bdecode_token::end)
  ------------------
  |  Branch (618:10): [True: 631k, False: 676k]
  ------------------
  619|   631k|		{
  620|   631k|			bdecode_token const& t = tokens[token];
  621|   631k|			TORRENT_ASSERT(t.type == bdecode_token::string
  ------------------
  |  |   95|  1.27M|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|   631k|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 631k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 622k, False: 9.82k]
  |  |  |  Branch (95:11): [True: 9.82k, False: 0]
  |  |  ------------------
  ------------------
  622|   631k|				|| t.type == bdecode_token::long_string);
  623|   631k|			int const size = token_source_span(t) - t.start_offset();
  624|   631k|			if (int(key.size()) == size
  ------------------
  |  Branch (624:8): [True: 60.4k, False: 571k]
  ------------------
  625|  60.4k|				&& std::equal(key.data(), key.data() + size, m_buffer
  ------------------
  |  Branch (625:8): [True: 11.8k, False: 48.6k]
  ------------------
  626|  60.4k|					+ t.offset + t.start_offset()))
  627|  11.8k|			{
  628|       |				// skip key
  629|  11.8k|				token += t.next_item;
  630|  11.8k|				TORRENT_ASSERT(tokens[token].type != bdecode_token::end);
  ------------------
  |  |   95|  11.8k|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|  11.8k|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 11.8k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 11.8k, False: 0]
  |  |  ------------------
  ------------------
  631|       |
  632|  11.8k|				return bdecode_node(tokens, m_buffer, m_buffer_size, token);
  633|  11.8k|			}
  634|       |
  635|       |			// skip key
  636|   619k|			token += t.next_item;
  637|   619k|			TORRENT_ASSERT(tokens[token].type != bdecode_token::end);
  ------------------
  |  |   95|   619k|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|   619k|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 619k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 619k, False: 0]
  |  |  ------------------
  ------------------
  638|       |
  639|       |			// skip value
  640|   619k|			token += tokens[token].next_item;
  641|   619k|		}
  642|       |
  643|   676k|		return bdecode_node();
  644|   687k|	}
_ZNK10libtorrent12bdecode_node14dict_find_listEN5boost17basic_string_viewIcNSt3__111char_traitsIcEEEE:
  647|  25.0k|	{
  648|  25.0k|		bdecode_node ret = dict_find(key);
  649|  25.0k|		if (ret.type() == bdecode_node::list_t)
  ------------------
  |  Branch (649:7): [True: 1.53k, False: 23.5k]
  ------------------
  650|  1.53k|			return ret;
  651|  23.5k|		return bdecode_node();
  652|  25.0k|	}
_ZNK10libtorrent12bdecode_node14dict_find_dictEN5boost17basic_string_viewIcNSt3__111char_traitsIcEEEE:
  655|  3.58k|	{
  656|  3.58k|		bdecode_node ret = dict_find(key);
  657|  3.58k|		if (ret.type() == bdecode_node::dict_t)
  ------------------
  |  Branch (657:7): [True: 216, False: 3.36k]
  ------------------
  658|    216|			return ret;
  659|  3.36k|		return bdecode_node();
  660|  3.58k|	}
_ZNK10libtorrent12bdecode_node16dict_find_stringEN5boost17basic_string_viewIcNSt3__111char_traitsIcEEEE:
  663|  29.2k|	{
  664|  29.2k|		bdecode_node ret = dict_find(key);
  665|  29.2k|		if (ret.type() == bdecode_node::string_t)
  ------------------
  |  Branch (665:7): [True: 636, False: 28.5k]
  ------------------
  666|    636|			return ret;
  667|  28.5k|		return bdecode_node();
  668|  29.2k|	}
_ZNK10libtorrent12bdecode_node22dict_find_string_valueEN5boost17basic_string_viewIcNSt3__111char_traitsIcEEEES6_:
  680|  22.1k|	{
  681|  22.1k|		bdecode_node n = dict_find(key);
  682|  22.1k|		if (n.type() != bdecode_node::string_t) return default_value;
  ------------------
  |  Branch (682:7): [True: 14.4k, False: 7.65k]
  ------------------
  683|  7.65k|		return n.string_value();
  684|  22.1k|	}
_ZNK10libtorrent12bdecode_node19dict_find_int_valueEN5boost17basic_string_viewIcNSt3__111char_traitsIcEEEEl:
  688|   607k|	{
  689|   607k|		bdecode_node n = dict_find(key);
  690|   607k|		if (n.type() != bdecode_node::int_t) return default_val;
  ------------------
  |  Branch (690:7): [True: 606k, False: 1.75k]
  ------------------
  691|  1.75k|		return n.int_value();
  692|   607k|	}
_ZNK10libtorrent12bdecode_node9int_valueEv:
  695|  1.75k|	{
  696|  1.75k|		TORRENT_ASSERT(type() == int_t);
  ------------------
  |  |   95|  1.75k|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|  1.75k|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 1.75k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 1.75k, False: 0]
  |  |  ------------------
  ------------------
  697|  1.75k|		bdecode_token const& t = m_root_tokens[m_token_idx];
  698|  1.75k|		int const size = token_source_span(t);
  699|  1.75k|		TORRENT_ASSERT(t.type == bdecode_token::integer);
  ------------------
  |  |   95|  1.75k|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|  1.75k|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 1.75k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 1.75k, False: 0]
  |  |  ------------------
  ------------------
  700|       |
  701|       |		// +1 is to skip the 'i'
  702|  1.75k|		char const* ptr = m_buffer + t.offset + 1;
  703|  1.75k|		std::int64_t val = 0;
  704|  1.75k|		bool const negative = (*ptr == '-');
  705|  1.75k|		bdecode_errors::error_code_enum ec = bdecode_errors::no_error;
  706|  1.75k|		char const* end = parse_int(ptr + int(negative)
  707|  1.75k|			, ptr + size, 'e', val, ec);
  708|  1.75k|		if (ec) return 0;
  ------------------
  |  Branch (708:7): [True: 18, False: 1.73k]
  ------------------
  709|  1.73k|		TORRENT_UNUSED(end);
  ------------------
  |  |  415|  1.73k|#define TORRENT_UNUSED(x) (void)(x)
  ------------------
  710|  1.73k|		TORRENT_ASSERT(end < ptr + size);
  ------------------
  |  |   95|  1.73k|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|  1.73k|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 1.73k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 1.73k, False: 0]
  |  |  ------------------
  ------------------
  711|  1.73k|		if (negative) val = -val;
  ------------------
  |  Branch (711:7): [True: 925, False: 812]
  ------------------
  712|  1.73k|		return val;
  713|  1.75k|	}
_ZNK10libtorrent12bdecode_node12string_valueEv:
  716|   596k|	{
  717|   596k|		TORRENT_ASSERT(type() == string_t);
  ------------------
  |  |   95|   596k|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|   596k|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 596k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 596k, False: 0]
  |  |  ------------------
  ------------------
  718|   596k|		bdecode_token const& t = m_root_tokens[m_token_idx];
  719|   596k|		auto const size = aux::numeric_cast<std::size_t>(token_source_span(t) - t.start_offset());
  720|   596k|		TORRENT_ASSERT(t.type == bdecode_token::string
  ------------------
  |  |   95|  1.19M|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|   596k|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 596k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 595k, False: 1.21k]
  |  |  |  Branch (95:11): [True: 1.21k, False: 0]
  |  |  ------------------
  ------------------
  721|   596k|			|| t.type == bdecode_token::long_string);
  722|       |
  723|   596k|		return string_view(m_buffer + t.offset + t.start_offset(), size);
  724|   596k|	}
_ZNK10libtorrent12bdecode_node10string_ptrEv:
  736|    399|	{
  737|    399|		TORRENT_ASSERT(type() == string_t);
  ------------------
  |  |   95|    399|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|    399|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 399]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 399, False: 0]
  |  |  ------------------
  ------------------
  738|    399|		bdecode_token const& t = m_root_tokens[m_token_idx];
  739|    399|		TORRENT_ASSERT(t.type == bdecode_token::string
  ------------------
  |  |   95|    831|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|    399|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 399]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 366, False: 33]
  |  |  |  Branch (95:11): [True: 33, False: 0]
  |  |  ------------------
  ------------------
  740|    399|			|| t.type == bdecode_token::long_string);
  741|    399|		return m_buffer + t.offset + t.start_offset();
  742|    399|	}
_ZNK10libtorrent12bdecode_node13string_lengthEv:
  745|   128k|	{
  746|   128k|		TORRENT_ASSERT(type() == string_t);
  ------------------
  |  |   95|   128k|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|   128k|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 128k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 128k, False: 0]
  |  |  ------------------
  ------------------
  747|   128k|		bdecode_token const& t = m_root_tokens[m_token_idx];
  748|   128k|		TORRENT_ASSERT(t.type == bdecode_token::string
  ------------------
  |  |   95|   349k|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|   128k|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 128k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 35.1k, False: 93.2k]
  |  |  |  Branch (95:11): [True: 93.2k, False: 0]
  |  |  ------------------
  ------------------
  749|   128k|			|| t.type == bdecode_token::long_string);
  750|   128k|		return token_source_span(t) - t.start_offset();
  751|   128k|	}
_ZN10libtorrent7bdecodeENS_4spanIKcEERN5boost6system10error_codeEPiii:
  811|  5.02k|	{
  812|  5.02k|		bdecode_node ret;
  813|  5.02k|		ec.clear();
  814|       |
  815|  5.02k|		if (buffer.size() > bdecode_token::max_offset)
  ------------------
  |  Branch (815:7): [True: 0, False: 5.02k]
  ------------------
  816|      0|		{
  817|      0|			if (error_pos) *error_pos = 0;
  ------------------
  |  Branch (817:8): [True: 0, False: 0]
  ------------------
  818|      0|			ec = bdecode_errors::limit_exceeded;
  819|      0|			return ret;
  820|      0|		}
  821|       |
  822|       |		// this is the stack of bdecode_token indices, into m_tokens.
  823|       |		// sp is the stack pointer, as index into the array, stack
  824|  5.02k|		int sp = 0;
  825|  5.02k|		TORRENT_ALLOCA(stack, stack_frame, depth_limit);
  ------------------
  |  |  104|  5.02k|#define TORRENT_ALLOCA(v, t, n) ::libtorrent::span<t> v; { \
  |  |  105|  5.02k|	auto TORRENT_ALLOCA_size = ::libtorrent::aux::numeric_cast<std::ptrdiff_t>(n); \
  |  |  106|  5.02k|	if (TORRENT_ALLOCA_size > ::libtorrent::aux::alloca_destructor<t>::cutoff) {\
  |  |  ------------------
  |  |  |  Branch (106:6): [True: 0, False: 5.02k]
  |  |  ------------------
  |  |  107|      0|		v = ::libtorrent::span<t>(new t[::libtorrent::aux::numeric_cast<std::size_t>(n)], TORRENT_ALLOCA_size); \
  |  |  108|      0|	} \
  |  |  109|  5.02k|	else { \
  |  |  110|  5.02k|		auto* TORRENT_ALLOCA_tmp = static_cast<t*>(TORRENT_ALLOCA_FUN(sizeof(t) * static_cast<std::size_t>(n))); \
  |  |  ------------------
  |  |  |  |  100|  5.02k|#define TORRENT_ALLOCA_FUN alloca
  |  |  ------------------
  |  |  111|  5.02k|		v = ::libtorrent::span<t>(TORRENT_ALLOCA_tmp, TORRENT_ALLOCA_size); \
  |  |  112|  5.02k|		::libtorrent::aux::uninitialized_default_construct(v.begin(), v.end()); \
  |  |  113|  5.02k|	} \
  |  |  114|  5.02k|} \
  |  |  115|  5.02k|::libtorrent::aux::alloca_destructor<t> v##_destructor{v}
  ------------------
  826|       |
  827|       |		// TODO: 2 attempt to simplify this implementation by embracing the span
  828|  5.02k|		char const* start = buffer.data();
  829|  5.02k|		char const* end = start + buffer.size();
  830|  5.02k|		char const* const orig_start = start;
  831|       |
  832|  5.02k|		if (start == end)
  ------------------
  |  Branch (832:7): [True: 0, False: 5.02k]
  ------------------
  833|      0|			TORRENT_FAIL_BDECODE(bdecode_errors::unexpected_eof);
  ------------------
  |  |  788|      0|#define TORRENT_FAIL_BDECODE(code) do { \
  |  |  789|      0|	ec = code; \
  |  |  790|      0|	if (error_pos) *error_pos = int(start - orig_start); \
  |  |  ------------------
  |  |  |  Branch (790:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  791|      0|	goto done; \
  |  |  792|      0|	} TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|      0|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  834|       |
  835|  66.1M|		while (start <= end)
  ------------------
  |  Branch (835:10): [True: 66.1M, False: 0]
  ------------------
  836|  66.1M|		{
  837|  66.1M|			if (start >= end) TORRENT_FAIL_BDECODE(bdecode_errors::unexpected_eof);
  ------------------
  |  |  788|    308|#define TORRENT_FAIL_BDECODE(code) do { \
  |  |  789|    308|	ec = code; \
  |  |  790|    308|	if (error_pos) *error_pos = int(start - orig_start); \
  |  |  ------------------
  |  |  |  Branch (790:6): [True: 308, False: 0]
  |  |  ------------------
  |  |  791|    308|	goto done; \
  |  |  792|    308|	} TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|    308|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (837:8): [True: 308, False: 66.1M]
  ------------------
  838|       |
  839|  66.1M|			if (sp >= depth_limit)
  ------------------
  |  Branch (839:8): [True: 4, False: 66.1M]
  ------------------
  840|      4|				TORRENT_FAIL_BDECODE(bdecode_errors::depth_exceeded);
  ------------------
  |  |  788|      4|#define TORRENT_FAIL_BDECODE(code) do { \
  |  |  789|      4|	ec = code; \
  |  |  790|      4|	if (error_pos) *error_pos = int(start - orig_start); \
  |  |  ------------------
  |  |  |  Branch (790:6): [True: 4, False: 0]
  |  |  ------------------
  |  |  791|      4|	goto done; \
  |  |  792|      4|	} TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|      4|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  841|       |
  842|  66.1M|			--token_limit;
  843|  66.1M|			if (token_limit < 0)
  ------------------
  |  Branch (843:8): [True: 0, False: 66.1M]
  ------------------
  844|      0|				TORRENT_FAIL_BDECODE(bdecode_errors::limit_exceeded);
  ------------------
  |  |  788|      0|#define TORRENT_FAIL_BDECODE(code) do { \
  |  |  789|      0|	ec = code; \
  |  |  790|      0|	if (error_pos) *error_pos = int(start - orig_start); \
  |  |  ------------------
  |  |  |  Branch (790:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  791|      0|	goto done; \
  |  |  792|      0|	} TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|      0|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  845|       |
  846|       |			// look for a new token
  847|  66.1M|			char const t = *start;
  848|       |
  849|  66.1M|			int const current_frame = sp;
  850|       |
  851|       |			// if we're currently parsing a dictionary, assert that
  852|       |			// every other node is a string.
  853|  66.1M|			if (current_frame > 0
  ------------------
  |  Branch (853:8): [True: 66.0M, False: 5.02k]
  ------------------
  854|  66.0M|				&& ret.m_tokens[stack[current_frame - 1].token].type == bdecode_token::dict)
  ------------------
  |  Branch (854:8): [True: 22.6M, False: 43.4M]
  ------------------
  855|  22.6M|			{
  856|  22.6M|				if (stack[current_frame - 1].state == 0)
  ------------------
  |  Branch (856:9): [True: 22.5M, False: 29.0k]
  ------------------
  857|  22.5M|				{
  858|       |					// the current parent is a dict and we are parsing a key.
  859|       |					// only allow a digit (for a string) or 'e' to terminate
  860|  22.5M|					if (!numeric(t) && t != 'e')
  ------------------
  |  Branch (860:10): [True: 22.5M, False: 29.0k]
  |  Branch (860:25): [True: 39, False: 22.5M]
  ------------------
  861|     39|						TORRENT_FAIL_BDECODE(bdecode_errors::expected_digit);
  ------------------
  |  |  788|     39|#define TORRENT_FAIL_BDECODE(code) do { \
  |  |  789|     39|	ec = code; \
  |  |  790|     39|	if (error_pos) *error_pos = int(start - orig_start); \
  |  |  ------------------
  |  |  |  Branch (790:6): [True: 39, False: 0]
  |  |  ------------------
  |  |  791|     39|	goto done; \
  |  |  792|     39|	} TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|     39|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  862|  22.5M|				}
  863|  22.6M|			}
  864|       |
  865|  66.1M|			switch (t)
  866|  66.1M|			{
  867|  22.5M|				case 'd':
  ------------------
  |  Branch (867:5): [True: 22.5M, False: 43.5M]
  ------------------
  868|  22.5M|					stack[sp++] = stack_frame(int(ret.m_tokens.size()));
  869|       |					// we push it into the stack so that we know where to fill
  870|       |					// in the next_node field once we pop this node off the stack.
  871|       |					// i.e. get to the node following the dictionary in the buffer
  872|  22.5M|					ret.m_tokens.push_back({start - orig_start, bdecode_token::dict});
  873|  22.5M|					++start;
  874|  22.5M|					break;
  875|  10.1M|				case 'l':
  ------------------
  |  Branch (875:5): [True: 10.1M, False: 55.9M]
  ------------------
  876|  10.1M|					stack[sp++] = stack_frame(int(ret.m_tokens.size()));
  877|       |					// we push it into the stack so that we know where to fill
  878|       |					// in the next_node field once we pop this node off the stack.
  879|       |					// i.e. get to the node following the list in the buffer
  880|  10.1M|					ret.m_tokens.push_back({start - orig_start, bdecode_token::list});
  881|  10.1M|					++start;
  882|  10.1M|					break;
  883|  3.31k|				case 'i':
  ------------------
  |  Branch (883:5): [True: 3.31k, False: 66.0M]
  ------------------
  884|  3.31k|				{
  885|  3.31k|					char const* const int_start = start;
  886|  3.31k|					bdecode_errors::error_code_enum e = bdecode_errors::no_error;
  887|       |					// +1 here to point to the first digit, rather than 'i'
  888|  3.31k|					start = check_integer(start + 1, end, e);
  889|  3.31k|					if (e)
  ------------------
  |  Branch (889:10): [True: 69, False: 3.24k]
  ------------------
  890|     69|					{
  891|       |						// in order to gracefully terminate the tree,
  892|       |						// make sure the end of the previous token is set correctly
  893|     69|						if (error_pos) *error_pos = int(start - orig_start);
  ------------------
  |  Branch (893:11): [True: 69, False: 0]
  ------------------
  894|     69|						error_pos = nullptr;
  895|     69|						start = int_start;
  896|     69|						TORRENT_FAIL_BDECODE(e);
  ------------------
  |  |  788|     69|#define TORRENT_FAIL_BDECODE(code) do { \
  |  |  789|     69|	ec = code; \
  |  |  790|     69|	if (error_pos) *error_pos = int(start - orig_start); \
  |  |  ------------------
  |  |  |  Branch (790:6): [True: 0, False: 69]
  |  |  ------------------
  |  |  791|     69|	goto done; \
  |  |  792|     69|	} TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|     69|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  897|     69|					}
  898|  3.24k|					ret.m_tokens.push_back({int_start - orig_start
  899|  3.24k|						, 1, bdecode_token::integer, 1});
  900|  3.24k|					TORRENT_ASSERT(*start == 'e');
  ------------------
  |  |   95|  3.24k|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|  3.24k|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 3.24k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 3.24k, False: 0]
  |  |  ------------------
  ------------------
  901|       |
  902|       |					// skip 'e'
  903|  3.24k|					++start;
  904|  3.24k|					break;
  905|  3.31k|				}
  906|  32.7M|				case 'e':
  ------------------
  |  Branch (906:5): [True: 32.7M, False: 33.3M]
  ------------------
  907|  32.7M|				{
  908|       |					// this is the end of a list or dict
  909|  32.7M|					if (sp == 0)
  ------------------
  |  Branch (909:10): [True: 1, False: 32.7M]
  ------------------
  910|      1|						TORRENT_FAIL_BDECODE(bdecode_errors::unexpected_eof);
  ------------------
  |  |  788|      1|#define TORRENT_FAIL_BDECODE(code) do { \
  |  |  789|      1|	ec = code; \
  |  |  790|      1|	if (error_pos) *error_pos = int(start - orig_start); \
  |  |  ------------------
  |  |  |  Branch (790:6): [True: 1, False: 0]
  |  |  ------------------
  |  |  791|      1|	goto done; \
  |  |  792|      1|	} TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|      1|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  911|       |
  912|  32.7M|					if (sp > 0
  ------------------
  |  Branch (912:10): [True: 32.7M, False: 0]
  ------------------
  913|  32.7M|						&& ret.m_tokens[stack[sp - 1].token].type == bdecode_token::dict
  ------------------
  |  Branch (913:10): [True: 22.5M, False: 10.1M]
  ------------------
  914|  22.5M|						&& stack[sp - 1].state == 1)
  ------------------
  |  Branch (914:10): [True: 24, False: 22.5M]
  ------------------
  915|     24|					{
  916|       |						// this means we're parsing a dictionary and about to parse a
  917|       |						// value associated with a key. Instead, we got a termination
  918|     24|						TORRENT_FAIL_BDECODE(bdecode_errors::expected_value);
  ------------------
  |  |  788|     24|#define TORRENT_FAIL_BDECODE(code) do { \
  |  |  789|     24|	ec = code; \
  |  |  790|     24|	if (error_pos) *error_pos = int(start - orig_start); \
  |  |  ------------------
  |  |  |  Branch (790:6): [True: 24, False: 0]
  |  |  ------------------
  |  |  791|     24|	goto done; \
  |  |  792|     24|	} TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|     24|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  919|     24|					}
  920|       |
  921|       |					// insert the end-of-sequence token
  922|  32.7M|					ret.m_tokens.push_back({start - orig_start, 1, bdecode_token::end});
  923|       |
  924|       |					// and back-patch the start of this sequence with the offset
  925|       |					// to the next token we'll insert
  926|  32.7M|					int const top = stack[sp - 1].token;
  927|       |					// subtract the token's own index, since this is a relative
  928|       |					// offset
  929|  32.7M|					if (int(ret.m_tokens.size()) - top > bdecode_token::max_next_item)
  ------------------
  |  Branch (929:10): [True: 0, False: 32.7M]
  ------------------
  930|      0|						TORRENT_FAIL_BDECODE(bdecode_errors::limit_exceeded);
  ------------------
  |  |  788|      0|#define TORRENT_FAIL_BDECODE(code) do { \
  |  |  789|      0|	ec = code; \
  |  |  790|      0|	if (error_pos) *error_pos = int(start - orig_start); \
  |  |  ------------------
  |  |  |  Branch (790:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  791|      0|	goto done; \
  |  |  792|      0|	} TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|      0|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  931|       |
  932|  32.7M|					ret.m_tokens[std::size_t(top)].next_item = std::uint32_t(int(ret.m_tokens.size()) - top);
  933|       |
  934|       |					// and pop it from the stack.
  935|  32.7M|					TORRENT_ASSERT(sp > 0);
  ------------------
  |  |   95|  32.7M|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|  32.7M|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 32.7M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 32.7M, False: 0]
  |  |  ------------------
  ------------------
  936|  32.7M|					--sp;
  937|  32.7M|					++start;
  938|  32.7M|					break;
  939|  32.7M|				}
  940|   668k|				default:
  ------------------
  |  Branch (940:5): [True: 668k, False: 65.4M]
  ------------------
  941|   668k|				{
  942|       |					// this is the case for strings. The start character is any
  943|       |					// numeric digit
  944|   668k|					if (!numeric(t))
  ------------------
  |  Branch (944:10): [True: 49, False: 668k]
  ------------------
  945|     49|						TORRENT_FAIL_BDECODE(bdecode_errors::expected_value);
  ------------------
  |  |  788|     49|#define TORRENT_FAIL_BDECODE(code) do { \
  |  |  789|     49|	ec = code; \
  |  |  790|     49|	if (error_pos) *error_pos = int(start - orig_start); \
  |  |  ------------------
  |  |  |  Branch (790:6): [True: 49, False: 0]
  |  |  ------------------
  |  |  791|     49|	goto done; \
  |  |  792|     49|	} TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|     49|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  946|       |
  947|   668k|					std::int64_t len = t - '0';
  948|   668k|					char const* const str_start = start;
  949|   668k|					++start;
  950|   668k|					if (start >= end) TORRENT_FAIL_BDECODE(bdecode_errors::unexpected_eof);
  ------------------
  |  |  788|     22|#define TORRENT_FAIL_BDECODE(code) do { \
  |  |  789|     22|	ec = code; \
  |  |  790|     22|	if (error_pos) *error_pos = int(start - orig_start); \
  |  |  ------------------
  |  |  |  Branch (790:6): [True: 22, False: 0]
  |  |  ------------------
  |  |  791|     22|	goto done; \
  |  |  792|     22|	} TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|     22|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (950:10): [True: 22, False: 668k]
  ------------------
  951|   668k|					bdecode_errors::error_code_enum e = bdecode_errors::no_error;
  952|   668k|					start = parse_int(start, end, ':', len, e);
  953|   668k|					if (e)
  ------------------
  |  Branch (953:10): [True: 30, False: 668k]
  ------------------
  954|     30|						TORRENT_FAIL_BDECODE(e);
  ------------------
  |  |  788|     30|#define TORRENT_FAIL_BDECODE(code) do { \
  |  |  789|     30|	ec = code; \
  |  |  790|     30|	if (error_pos) *error_pos = int(start - orig_start); \
  |  |  ------------------
  |  |  |  Branch (790:6): [True: 30, False: 0]
  |  |  ------------------
  |  |  791|     30|	goto done; \
  |  |  792|     30|	} TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|     30|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  955|   668k|					if (start == end)
  ------------------
  |  Branch (955:10): [True: 146, False: 668k]
  ------------------
  956|    146|						TORRENT_FAIL_BDECODE(bdecode_errors::expected_colon);
  ------------------
  |  |  788|    146|#define TORRENT_FAIL_BDECODE(code) do { \
  |  |  789|    146|	ec = code; \
  |  |  790|    146|	if (error_pos) *error_pos = int(start - orig_start); \
  |  |  ------------------
  |  |  |  Branch (790:6): [True: 146, False: 0]
  |  |  ------------------
  |  |  791|    146|	goto done; \
  |  |  792|    146|	} TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|    146|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  957|       |
  958|       |					// remaining buffer size excluding ':'
  959|   668k|					ptrdiff_t const buff_size = end - start - 1;
  960|   668k|					if (len > buff_size)
  ------------------
  |  Branch (960:10): [True: 123, False: 668k]
  ------------------
  961|    123|						TORRENT_FAIL_BDECODE(bdecode_errors::unexpected_eof);
  ------------------
  |  |  788|    123|#define TORRENT_FAIL_BDECODE(code) do { \
  |  |  789|    123|	ec = code; \
  |  |  790|    123|	if (error_pos) *error_pos = int(start - orig_start); \
  |  |  ------------------
  |  |  |  Branch (790:6): [True: 123, False: 0]
  |  |  ------------------
  |  |  791|    123|	goto done; \
  |  |  792|    123|	} TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|    123|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  962|   668k|					if (len < 0)
  ------------------
  |  Branch (962:10): [True: 0, False: 668k]
  ------------------
  963|      0|						TORRENT_FAIL_BDECODE(bdecode_errors::overflow);
  ------------------
  |  |  788|      0|#define TORRENT_FAIL_BDECODE(code) do { \
  |  |  789|      0|	ec = code; \
  |  |  790|      0|	if (error_pos) *error_pos = int(start - orig_start); \
  |  |  ------------------
  |  |  |  Branch (790:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  791|      0|	goto done; \
  |  |  792|      0|	} TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|      0|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  964|       |
  965|       |					// skip ':'
  966|   668k|					++start;
  967|       |					// no need to range check start here
  968|       |					// the check above ensures that the buffer is long enough to hold
  969|       |					// the string's length which guarantees that start <= end
  970|       |
  971|   668k|					int const header = int(start - str_start);
  972|   668k|					TORRENT_ASSERT(header >= 0);
  ------------------
  |  |   95|   668k|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|   668k|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 668k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 668k, False: 0]
  |  |  ------------------
  ------------------
  973|       |
  974|       |					// the bdecode_token only has 8 bits to keep the header size
  975|       |					// in. If it overflows, fail!
  976|   668k|					if (header > aux::bdecode_token::long_string_max_header)
  ------------------
  |  Branch (976:10): [True: 31, False: 668k]
  ------------------
  977|     31|						TORRENT_FAIL_BDECODE(bdecode_errors::limit_exceeded);
  ------------------
  |  |  788|     31|#define TORRENT_FAIL_BDECODE(code) do { \
  |  |  789|     31|	ec = code; \
  |  |  790|     31|	if (error_pos) *error_pos = int(start - orig_start); \
  |  |  ------------------
  |  |  |  Branch (790:6): [True: 31, False: 0]
  |  |  ------------------
  |  |  791|     31|	goto done; \
  |  |  792|     31|	} TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|     31|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  978|       |
  979|   668k|					ret.m_tokens.push_back({str_start - orig_start
  980|   668k|						, 1, bdecode_token::string, std::uint32_t(header)});
  981|   668k|					start += len;
  982|   668k|					break;
  983|   668k|				}
  984|  66.1M|			}
  985|       |
  986|  66.1M|			if (current_frame > 0
  ------------------
  |  Branch (986:8): [True: 66.0M, False: 4.64k]
  ------------------
  987|  66.0M|				&& ret.m_tokens[stack[current_frame - 1].token].type == bdecode_token::dict)
  ------------------
  |  Branch (987:8): [True: 22.6M, False: 43.4M]
  ------------------
  988|  22.6M|			{
  989|       |				// the next item we parse is the opposite
  990|       |				// state is an unsigned 1-bit member. adding 1 will flip the bit
  991|  22.6M|				stack[current_frame - 1].state = (stack[current_frame - 1].state + 1) & 1;
  992|  22.6M|			}
  993|       |
  994|       |			// this terminates the top level node, we're done!
  995|  66.1M|			if (sp == 0) break;
  ------------------
  |  Branch (995:8): [True: 4.17k, False: 66.0M]
  ------------------
  996|  66.1M|		}
  997|       |
  998|  5.02k|done:
  999|       |
 1000|       |		// if parse failed, sp will be greater than 1
 1001|       |		// unwind the stack by inserting terminator to make whatever we have
 1002|       |		// so far valid
 1003|  14.0k|		while (sp > 0) {
  ------------------
  |  Branch (1003:10): [True: 9.04k, False: 5.02k]
  ------------------
 1004|  9.04k|			TORRENT_ASSERT(ec);
  ------------------
  |  |   95|  9.04k|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|  9.04k|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 9.04k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 9.04k, False: 0]
  |  |  ------------------
  ------------------
 1005|  9.04k|			--sp;
 1006|       |
 1007|       |			// we may need to insert a dummy token to properly terminate the tree,
 1008|       |			// in case we just parsed a key to a dict and failed in the value
 1009|  9.04k|			if (ret.m_tokens[stack[sp].token].type == bdecode_token::dict
  ------------------
  |  Branch (1009:8): [True: 773, False: 8.27k]
  ------------------
 1010|    773|				&& stack[sp].state == 1)
  ------------------
  |  Branch (1010:8): [True: 108, False: 665]
  ------------------
 1011|    108|			{
 1012|       |				// insert an empty dictionary as the value
 1013|    108|				ret.m_tokens.push_back({start - orig_start, 2, bdecode_token::dict});
 1014|    108|				ret.m_tokens.push_back({start - orig_start, bdecode_token::end});
 1015|    108|			}
 1016|       |
 1017|  9.04k|			int const top = stack[sp].token;
 1018|  9.04k|			TORRENT_ASSERT(int(ret.m_tokens.size()) - top <= bdecode_token::max_next_item);
  ------------------
  |  |   95|  9.04k|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|  9.04k|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 9.04k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 9.04k, False: 0]
  |  |  ------------------
  ------------------
 1019|  9.04k|			ret.m_tokens[std::size_t(top)].next_item = std::uint32_t(int(ret.m_tokens.size()) - top);
 1020|  9.04k|			ret.m_tokens.push_back({start - orig_start, 1, bdecode_token::end});
 1021|  9.04k|		}
 1022|       |
 1023|  5.02k|		ret.m_tokens.push_back({start - orig_start, 0, bdecode_token::end});
 1024|       |
 1025|  5.02k|		ret.m_token_idx = 0;
 1026|  5.02k|		ret.m_buffer = orig_start;
 1027|  5.02k|		ret.m_buffer_size = int(start - orig_start);
 1028|  5.02k|		ret.m_root_tokens = ret.m_tokens.data();
 1029|       |
 1030|  5.02k|		return ret;
 1031|  5.02k|	}
bdecode.cpp:_ZN10libtorrent12_GLOBAL__N_17numericEc:
   60|  30.4M|	bool numeric(char c) { return c >= '0' && c <= '9'; }
  ------------------
  |  Branch (60:32): [True: 30.4M, False: 75]
  |  Branch (60:44): [True: 7.86M, False: 22.5M]
  ------------------
bdecode.cpp:_ZN10libtorrent12_GLOBAL__N_117token_source_spanERKNS_3aux13bdecode_tokenE:
  126|  1.35M|	{
  127|  1.35M|		return (&t)[1].offset - t.offset;
  128|  1.35M|	}
bdecode.cpp:_ZN10libtorrent12_GLOBAL__N_111stack_frameC2Ev:
  114|   502k|		stack_frame() : token(0), state(0) {}
bdecode.cpp:_ZN10libtorrent12_GLOBAL__N_111stack_frameC2Ei:
  115|  32.7M|		explicit stack_frame(int const t): token(std::uint32_t(t)), state(0) {}
bdecode.cpp:_ZN10libtorrent12_GLOBAL__N_113check_integerEPKcS2_RNS_14bdecode_errors15error_code_enumE:
   68|  3.31k|	{
   69|  3.31k|		if (start == end)
  ------------------
  |  Branch (69:7): [True: 4, False: 3.31k]
  ------------------
   70|      4|		{
   71|      4|			e = bdecode_errors::unexpected_eof;
   72|      4|			return start;
   73|      4|		}
   74|       |
   75|  3.31k|		if (*start == '-')
  ------------------
  |  Branch (75:7): [True: 1.62k, False: 1.69k]
  ------------------
   76|  1.62k|		{
   77|  1.62k|			++start;
   78|  1.62k|			if (start == end)
  ------------------
  |  Branch (78:8): [True: 1, False: 1.62k]
  ------------------
   79|      1|			{
   80|      1|				e = bdecode_errors::unexpected_eof;
   81|      1|				return start;
   82|      1|			}
   83|  1.62k|		}
   84|       |
   85|  3.31k|		int digits = 0;
   86|  3.31k|		do
   87|  2.55M|		{
   88|  2.55M|			if (!numeric(*start))
  ------------------
  |  Branch (88:8): [True: 38, False: 2.55M]
  ------------------
   89|     38|			{
   90|     38|				e = bdecode_errors::expected_digit;
   91|     38|				break;
   92|     38|			}
   93|  2.55M|			++start;
   94|  2.55M|			++digits;
   95|       |
   96|  2.55M|			if (start == end)
  ------------------
  |  Branch (96:8): [True: 26, False: 2.55M]
  ------------------
   97|     26|			{
   98|     26|				e = bdecode_errors::unexpected_eof;
   99|     26|				break;
  100|     26|			}
  101|  2.55M|		}
  102|  2.55M|		while (*start != 'e');
  ------------------
  |  Branch (102:10): [True: 2.54M, False: 3.24k]
  ------------------
  103|       |
  104|  3.31k|		if (digits > 20)
  ------------------
  |  Branch (104:7): [True: 18, False: 3.29k]
  ------------------
  105|     18|		{
  106|     18|			e = bdecode_errors::overflow;
  107|     18|		}
  108|       |
  109|  3.31k|		return start;
  110|  3.31k|	}

_ZN10libtorrent8bitfield6resizeEi:
  180|    494|	{
  181|    494|		if (bits == size()) return;
  ------------------
  |  Branch (181:7): [True: 57, False: 437]
  ------------------
  182|       |
  183|    437|		TORRENT_ASSERT(bits >= 0);
  ------------------
  |  |   95|    494|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|    494|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 437]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 437, False: 0]
  |  |  ------------------
  ------------------
  184|    437|		if (bits == 0)
  ------------------
  |  Branch (184:7): [True: 5, False: 432]
  ------------------
  185|      5|		{
  186|      5|			m_buf.reset();
  187|      5|			return;
  188|      5|		}
  189|    432|		int const new_size_words = (bits + 31) / 32;
  190|    432|		int const cur_size_words = num_words();
  191|    432|		if (cur_size_words != new_size_words)
  ------------------
  |  Branch (191:7): [True: 425, False: 7]
  ------------------
  192|    425|		{
  193|    425|			aux::unique_ptr<std::uint32_t[]> b(new std::uint32_t[std::size_t(new_size_words + 1)]);
  194|       |#ifdef BOOST_NO_EXCEPTIONS
  195|       |			if (b == nullptr) std::terminate();
  196|       |#endif
  197|    425|			b[0] = aux::numeric_cast<std::uint32_t>(bits);
  198|    425|			if (m_buf) std::memcpy(&b[1], buf()
  ------------------
  |  Branch (198:8): [True: 37, False: 388]
  ------------------
  199|     37|				, aux::numeric_cast<std::size_t>(std::min(new_size_words, cur_size_words) * 4));
  200|    425|			if (new_size_words > cur_size_words)
  ------------------
  |  Branch (200:8): [True: 393, False: 32]
  ------------------
  201|    393|			{
  202|    393|				std::memset(&b[1 + cur_size_words], 0
  203|    393|					, aux::numeric_cast<std::size_t>((new_size_words - cur_size_words) * 4));
  204|    393|			}
  205|    425|			m_buf = std::move(b);
  206|    425|		}
  207|      7|		else
  208|      7|		{
  209|      7|			m_buf[0] = aux::numeric_cast<std::uint32_t>(bits);
  210|      7|		}
  211|       |
  212|    432|		clear_trailing_bits();
  213|    432|		TORRENT_ASSERT(size() == bits);
  ------------------
  |  |   95|    432|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|    432|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 432]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 432, False: 0]
  |  |  ------------------
  ------------------
  214|    432|	}

cpuid.cpp:_ZN10libtorrent3aux12_GLOBAL__N_114supports_sse42Ev:
  101|      2|	{
  102|      2|#if TORRENT_HAS_SSE
  103|      2|		std::uint32_t cpui[4] = {0};
  104|      2|		cpuid(cpui, 1);
  105|      2|		return (cpui[2] & (1 << 20)) != 0;
  106|       |#else
  107|       |		return false;
  108|       |#endif
  109|      2|	}
cpuid.cpp:_ZN10libtorrent3aux12_GLOBAL__N_15cpuidEPji:
   86|      4|	{
   87|       |#if defined _MSC_VER
   88|       |		__cpuid(reinterpret_cast<int*>(info), type);
   89|       |
   90|       |#elif defined __GNUC__
   91|       |		__get_cpuid(std::uint32_t(type), &info[0], &info[1], &info[2], &info[3]);
   92|       |#else
   93|       |		TORRENT_UNUSED(type);
   94|       |		// for non-x86 and non-amd64, just return zeroes
   95|       |		std::memset(&info[0], 0, sizeof(std::uint32_t) * 4);
   96|       |#endif
   97|      4|	}
cpuid.cpp:_ZN10libtorrent3aux12_GLOBAL__N_112supports_mmxEv:
  112|      2|	{
  113|      2|#if TORRENT_HAS_SSE
  114|      2|		std::uint32_t cpui[4] = {0};
  115|      2|		cpuid(cpui, 1);
  116|      2|		return (cpui[2] & (1 << 23)) != 0;
  117|       |#else
  118|       |		return false;
  119|       |#endif
  120|      2|	}
cpuid.cpp:_ZN10libtorrent3aux12_GLOBAL__N_117supports_arm_neonEv:
  123|      2|	{
  124|       |#if TORRENT_HAS_ARM_NEON && TORRENT_HAS_AUXV
  125|       |#if defined __arm__
  126|       |		//return (getauxval(AT_HWCAP) & HWCAP_NEON);
  127|       |		return (helper_getauxval(16) & (1 << 12));
  128|       |#elif defined __aarch64__
  129|       |		//return (getauxval(AT_HWCAP) & HWCAP_ASIMD);
  130|       |		//return (getauxval(16) & (1 << 1));
  131|       |		// TODO: enable when aarch64 is really tested
  132|       |		return false;
  133|       |#endif
  134|       |#else
  135|      2|		return false;
  136|      2|#endif
  137|      2|	}
cpuid.cpp:_ZN10libtorrent3aux12_GLOBAL__N_119supports_arm_crc32cEv:
  140|      2|	{
  141|       |#if TORRENT_HAS_ARM_CRC32 && TORRENT_HAS_AUXV
  142|       |#if defined TORRENT_FORCE_ARM_CRC32
  143|       |		return true;
  144|       |#elif defined __arm__
  145|       |		//return (getauxval(AT_HWCAP2) & HWCAP2_CRC32);
  146|       |		return (helper_getauxval(26) & (1 << 4));
  147|       |#elif defined __aarch64__
  148|       |		//return (getauxval(AT_HWCAP) & HWCAP_CRC32);
  149|       |		return (helper_getauxval(16) & (1 << 7));
  150|       |#endif
  151|       |#else
  152|      2|		return false;
  153|      2|#endif
  154|      2|	}

_ZN10libtorrent3aux14integer_to_strERNSt3__15arrayIcLm21EEEl:
   50|  4.34M|	{
   51|  4.34M|		if (val >= 0)
  ------------------
  |  Branch (51:7): [True: 4.31M, False: 35.2k]
  ------------------
   52|  4.31M|		{
   53|  4.31M|			if (val < 10)
  ------------------
  |  Branch (53:8): [True: 4.12M, False: 185k]
  ------------------
   54|  4.12M|			{
   55|  4.12M|				buf[0] = '0' + static_cast<char>(val);
   56|  4.12M|				return {buf.data(), std::size_t(1)};
   57|  4.12M|			}
   58|   185k|			if (val < 100)
  ------------------
  |  Branch (58:8): [True: 183k, False: 1.61k]
  ------------------
   59|   183k|			{
   60|   183k|				buf[0] = '0' + (val / 10) % 10;
   61|   183k|				buf[1] = '0' + val % 10;
   62|   183k|				return {buf.data(), std::size_t(2)};
   63|   183k|			}
   64|  1.61k|			if (val < 1000)
  ------------------
  |  Branch (64:8): [True: 723, False: 889]
  ------------------
   65|    723|			{
   66|    723|				buf[0] = '0' + (val / 100) % 10;
   67|    723|				buf[1] = '0' + (val / 10) % 10;
   68|    723|				buf[2] = '0' + val % 10;
   69|    723|				return {buf.data(), std::size_t(3)};
   70|    723|			}
   71|    889|			if (val < 10000)
  ------------------
  |  Branch (71:8): [True: 416, False: 473]
  ------------------
   72|    416|			{
   73|    416|				buf[0] = '0' + (val / 1000) % 10;
   74|    416|				buf[1] = '0' + (val / 100) % 10;
   75|    416|				buf[2] = '0' + (val / 10) % 10;
   76|    416|				buf[3] = '0' + val % 10;
   77|    416|				return {buf.data(), std::size_t(4)};
   78|    416|			}
   79|    473|			if (val < 100000)
  ------------------
  |  Branch (79:8): [True: 209, False: 264]
  ------------------
   80|    209|			{
   81|    209|				buf[0] = '0' + (val / 10000) % 10;
   82|    209|				buf[1] = '0' + (val / 1000) % 10;
   83|    209|				buf[2] = '0' + (val / 100) % 10;
   84|    209|				buf[3] = '0' + (val / 10) % 10;
   85|    209|				buf[4] = '0' + val % 10;
   86|    209|				return {buf.data(), std::size_t(5)};
   87|    209|			}
   88|    473|		}
   89|       |		// val == 0 is handled in the fast-path above
   90|  35.4k|		TORRENT_ASSERT(val != 0);
  ------------------
  |  |   95|  4.34M|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|  4.34M|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 35.4k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 35.4k, False: 0]
  |  |  ------------------
  ------------------
   91|       |		// slow path
   92|       |		// convert positive values to negative, since the negative space is
   93|       |		// larger, so we can fit INT64_MIN
   94|  35.4k|		int sign = 1;
   95|  35.4k|		if (val > 0)
  ------------------
  |  Branch (95:7): [True: 264, False: 35.2k]
  ------------------
   96|    264|		{
   97|    264|			sign = 0;
   98|    264|			val = -val;
   99|    264|		}
  100|  35.4k|		char* ptr = &buf.back();
  101|  35.4k|		do
  102|  38.7k|		{
  103|  38.7k|			*ptr-- = '0' - char(val % 10);
  104|  38.7k|			val /= 10;
  105|  38.7k|		} while (val != 0);
  ------------------
  |  Branch (105:12): [True: 3.27k, False: 35.4k]
  ------------------
  106|  35.4k|		if (sign) *ptr-- = '-';
  ------------------
  |  Branch (106:7): [True: 35.2k, False: 264]
  ------------------
  107|  35.4k|		++ptr;
  108|  35.4k|		return {ptr, static_cast<std::size_t>(&buf.back() - ptr + 1)};
  109|  4.34M|	}
_ZN10libtorrent5entryixEN5boost17basic_string_viewIcNSt3__111char_traitsIcEEEE:
  126|   206k|	{
  127|       |		// at least GCC-5.4 for ARM (on travis) has a libstdc++ whose debug map$
  128|       |		// doesn't seem to support transparent comparators$
  129|       |#if ! defined _GLIBCXX_DEBUG
  130|       |		auto const i = dict().find(key);
  131|       |#else
  132|   206k|		auto const i = dict().find(std::string(key));
  133|   206k|#endif
  134|   206k|		if (i != dict().end()) return i->second;
  ------------------
  |  Branch (134:7): [True: 0, False: 206k]
  ------------------
  135|   206k|		auto const ret = dict().emplace(
  136|   206k|			std::piecewise_construct,
  137|   206k|			std::forward_as_tuple(key),
  138|   206k|			std::forward_as_tuple()).first;
  139|   206k|		return ret->second;
  140|   206k|	}
_ZNK10libtorrent5entry4typeEv:
  178|  25.0M|	{
  179|  25.0M|#if TORRENT_USE_ASSERTS
  180|  25.0M|		m_type_queried = true;
  181|  25.0M|#endif
  182|  25.0M|		return entry::data_type(m_type);
  183|  25.0M|	}
_ZN10libtorrent5entryD2Ev:
  185|  25.0M|	entry::~entry() { destruct(); }
_ZNR10libtorrent5entryaSEOS0_:
  196|  13.3M|	{
  197|  13.3M|		if (&e == this) return *this;
  ------------------
  |  Branch (197:7): [True: 0, False: 13.3M]
  ------------------
  198|  13.3M|		destruct();
  199|  13.3M|		const auto t = e.type();
  200|  13.3M|		switch (t)
  ------------------
  |  Branch (200:11): [True: 13.3M, False: 0]
  ------------------
  201|  13.3M|		{
  202|      0|		case int_t:
  ------------------
  |  Branch (202:3): [True: 0, False: 13.3M]
  ------------------
  203|      0|			new (&data) integer_type(std::move(e.integer()));
  204|      0|			break;
  205|  6.00M|		case string_t:
  ------------------
  |  Branch (205:3): [True: 6.00M, False: 7.38M]
  ------------------
  206|  6.00M|			new (&data) string_type(std::move(e.string()));
  207|  6.00M|			break;
  208|  15.2k|		case list_t:
  ------------------
  |  Branch (208:3): [True: 15.2k, False: 13.3M]
  ------------------
  209|  15.2k|			new (&data) list_type(std::move(e.list()));
  210|  15.2k|			break;
  211|      0|		case dictionary_t:
  ------------------
  |  Branch (211:3): [True: 0, False: 13.3M]
  ------------------
  212|      0|			new (&data) dictionary_type(std::move(e.dict()));
  213|      0|			break;
  214|  7.36M|		case undefined_t:
  ------------------
  |  Branch (214:3): [True: 7.36M, False: 6.02M]
  ------------------
  215|  7.36M|			break;
  216|      0|		case preformatted_t:
  ------------------
  |  Branch (216:3): [True: 0, False: 13.3M]
  ------------------
  217|      0|			new (&data) preformatted_type(std::move(e.preformatted()));
  218|      0|			break;
  219|  13.3M|		}
  220|  13.3M|		m_type = t;
  221|  13.3M|#if TORRENT_USE_ASSERTS
  222|  13.3M|		m_type_queried = true;
  223|  13.3M|#endif
  224|  13.3M|		return *this;
  225|  13.3M|	}
_ZNK10libtorrent5entry7integerEv:
  239|   155k|	{
  240|   155k|		if (m_type != int_t) throw_error();
  ------------------
  |  Branch (240:7): [True: 0, False: 155k]
  ------------------
  241|       |#ifdef BOOST_NO_EXCEPTIONS
  242|       |		TORRENT_ASSERT(m_type_queried);
  243|       |#endif
  244|   155k|		TORRENT_ASSERT(m_type == int_t);
  ------------------
  |  |   95|   155k|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|   155k|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 155k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 155k, False: 0]
  |  |  ------------------
  ------------------
  245|   155k|		return *reinterpret_cast<const integer_type*>(&data);
  246|   155k|	}
_ZN10libtorrent5entry6stringEv:
  249|  6.01M|	{
  250|  6.01M|		if (m_type == undefined_t) construct(string_t);
  ------------------
  |  Branch (250:7): [True: 5.37k, False: 6.00M]
  ------------------
  251|       |#ifdef BOOST_NO_EXCEPTIONS
  252|       |		TORRENT_ASSERT(m_type_queried);
  253|       |#endif
  254|  6.01M|		if (m_type != string_t) throw_error();
  ------------------
  |  Branch (254:7): [True: 0, False: 6.01M]
  ------------------
  255|  6.01M|		TORRENT_ASSERT(m_type == string_t);
  ------------------
  |  |   95|  6.01M|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|  6.01M|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 6.01M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 6.01M, False: 0]
  |  |  ------------------
  ------------------
  256|  6.01M|		return *reinterpret_cast<string_type*>(&data);
  257|  6.01M|	}
_ZNK10libtorrent5entry6stringEv:
  260|  7.96M|	{
  261|  7.96M|		if (m_type != string_t) throw_error();
  ------------------
  |  Branch (261:7): [True: 0, False: 7.96M]
  ------------------
  262|       |#ifdef BOOST_NO_EXCEPTIONS
  263|       |		TORRENT_ASSERT(m_type_queried);
  264|       |#endif
  265|  7.96M|		TORRENT_ASSERT(m_type == string_t);
  ------------------
  |  |   95|  7.96M|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|  7.96M|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 7.96M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 7.96M, False: 0]
  |  |  ------------------
  ------------------
  266|  7.96M|		return *reinterpret_cast<const string_type*>(&data);
  267|  7.96M|	}
_ZN10libtorrent5entry4listEv:
  270|  3.41M|	{
  271|  3.41M|		if (m_type == undefined_t) construct(list_t);
  ------------------
  |  Branch (271:7): [True: 22.3k, False: 3.39M]
  ------------------
  272|       |#ifdef BOOST_NO_EXCEPTIONS
  273|       |		TORRENT_ASSERT(m_type_queried);
  274|       |#endif
  275|  3.41M|		if (m_type != list_t) throw_error();
  ------------------
  |  Branch (275:7): [True: 0, False: 3.41M]
  ------------------
  276|  3.41M|		TORRENT_ASSERT(m_type == list_t);
  ------------------
  |  |   95|  3.41M|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|  3.41M|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 3.41M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 3.41M, False: 0]
  |  |  ------------------
  ------------------
  277|  3.41M|		return *reinterpret_cast<list_type*>(&data);
  278|  3.41M|	}
_ZNK10libtorrent5entry4listEv:
  281|  23.3k|	{
  282|  23.3k|		if (m_type != list_t) throw_error();
  ------------------
  |  Branch (282:7): [True: 0, False: 23.3k]
  ------------------
  283|       |#ifdef BOOST_NO_EXCEPTIONS
  284|       |		TORRENT_ASSERT(m_type_queried);
  285|       |#endif
  286|  23.3k|		TORRENT_ASSERT(m_type == list_t);
  ------------------
  |  |   95|  23.3k|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|  23.3k|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 23.3k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 23.3k, False: 0]
  |  |  ------------------
  ------------------
  287|  23.3k|		return *reinterpret_cast<const list_type*>(&data);
  288|  23.3k|	}
_ZN10libtorrent5entry4dictEv:
  291|   619k|	{
  292|   619k|		if (m_type == undefined_t) construct(dictionary_t);
  ------------------
  |  Branch (292:7): [True: 5.02k, False: 614k]
  ------------------
  293|       |#ifdef BOOST_NO_EXCEPTIONS
  294|       |		TORRENT_ASSERT(m_type_queried);
  295|       |#endif
  296|   619k|		if (m_type != dictionary_t) throw_error();
  ------------------
  |  Branch (296:7): [True: 0, False: 619k]
  ------------------
  297|   619k|		TORRENT_ASSERT(m_type == dictionary_t);
  ------------------
  |  |   95|   619k|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|   619k|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 619k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 619k, False: 0]
  |  |  ------------------
  ------------------
  298|   619k|		return *reinterpret_cast<dictionary_type*>(&data);
  299|   619k|	}
_ZNK10libtorrent5entry4dictEv:
  302|  5.02k|	{
  303|  5.02k|		if (m_type != dictionary_t) throw_error();
  ------------------
  |  Branch (303:7): [True: 0, False: 5.02k]
  ------------------
  304|       |#ifdef BOOST_NO_EXCEPTIONS
  305|       |		TORRENT_ASSERT(m_type_queried);
  306|       |#endif
  307|  5.02k|		TORRENT_ASSERT(m_type == dictionary_t);
  ------------------
  |  |   95|  5.02k|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|  5.02k|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 5.02k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 5.02k, False: 0]
  |  |  ------------------
  ------------------
  308|  5.02k|		return *reinterpret_cast<const dictionary_type*>(&data);
  309|  5.02k|	}
_ZN10libtorrent5entry12preformattedEv:
  312|     98|	{
  313|     98|		if (m_type == undefined_t) construct(preformatted_t);
  ------------------
  |  Branch (313:7): [True: 98, False: 0]
  ------------------
  314|       |#ifdef BOOST_NO_EXCEPTIONS
  315|       |		TORRENT_ASSERT(m_type_queried);
  316|       |#endif
  317|     98|		if (m_type != preformatted_t) throw_error();
  ------------------
  |  Branch (317:7): [True: 0, False: 98]
  ------------------
  318|     98|		TORRENT_ASSERT(m_type == preformatted_t);
  ------------------
  |  |   95|     98|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|     98|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 98]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 98, False: 0]
  |  |  ------------------
  ------------------
  319|     98|		return *reinterpret_cast<preformatted_type*>(&data);
  320|     98|	}
_ZNK10libtorrent5entry12preformattedEv:
  323|    294|	{
  324|    294|		if (m_type != preformatted_t) throw_error();
  ------------------
  |  Branch (324:7): [True: 0, False: 294]
  ------------------
  325|       |#ifdef BOOST_NO_EXCEPTIONS
  326|       |		TORRENT_ASSERT(m_type_queried);
  327|       |#endif
  328|    294|		TORRENT_ASSERT(m_type == preformatted_t);
  ------------------
  |  |   95|    294|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|    294|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 294]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 294, False: 0]
  |  |  ------------------
  ------------------
  329|    294|		return *reinterpret_cast<const preformatted_type*>(&data);
  330|    294|	}
_ZN10libtorrent5entryC2Ev:
  333|  7.75M|		: m_type(undefined_t)
  334|  7.75M|	{
  335|  7.75M|#if TORRENT_USE_ASSERTS
  336|  7.75M|		m_type_queried = true;
  337|  7.75M|#endif
  338|  7.75M|	}
_ZN10libtorrent5entryC2EOS0_:
  359|  13.3M|		: m_type(undefined_t)
  360|  13.3M|	{
  361|  13.3M|		this->operator=(std::move(e));
  362|  13.3M|	}
_ZN10libtorrent5entryC2ENSt3__16vectorIS0_NS1_9allocatorIS0_EEEE:
  391|    902|		: m_type(undefined_t)
  392|    902|	{
  393|    902|#if TORRENT_USE_ASSERTS
  394|    902|		m_type_queried = true;
  395|    902|#endif
  396|    902|		new(&data) list_type(std::move(v));
  397|    902|		m_type = list_t;
  398|    902|	}
_ZNR10libtorrent5entryaSENS_4spanIKcEE:
  481|  10.0k|	{
  482|  10.0k|		destruct();
  483|  10.0k|		new(&data) string_type(v.data(), std::size_t(v.size()));
  484|  10.0k|		m_type = string_t;
  485|  10.0k|#if TORRENT_USE_ASSERTS
  486|  10.0k|		m_type_queried = true;
  487|  10.0k|#endif
  488|  10.0k|		return *this;
  489|  10.0k|	}
_ZNR10libtorrent5entryaSEl:
  503|   155k|	{
  504|   155k|		destruct();
  505|   155k|		new(&data) integer_type(std::move(v));
  506|   155k|		m_type = int_t;
  507|   155k|#if TORRENT_USE_ASSERTS
  508|   155k|		m_type_queried = true;
  509|   155k|#endif
  510|   155k|		return *this;
  511|   155k|	}
_ZN10libtorrent5entry9constructENS0_9data_typeE:
  536|  32.8k|	{
  537|  32.8k|		switch (t)
  ------------------
  |  Branch (537:11): [True: 32.8k, False: 0]
  ------------------
  538|  32.8k|		{
  539|      0|		case int_t:
  ------------------
  |  Branch (539:3): [True: 0, False: 32.8k]
  ------------------
  540|      0|			new (&data) integer_type(0);
  541|      0|			break;
  542|  5.37k|		case string_t:
  ------------------
  |  Branch (542:3): [True: 5.37k, False: 27.5k]
  ------------------
  543|  5.37k|			new (&data) string_type;
  544|  5.37k|			break;
  545|  22.3k|		case list_t:
  ------------------
  |  Branch (545:3): [True: 22.3k, False: 10.4k]
  ------------------
  546|  22.3k|			new (&data) list_type;
  547|  22.3k|			break;
  548|  5.02k|		case dictionary_t:
  ------------------
  |  Branch (548:3): [True: 5.02k, False: 27.8k]
  ------------------
  549|  5.02k|			new (&data) dictionary_type;
  550|  5.02k|			break;
  551|      0|		case undefined_t:
  ------------------
  |  Branch (551:3): [True: 0, False: 32.8k]
  ------------------
  552|      0|			break;
  553|     98|		case preformatted_t:
  ------------------
  |  Branch (553:3): [True: 98, False: 32.7k]
  ------------------
  554|     98|			new (&data) preformatted_type;
  555|     98|			break;
  556|  32.8k|		}
  557|  32.8k|		m_type = t;
  558|  32.8k|#if TORRENT_USE_ASSERTS
  559|  32.8k|		m_type_queried = true;
  560|  32.8k|#endif
  561|  32.8k|	}
_ZN10libtorrent5entry8destructEv:
  593|  38.6M|	{
  594|  38.6M|		switch(m_type)
  595|  38.6M|		{
  596|   155k|		case int_t:
  ------------------
  |  Branch (596:3): [True: 155k, False: 38.5M]
  ------------------
  597|   155k|			call_destructor(reinterpret_cast<integer_type*>(&data));
  598|   155k|			break;
  599|  9.99M|		case string_t:
  ------------------
  |  Branch (599:3): [True: 9.99M, False: 28.6M]
  ------------------
  600|  9.99M|			call_destructor(reinterpret_cast<string_type*>(&data));
  601|  9.99M|			break;
  602|  38.5k|		case list_t:
  ------------------
  |  Branch (602:3): [True: 38.5k, False: 38.6M]
  ------------------
  603|  38.5k|			call_destructor(reinterpret_cast<list_type*>(&data));
  604|  38.5k|			break;
  605|  5.02k|		case dictionary_t:
  ------------------
  |  Branch (605:3): [True: 5.02k, False: 38.6M]
  ------------------
  606|  5.02k|			call_destructor(reinterpret_cast<dictionary_type*>(&data));
  607|  5.02k|			break;
  608|     98|		case preformatted_t:
  ------------------
  |  Branch (608:3): [True: 98, False: 38.6M]
  ------------------
  609|     98|			call_destructor(reinterpret_cast<preformatted_type*>(&data));
  610|     98|			break;
  611|  28.4M|		default:
  ------------------
  |  Branch (611:3): [True: 28.4M, False: 10.1M]
  ------------------
  612|  28.4M|			TORRENT_ASSERT(m_type == undefined_t);
  ------------------
  |  |   95|  28.4M|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|  28.4M|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 28.4M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 28.4M, False: 0]
  |  |  ------------------
  ------------------
  613|  28.4M|			break;
  614|  38.6M|		}
  615|  38.6M|		m_type = undefined_t;
  616|  38.6M|#if TORRENT_USE_ASSERTS
  617|  38.6M|		m_type_queried = false;
  618|  38.6M|#endif
  619|  38.6M|	}
entry.cpp:_ZN10libtorrent12_GLOBAL__N_115call_destructorIlEEvPT_:
  119|   155k|	{
  120|   155k|		TORRENT_ASSERT(o);
  ------------------
  |  |   95|   155k|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|   155k|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 155k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 155k, False: 0]
  |  |  ------------------
  ------------------
  121|   155k|		o->~T();
  122|   155k|	}
entry.cpp:_ZN10libtorrent12_GLOBAL__N_115call_destructorINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEvPT_:
  119|  9.99M|	{
  120|  9.99M|		TORRENT_ASSERT(o);
  ------------------
  |  |   95|  9.99M|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|  9.99M|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 9.99M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 9.99M, False: 0]
  |  |  ------------------
  ------------------
  121|  9.99M|		o->~T();
  122|  9.99M|	}
entry.cpp:_ZN10libtorrent12_GLOBAL__N_115call_destructorINSt3__16vectorINS_5entryENS2_9allocatorIS4_EEEEEEvPT_:
  119|  38.5k|	{
  120|  38.5k|		TORRENT_ASSERT(o);
  ------------------
  |  |   95|  38.5k|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|  38.5k|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 38.5k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 38.5k, False: 0]
  |  |  ------------------
  ------------------
  121|  38.5k|		o->~T();
  122|  38.5k|	}
entry.cpp:_ZN10libtorrent12_GLOBAL__N_115call_destructorINSt3__13mapINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS_5entryENS_3aux12strview_lessENS7_INS2_4pairIKS9_SA_EEEEEEEEvPT_:
  119|  5.02k|	{
  120|  5.02k|		TORRENT_ASSERT(o);
  ------------------
  |  |   95|  5.02k|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|  5.02k|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 5.02k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 5.02k, False: 0]
  |  |  ------------------
  ------------------
  121|  5.02k|		o->~T();
  122|  5.02k|	}
entry.cpp:_ZN10libtorrent12_GLOBAL__N_115call_destructorINSt3__16vectorIcNS2_9allocatorIcEEEEEEvPT_:
  119|     98|	{
  120|     98|		TORRENT_ASSERT(o);
  ------------------
  |  |   95|     98|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|     98|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 98]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 98, False: 0]
  |  |  ------------------
  ------------------
  121|     98|		o->~T();
  122|     98|	}

_ZN10libtorrent19libtorrent_categoryEv:
  305|  3.37M|	{
  306|  3.37M|		static libtorrent_error_category libtorrent_category;
  307|  3.37M|		return libtorrent_category;
  308|  3.37M|	}
_ZN10libtorrent6errors15make_error_codeENS0_15error_code_enumE:
  357|  3.37M|		{
  358|  3.37M|			return {e, libtorrent_category()};
  359|  3.37M|		}

_ZN10libtorrent12file_storageC2Ev:
   80|     98|	file_storage::file_storage() = default;
_ZN10libtorrent12file_storageD2Ev:
   81|     98|	file_storage::~file_storage() = default;

_ZN10libtorrent7lcrypto6hasherC2Ev:
   48|    314|	{
   49|       |#ifdef TORRENT_USE_LIBGCRYPT
   50|       |		gcry_md_open(&m_context, GCRY_MD_SHA1, 0);
   51|       |#elif TORRENT_USE_COMMONCRYPTO
   52|       |		CC_SHA1_Init(&m_context);
   53|       |#elif TORRENT_USE_CNG
   54|       |#elif TORRENT_USE_CRYPTOAPI
   55|       |#elif defined TORRENT_USE_LIBCRYPTO
   56|       |		SHA1_Init(&m_context);
   57|       |#else
   58|       |		SHA1_init(&m_context);
   59|       |#endif
   60|    314|	}
_ZN10libtorrent7lcrypto6hasherC2ENS_4spanIKcEE:
   63|    314|		: hasher()
   64|    314|	{
   65|    314|		update(data);
   66|    314|	}
_ZN10libtorrent7lcrypto6hasher6updateENS_4spanIKcEE:
   99|    314|	{
  100|    314|		TORRENT_ASSERT(data.size() > 0);
  ------------------
  |  |   95|    314|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|    314|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 314]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 314, False: 0]
  |  |  ------------------
  ------------------
  101|       |#ifdef TORRENT_USE_LIBGCRYPT
  102|       |		gcry_md_write(m_context, data.data(), static_cast<std::size_t>(data.size()));
  103|       |#elif TORRENT_USE_COMMONCRYPTO
  104|       |		CC_SHA1_Update(&m_context, reinterpret_cast<unsigned char const*>(data.data()), CC_LONG(data.size()));
  105|       |#elif TORRENT_USE_CNG
  106|       |		m_context.update(data);
  107|       |#elif TORRENT_USE_CRYPTOAPI
  108|       |		m_context.update(data);
  109|       |#elif defined TORRENT_USE_LIBCRYPTO
  110|       |		SHA1_Update(&m_context, reinterpret_cast<unsigned char const*>(data.data())
  111|    314|			, static_cast<std::size_t>(data.size()));
  112|       |#else
  113|       |		SHA1_update(&m_context, reinterpret_cast<unsigned char const*>(data.data())
  114|       |			, static_cast<std::size_t>(data.size()));
  115|       |#endif
  116|    314|		return *this;
  117|    314|	}
_ZN10libtorrent7lcrypto6hasher5finalEv:
  120|    314|	{
  121|    314|		sha1_hash digest;
  122|       |#ifdef TORRENT_USE_LIBGCRYPT
  123|       |		gcry_md_final(m_context);
  124|       |		digest.assign(reinterpret_cast<char const*>(gcry_md_read(m_context, 0)));
  125|       |#elif TORRENT_USE_COMMONCRYPTO
  126|       |		CC_SHA1_Final(reinterpret_cast<unsigned char*>(digest.data()), &m_context);
  127|       |#elif TORRENT_USE_CNG
  128|       |		m_context.get_hash(digest.data(), digest.size());
  129|       |#elif TORRENT_USE_CRYPTOAPI
  130|       |		m_context.get_hash(digest.data(), digest.size());
  131|       |#elif defined TORRENT_USE_LIBCRYPTO
  132|       |		SHA1_Final(reinterpret_cast<unsigned char*>(digest.data()), &m_context);
  133|       |#else
  134|       |		SHA1_final(reinterpret_cast<unsigned char*>(digest.data()), &m_context);
  135|       |#endif
  136|    314|		return digest;
  137|    314|	}
_ZN10libtorrent7lcrypto6hasherD2Ev:
  157|    314|	{
  158|       |#if defined TORRENT_USE_LIBGCRYPT
  159|       |		gcry_md_close(m_context);
  160|       |#endif
  161|    314|	}
_ZN10libtorrent7lcrypto9hasher256C2Ev:
  164|    314|	{
  165|       |#ifdef TORRENT_USE_LIBGCRYPT
  166|       |		gcry_md_open(&m_context, GCRY_MD_SHA256, 0);
  167|       |#elif TORRENT_USE_COMMONCRYPTO
  168|       |		CC_SHA256_Init(&m_context);
  169|       |#elif TORRENT_USE_CNG
  170|       |#elif TORRENT_USE_CRYPTOAPI_SHA_512
  171|       |#elif defined TORRENT_USE_LIBCRYPTO
  172|       |		SHA256_Init(&m_context);
  173|       |#else
  174|       |		SHA256_init(m_context);
  175|       |#endif
  176|    314|	}
_ZN10libtorrent7lcrypto9hasher256C2ENS_4spanIKcEE:
  179|    314|		: hasher256()
  180|    314|	{
  181|    314|		update(data);
  182|    314|	}
_ZN10libtorrent7lcrypto9hasher2566updateENS_4spanIKcEE:
  215|    314|	{
  216|    314|		TORRENT_ASSERT(!data.empty());
  ------------------
  |  |   95|    314|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|    314|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 314]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 314, False: 0]
  |  |  ------------------
  ------------------
  217|       |#ifdef TORRENT_USE_LIBGCRYPT
  218|       |		gcry_md_write(m_context, data.data(), data.size());
  219|       |#elif TORRENT_USE_COMMONCRYPTO
  220|       |		CC_SHA256_Update(&m_context, reinterpret_cast<unsigned char const*>(data.data()), CC_LONG(data.size()));
  221|       |#elif TORRENT_USE_CNG
  222|       |		m_context.update(data);
  223|       |#elif TORRENT_USE_CRYPTOAPI_SHA_512
  224|       |		m_context.update(data);
  225|       |#elif defined TORRENT_USE_LIBCRYPTO
  226|       |		SHA256_Update(&m_context, reinterpret_cast<unsigned char const*>(data.data())
  227|    314|			, static_cast<std::size_t>(data.size()));
  228|       |#else
  229|       |		SHA256_update(m_context, reinterpret_cast<unsigned char const*>(data.data())
  230|       |			, static_cast<std::size_t>(data.size()));
  231|       |#endif
  232|    314|		return *this;
  233|    314|	}
_ZN10libtorrent7lcrypto9hasher2565finalEv:
  236|    314|	{
  237|    314|		sha256_hash digest;
  238|       |#ifdef TORRENT_USE_LIBGCRYPT
  239|       |		gcry_md_final(m_context);
  240|       |		digest.assign((char const*)gcry_md_read(m_context, 0));
  241|       |#elif TORRENT_USE_COMMONCRYPTO
  242|       |		CC_SHA256_Final(reinterpret_cast<unsigned char*>(digest.data()), &m_context);
  243|       |#elif TORRENT_USE_CNG
  244|       |		m_context.get_hash(digest.data(), digest.size());
  245|       |#elif TORRENT_USE_CRYPTOAPI_SHA_512
  246|       |		m_context.get_hash(digest.data(), digest.size());
  247|       |#elif defined TORRENT_USE_LIBCRYPTO
  248|       |		SHA256_Final(reinterpret_cast<unsigned char*>(digest.data()), &m_context);
  249|       |#else
  250|       |		SHA256_final(reinterpret_cast<unsigned char*>(digest.data()), m_context);
  251|       |#endif
  252|    314|		return digest;
  253|    314|	}
_ZN10libtorrent7lcrypto9hasher256D2Ev:
  273|    314|	{
  274|       |#if defined TORRENT_USE_LIBGCRYPT
  275|       |		gcry_md_close(m_context);
  276|       |#endif
  277|    314|	}

_ZN10libtorrent20parse_url_componentsENSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEERN5boost6system10error_codeE:
   45|  3.38M|	{
   46|  3.38M|		std::string hostname; // hostname only
   47|  3.38M|		std::string auth; // user:pass
   48|  3.38M|		std::string protocol; // http or https for instance
   49|  3.38M|		int port = -1;
   50|       |
   51|  3.38M|		std::string::iterator at;
   52|  3.38M|		std::string::iterator colon;
   53|  3.38M|		std::string::iterator port_pos;
   54|       |
   55|       |		// PARSE URL
   56|  3.38M|		auto start = url.begin();
   57|       |		// remove white spaces in front of the url
   58|  3.38M|		while (start != url.end() && is_space(*start))
  ------------------
  |  Branch (58:10): [True: 10.5k, False: 3.37M]
  |  Branch (58:10): [True: 1.85k, False: 3.38M]
  |  Branch (58:32): [True: 1.85k, False: 8.68k]
  ------------------
   59|  1.85k|			++start;
   60|  3.38M|		auto end = std::find(url.begin(), url.end(), ':');
   61|  3.38M|		protocol.assign(start, end);
   62|       |
   63|  3.38M|		if (end == url.end())
  ------------------
  |  Branch (63:7): [True: 3.37M, False: 7.48k]
  ------------------
   64|  3.37M|		{
   65|  3.37M|			ec = errors::unsupported_url_protocol;
   66|  3.37M|			goto exit;
   67|  3.37M|		}
   68|  7.48k|		++end;
   69|  7.48k|		if (end == url.end() || *end != '/')
  ------------------
  |  Branch (69:7): [True: 512, False: 6.97k]
  |  Branch (69:7): [True: 1.64k, False: 5.84k]
  |  Branch (69:27): [True: 1.13k, False: 5.84k]
  ------------------
   70|  1.64k|		{
   71|  1.64k|			ec = errors::unsupported_url_protocol;
   72|  1.64k|			goto exit;
   73|  1.64k|		}
   74|  5.84k|		++end;
   75|  5.84k|		if (end == url.end() || *end != '/')
  ------------------
  |  Branch (75:7): [True: 209, False: 5.63k]
  |  Branch (75:7): [True: 396, False: 5.44k]
  |  Branch (75:27): [True: 187, False: 5.44k]
  ------------------
   76|    396|		{
   77|    396|			ec = errors::unsupported_url_protocol;
   78|    396|			goto exit;
   79|    396|		}
   80|  5.44k|		++end;
   81|  5.44k|		start = end;
   82|       |
   83|  5.44k|		at = std::find(start, url.end(), '@');
   84|  5.44k|		colon = std::find(start, url.end(), ':');
   85|  5.44k|		end = std::min({
   86|  5.44k|			std::find(start, url.end(), '/')
   87|  5.44k|			, std::find(start, url.end(), '?')
   88|  5.44k|			, std::find(start, url.end(), '#')
   89|  5.44k|			});
   90|       |
   91|  5.44k|		if (at != url.end()
  ------------------
  |  Branch (91:7): [True: 1.49k, False: 3.95k]
  |  Branch (91:7): [True: 424, False: 5.02k]
  ------------------
   92|  1.49k|			&& colon != url.end()
  ------------------
  |  Branch (92:7): [True: 936, False: 555]
  ------------------
   93|    936|			&& colon < at
  ------------------
  |  Branch (93:7): [True: 443, False: 493]
  ------------------
   94|    443|			&& at < end)
  ------------------
  |  Branch (94:7): [True: 424, False: 19]
  ------------------
   95|    424|		{
   96|    424|			auth.assign(start, at);
   97|    424|			start = at;
   98|    424|			++start;
   99|    424|		}
  100|       |
  101|       |		// this is for IPv6 addresses
  102|  5.44k|		if (start != url.end() && *start == '[')
  ------------------
  |  Branch (102:7): [True: 4.96k, False: 479]
  |  Branch (102:7): [True: 1.69k, False: 3.75k]
  |  Branch (102:29): [True: 1.69k, False: 3.27k]
  ------------------
  103|  1.69k|		{
  104|  1.69k|			port_pos = std::find(start, url.end(), ']');
  105|  1.69k|			if (port_pos == url.end())
  ------------------
  |  Branch (105:8): [True: 266, False: 1.42k]
  ------------------
  106|    266|			{
  107|    266|				ec = errors::expected_close_bracket_in_address;
  108|    266|				goto exit;
  109|    266|			}
  110|       |			// strip the brackets
  111|  1.42k|			hostname.assign(start + 1, port_pos);
  112|  1.42k|			port_pos = std::find(port_pos, url.end(), ':');
  113|  1.42k|		}
  114|  3.75k|		else
  115|  3.75k|		{
  116|  3.75k|			port_pos = std::find(start, url.end(), ':');
  117|  3.75k|			if (port_pos < end) hostname.assign(start, port_pos);
  ------------------
  |  Branch (117:8): [True: 2.08k, False: 1.66k]
  ------------------
  118|  1.66k|			else hostname.assign(start, end);
  119|  3.75k|		}
  120|       |
  121|  5.18k|		if (port_pos < end)
  ------------------
  |  Branch (121:7): [True: 2.67k, False: 2.50k]
  ------------------
  122|  2.67k|		{
  123|  2.67k|			++port_pos;
  124|  15.6k|			for (auto i = port_pos; i < end; ++i)
  ------------------
  |  Branch (124:28): [True: 13.8k, False: 1.79k]
  ------------------
  125|  13.8k|			{
  126|  13.8k|				if (is_digit(*i)) continue;
  ------------------
  |  Branch (126:9): [True: 12.9k, False: 888]
  ------------------
  127|    888|				ec = errors::invalid_port;
  128|    888|				goto exit;
  129|  13.8k|			}
  130|  1.79k|			port = std::atoi(std::string(port_pos, end).c_str());
  131|  1.79k|		}
  132|       |
  133|  4.29k|		start = end;
  134|  3.38M|exit:
  135|  3.38M|		std::string path_component(start, url.end());
  136|  3.38M|		if (path_component.empty()
  ------------------
  |  Branch (136:7): [True: 3.37M, False: 6.15k]
  ------------------
  137|  6.15k|			|| path_component.front() == '?'
  ------------------
  |  Branch (137:7): [True: 1.15k, False: 5.00k]
  ------------------
  138|  5.00k|			|| path_component.front() == '#')
  ------------------
  |  Branch (138:7): [True: 937, False: 4.06k]
  ------------------
  139|  3.37M|		{
  140|  3.37M|			path_component.insert(path_component.begin(), '/');
  141|  3.37M|		}
  142|       |
  143|  3.38M|		return std::make_tuple(std::move(protocol)
  144|  3.38M|			, std::move(auth)
  145|  3.38M|			, std::move(hostname)
  146|  3.38M|			, port
  147|  3.38M|			, path_component);
  148|  4.29k|	}

_ZN10libtorrent16read_resume_dataERKNS_12bdecode_nodeERN5boost6system10error_codeEi:
   71|  4.17k|	{
   72|  4.17k|		add_torrent_params ret;
   73|  4.17k|		if (rd.type() != bdecode_node::dict_t)
  ------------------
  |  Branch (73:7): [True: 41, False: 4.13k]
  ------------------
   74|     41|		{
   75|     41|			ec = errors::not_a_dictionary;
   76|     41|			return ret;
   77|     41|		}
   78|       |
   79|  4.13k|		if (bdecode_node const alloc = rd.dict_find_string("allocation"))
  ------------------
  |  Branch (79:26): [True: 71, False: 4.06k]
  ------------------
   80|     71|		{
   81|     71|			ret.storage_mode = (alloc.string_value() == "allocate"
  ------------------
  |  Branch (81:24): [True: 1, False: 70]
  ------------------
   82|     70|				|| alloc.string_value() == "full")
  ------------------
  |  Branch (82:8): [True: 1, False: 69]
  ------------------
   83|     71|				? storage_mode_allocate : storage_mode_sparse;
   84|     71|		}
   85|       |
   86|  4.13k|		if (rd.dict_find_string_value("file-format")
  ------------------
  |  Branch (86:7): [True: 250, False: 3.88k]
  ------------------
   87|  4.13k|			!= "libtorrent resume file")
   88|    250|		{
   89|    250|			ec = errors::invalid_file_tag;
   90|    250|			return ret;
   91|    250|		}
   92|       |
   93|  3.88k|		std::int64_t const file_version = rd.dict_find_int_value("file-version", 1);
   94|       |
   95|  3.88k|		if (file_version != 1 && file_version != 2)
  ------------------
  |  Branch (95:7): [True: 318, False: 3.56k]
  |  Branch (95:28): [True: 257, False: 61]
  ------------------
   96|    257|		{
   97|    257|			ec = errors::invalid_file_tag;
   98|    257|			return ret;
   99|    257|		}
  100|       |
  101|  3.62k|		auto info_hash = rd.dict_find_string_value("info-hash");
  102|  3.62k|		auto info_hash2 = rd.dict_find_string_value("info-hash2");
  103|  3.62k|		if (info_hash.size() != std::size_t(sha1_hash::size())
  ------------------
  |  Branch (103:7): [True: 152, False: 3.47k]
  ------------------
  104|    152|			&& info_hash2.size() != std::size_t(sha256_hash::size()))
  ------------------
  |  Branch (104:7): [True: 44, False: 108]
  ------------------
  105|     44|		{
  106|     44|			ec = errors::missing_info_hash;
  107|     44|			return ret;
  108|     44|		}
  109|       |
  110|  3.58k|		ret.name = rd.dict_find_string_value("name").to_string();
  111|       |
  112|  3.58k|		if (info_hash.size() == 20)
  ------------------
  |  Branch (112:7): [True: 3.47k, False: 108]
  ------------------
  113|  3.47k|			ret.info_hashes.v1.assign(info_hash.data());
  114|  3.58k|		if (info_hash2.size() == 32)
  ------------------
  |  Branch (114:7): [True: 114, False: 3.46k]
  ------------------
  115|    114|			ret.info_hashes.v2.assign(info_hash2.data());
  116|       |
  117|  3.58k|		bdecode_node const info = rd.dict_find_dict("info");
  118|  3.58k|		if (info)
  ------------------
  |  Branch (118:7): [True: 216, False: 3.36k]
  ------------------
  119|    216|		{
  120|       |			// verify the info-hash of the metadata stored in the resume file matches
  121|       |			// the torrent we're loading
  122|    216|			info_hash_t const resume_ih(hasher(info.data_section()).final()
  123|    216|				, hasher256(info.data_section()).final());
  124|       |
  125|       |			// if url is set, the info_hash is not actually the info-hash of the
  126|       |			// torrent, but the hash of the URL, until we have the full torrent
  127|       |			// only require the info-hash to match if we actually passed in one
  128|    216|			if ((!ret.info_hashes.has_v1() || resume_ih.v1 == ret.info_hashes.v1)
  ------------------
  |  Branch (128:9): [True: 153, False: 63]
  |  Branch (128:38): [True: 0, False: 63]
  ------------------
  129|    153|				&& (!ret.info_hashes.has_v2() || resume_ih.v2 == ret.info_hashes.v2))
  ------------------
  |  Branch (129:9): [True: 98, False: 55]
  |  Branch (129:38): [True: 0, False: 55]
  ------------------
  130|     98|			{
  131|     98|				ret.ti = std::make_shared<torrent_info>(resume_ih);
  132|       |
  133|     98|				error_code err;
  134|     98|				if (!ret.ti->parse_info_section(info, err, piece_limit))
  ------------------
  |  Branch (134:9): [True: 98, False: 0]
  ------------------
  135|     98|				{
  136|     98|					ec = err;
  137|     98|				}
  138|      0|				else
  139|      0|				{
  140|       |					// time_t might be 32 bit if we're unlucky, but there isn't
  141|       |					// much to do about it
  142|      0|					ret.ti->internal_set_creation_date(static_cast<std::time_t>(
  143|      0|						rd.dict_find_int_value("creation date", 0)));
  144|      0|					ret.ti->internal_set_creator(rd.dict_find_string_value("created by", ""));
  145|      0|					ret.ti->internal_set_comment(rd.dict_find_string_value("comment", ""));
  146|      0|				}
  147|     98|			}
  148|    118|			else
  149|    118|			{
  150|    118|				ec = errors::mismatching_info_hash;
  151|    118|			}
  152|    216|		}
  153|       |
  154|  3.58k|#if TORRENT_ABI_VERSION < 3
  155|  3.58k|		ret.info_hash = ret.info_hashes.get_best();
  156|  3.58k|#endif
  157|       |
  158|  3.58k|		bdecode_node const trees = rd.dict_find_list("trees");
  159|  3.58k|		if (trees)
  ------------------
  |  Branch (159:7): [True: 62, False: 3.52k]
  ------------------
  160|     62|		{
  161|     62|			ret.merkle_trees.reserve(trees.list_size());
  162|     62|			ret.verified_leaf_hashes.reserve(trees.list_size());
  163|     62|			ret.merkle_tree_mask.reserve(trees.list_size());
  164|     62|			for (int i = 0; i < trees.list_size(); ++i)
  ------------------
  |  Branch (164:20): [True: 55, False: 7]
  ------------------
  165|     55|			{
  166|     55|				auto de = trees.list_at(i);
  167|     55|				if (de.type() != bdecode_node::dict_t)
  ------------------
  |  Branch (167:9): [True: 36, False: 19]
  ------------------
  168|     36|					break;
  169|     19|				auto dh = de.dict_find_string("hashes");
  170|     19|				if (!dh || dh.string_length() % 32 != 0) break;
  ------------------
  |  Branch (170:9): [True: 19, False: 0]
  |  Branch (170:16): [True: 0, False: 0]
  ------------------
  171|       |
  172|      0|				ret.merkle_trees.emplace_back();
  173|      0|				ret.merkle_trees.back().reserve(dh.string_value().size() / 32);
  174|      0|				for (auto hashes = dh.string_value();
  175|      0|					!hashes.empty(); hashes = hashes.substr(32))
  ------------------
  |  Branch (175:6): [True: 0, False: 0]
  ------------------
  176|      0|				{
  177|      0|					ret.merkle_trees.back().emplace_back(hashes);
  178|      0|				}
  179|       |
  180|      0|				if (bdecode_node const verified = de.dict_find_string("verified"))
  ------------------
  |  Branch (180:28): [True: 0, False: 0]
  ------------------
  181|      0|				{
  182|      0|					string_view const str = verified.string_value();
  183|      0|					if (file_version == 1)
  ------------------
  |  Branch (183:10): [True: 0, False: 0]
  ------------------
  184|      0|					{
  185|      0|						ret.verified_leaf_hashes.emplace_back(str.size());
  186|      0|						auto& v = ret.verified_leaf_hashes.back();
  187|      0|						for (std::size_t j = 0; j < str.size(); ++j)
  ------------------
  |  Branch (187:31): [True: 0, False: 0]
  ------------------
  188|      0|						{
  189|      0|							if (str[j] == '1')
  ------------------
  |  Branch (189:12): [True: 0, False: 0]
  ------------------
  190|      0|								v[j] = true;
  191|      0|						}
  192|      0|					}
  193|      0|					else
  194|      0|					{
  195|      0|						ret.verified_leaf_hashes.emplace_back(str.size() * 8);
  196|      0|						auto& v = ret.verified_leaf_hashes.back();
  197|      0|						for (std::size_t j = 0; j < v.size(); ++j)
  ------------------
  |  Branch (197:31): [True: 0, False: 0]
  ------------------
  198|      0|						{
  199|      0|							if (str[j / 8] & (0x80 >> (j % 8)))
  ------------------
  |  Branch (199:12): [True: 0, False: 0]
  ------------------
  200|      0|								v[j] = true;
  201|      0|						}
  202|      0|					}
  203|      0|				}
  204|      0|				else
  205|      0|				{
  206|      0|					ret.verified_leaf_hashes.emplace_back();
  207|      0|				}
  208|       |
  209|      0|				if (bdecode_node const mask = de.dict_find_string("mask"))
  ------------------
  |  Branch (209:28): [True: 0, False: 0]
  ------------------
  210|      0|				{
  211|      0|					string_view const str = mask.string_value();
  212|      0|					if (file_version == 1)
  ------------------
  |  Branch (212:10): [True: 0, False: 0]
  ------------------
  213|      0|					{
  214|      0|						ret.merkle_tree_mask.emplace_back(str.size());
  215|      0|						auto& m = ret.merkle_tree_mask.back();
  216|      0|						for (std::size_t j = 0; j < str.size(); ++j)
  ------------------
  |  Branch (216:31): [True: 0, False: 0]
  ------------------
  217|      0|						{
  218|      0|							if (str[j] == '1')
  ------------------
  |  Branch (218:12): [True: 0, False: 0]
  ------------------
  219|      0|								m[j] = true;
  220|      0|						}
  221|      0|					}
  222|      0|					else
  223|      0|					{
  224|      0|						ret.merkle_tree_mask.emplace_back(str.size() * 8);
  225|      0|						auto& m = ret.merkle_tree_mask.back();
  226|      0|						for (std::size_t j = 0; j < m.size(); ++j)
  ------------------
  |  Branch (226:31): [True: 0, False: 0]
  ------------------
  227|      0|						{
  228|      0|							if (str[j / 8] & (0x80 >> (j % 8)))
  ------------------
  |  Branch (228:12): [True: 0, False: 0]
  ------------------
  229|      0|								m[j] = true;
  230|      0|						}
  231|      0|					}
  232|      0|				}
  233|      0|				else
  234|      0|				{
  235|      0|					ret.merkle_tree_mask.emplace_back();
  236|      0|				}
  237|      0|			}
  238|       |
  239|     62|			TORRENT_ASSERT(ret.merkle_trees.size() == ret.merkle_tree_mask.size());
  ------------------
  |  |   95|     62|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|     62|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 62]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 62, False: 0]
  |  |  ------------------
  ------------------
  240|     62|			TORRENT_ASSERT(ret.merkle_tree_mask.size() == ret.verified_leaf_hashes.size());
  ------------------
  |  |   95|     62|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|     62|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 62]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 62, False: 0]
  |  |  ------------------
  ------------------
  241|     62|		}
  242|       |
  243|  3.58k|		ret.total_uploaded = rd.dict_find_int_value("total_uploaded");
  244|  3.58k|		ret.total_downloaded = rd.dict_find_int_value("total_downloaded");
  245|       |
  246|  3.58k|		ret.active_time = int(rd.dict_find_int_value("active_time"));
  247|  3.58k|		ret.finished_time = int(rd.dict_find_int_value("finished_time"));
  248|  3.58k|		ret.seeding_time = int(rd.dict_find_int_value("seeding_time"));
  249|       |
  250|  3.58k|		ret.last_seen_complete = std::time_t(rd.dict_find_int_value("last_seen_complete"));
  251|       |
  252|  3.58k|		ret.last_download = std::time_t(rd.dict_find_int_value("last_download", 0));
  253|  3.58k|		ret.last_upload = std::time_t(rd.dict_find_int_value("last_upload", 0));
  254|       |
  255|       |		// scrape data cache
  256|  3.58k|		ret.num_complete = int(rd.dict_find_int_value("num_complete", -1));
  257|  3.58k|		ret.num_incomplete = int(rd.dict_find_int_value("num_incomplete", -1));
  258|  3.58k|		ret.num_downloaded = int(rd.dict_find_int_value("num_downloaded", -1));
  259|       |
  260|       |		// torrent settings
  261|  3.58k|		ret.max_uploads = int(rd.dict_find_int_value("max_uploads", -1));
  262|  3.58k|		ret.max_connections = int(rd.dict_find_int_value("max_connections", -1));
  263|  3.58k|		ret.upload_limit = int(rd.dict_find_int_value("upload_rate_limit", -1));
  264|  3.58k|		ret.download_limit = int(rd.dict_find_int_value("download_rate_limit", -1));
  265|       |
  266|       |		// torrent flags
  267|  3.58k|		apply_flag(ret.flags, rd, "seed_mode", torrent_flags::seed_mode);
  268|  3.58k|		apply_flag(ret.flags, rd, "upload_mode", torrent_flags::upload_mode);
  269|  3.58k|#ifndef TORRENT_DISABLE_SHARE_MODE
  270|  3.58k|		apply_flag(ret.flags, rd, "share_mode", torrent_flags::share_mode);
  271|  3.58k|#endif
  272|  3.58k|		apply_flag(ret.flags, rd, "apply_ip_filter", torrent_flags::apply_ip_filter);
  273|  3.58k|		apply_flag(ret.flags, rd, "paused", torrent_flags::paused);
  274|  3.58k|		apply_flag(ret.flags, rd, "auto_managed", torrent_flags::auto_managed);
  275|  3.58k|#ifndef TORRENT_DISABLE_SUPERSEEDING
  276|  3.58k|		apply_flag(ret.flags, rd, "super_seeding", torrent_flags::super_seeding);
  277|  3.58k|#endif
  278|  3.58k|#if TORRENT_USE_I2P
  279|  3.58k|		apply_flag(ret.flags, rd, "i2p", torrent_flags::i2p_torrent);
  280|  3.58k|#endif
  281|  3.58k|		apply_flag(ret.flags, rd, "sequential_download", torrent_flags::sequential_download);
  282|  3.58k|		apply_flag(ret.flags, rd, "stop_when_ready", torrent_flags::stop_when_ready);
  283|  3.58k|		apply_flag(ret.flags, rd, "disable_dht", torrent_flags::disable_dht);
  284|  3.58k|		apply_flag(ret.flags, rd, "disable_lsd", torrent_flags::disable_lsd);
  285|  3.58k|		apply_flag(ret.flags, rd, "disable_pex", torrent_flags::disable_pex);
  286|       |
  287|  3.58k|		ret.save_path = rd.dict_find_string_value("save_path").to_string();
  288|       |
  289|  3.58k|#if TORRENT_ABI_VERSION == 1
  290|       |		// deprecated in 1.2
  291|  3.58k|		ret.url = rd.dict_find_string_value("url").to_string();
  292|  3.58k|#endif
  293|       |
  294|  3.58k|		bdecode_node const mapped_files = rd.dict_find_list("mapped_files");
  295|  3.58k|		if (mapped_files)
  ------------------
  |  Branch (295:7): [True: 246, False: 3.33k]
  ------------------
  296|    246|		{
  297|  7.45M|			for (int i = 0; i < mapped_files.list_size(); ++i)
  ------------------
  |  Branch (297:20): [True: 7.45M, False: 246]
  ------------------
  298|  7.45M|			{
  299|  7.45M|				auto new_filename = mapped_files.list_string_value_at(i);
  300|  7.45M|				if (new_filename.empty()) continue;
  ------------------
  |  Branch (300:9): [True: 7.39M, False: 61.7k]
  ------------------
  301|  61.7k|				ret.renamed_files[file_index_t(i)] = new_filename.to_string();
  302|  61.7k|			}
  303|    246|		}
  304|       |
  305|  3.58k|		ret.added_time = std::time_t(rd.dict_find_int_value("added_time", 0));
  306|  3.58k|		ret.completed_time = std::time_t(rd.dict_find_int_value("completed_time", 0));
  307|       |
  308|       |		// load file priorities except if the add_torrent_param file was set to
  309|       |		// override resume data
  310|  3.58k|		bdecode_node const file_priority = rd.dict_find_list("file_priority");
  311|  3.58k|		if (file_priority)
  ------------------
  |  Branch (311:7): [True: 0, False: 3.58k]
  ------------------
  312|      0|		{
  313|      0|			int const num_files = file_priority.list_size();
  314|      0|			ret.file_priorities.resize(aux::numeric_cast<std::size_t>(num_files)
  315|      0|				, default_priority);
  316|      0|			for (int i = 0; i < num_files; ++i)
  ------------------
  |  Branch (316:20): [True: 0, False: 0]
  ------------------
  317|      0|			{
  318|      0|				auto const idx = static_cast<std::size_t>(i);
  319|      0|				ret.file_priorities[idx] = aux::clamp(
  320|      0|					download_priority_t(static_cast<std::uint8_t>(
  321|      0|						file_priority.list_int_value_at(i
  322|      0|							, static_cast<std::uint8_t>(default_priority))))
  323|      0|						, dont_download, top_priority);
  324|       |				// this is suspicious, leave seed mode
  325|      0|				if (ret.file_priorities[idx] == dont_download)
  ------------------
  |  Branch (325:9): [True: 0, False: 0]
  ------------------
  326|      0|				{
  327|      0|					ret.flags &= ~torrent_flags::seed_mode;
  328|      0|				}
  329|      0|			}
  330|      0|		}
  331|       |
  332|  3.58k|		bdecode_node const trackers = rd.dict_find_list("trackers");
  333|  3.58k|		if (trackers)
  ------------------
  |  Branch (333:7): [True: 953, False: 2.63k]
  ------------------
  334|    953|		{
  335|       |			// it's possible to delete the trackers from a torrent and then save
  336|       |			// resume data with an empty trackers list. Since we found a trackers
  337|       |			// list here, these should replace whatever we find in the .torrent
  338|       |			// file.
  339|    953|			ret.flags |= torrent_flags::override_trackers;
  340|       |
  341|    953|			int tier = 0;
  342|  1.62M|			for (int i = 0; i < trackers.list_size(); ++i)
  ------------------
  |  Branch (342:20): [True: 1.62M, False: 953]
  ------------------
  343|  1.62M|			{
  344|  1.62M|				bdecode_node const tier_list = trackers.list_at(i);
  345|  1.62M|				if (!tier_list || tier_list.type() != bdecode_node::list_t)
  ------------------
  |  Branch (345:9): [True: 0, False: 1.62M]
  |  Branch (345:23): [True: 544k, False: 1.08M]
  ------------------
  346|   544k|					continue;
  347|       |
  348|  4.46M|				for (int j = 0; j < tier_list.list_size(); ++j)
  ------------------
  |  Branch (348:21): [True: 3.38M, False: 1.08M]
  ------------------
  349|  3.38M|				{
  350|  3.38M|					ret.trackers.push_back(tier_list.list_string_value_at(j).to_string());
  351|  3.38M|					ret.tracker_tiers.push_back(tier);
  352|  3.38M|#if TORRENT_USE_I2P
  353|  3.38M|					if (is_i2p_url(ret.trackers.back())) ret.flags |= torrent_flags::i2p_torrent;
  ------------------
  |  Branch (353:10): [True: 197, False: 3.38M]
  ------------------
  354|  3.38M|#endif
  355|  3.38M|				}
  356|  1.08M|				++tier;
  357|  1.08M|			}
  358|    953|		}
  359|       |
  360|       |		// if merge resume http seeds is not set, we need to clear whatever web
  361|       |		// seeds we loaded from the .torrent file, because we want whatever's in
  362|       |		// the resume file to take precedence. If there aren't even any fields in
  363|       |		// the resume data though, keep the ones from the torrent
  364|  3.58k|		bdecode_node const url_list = rd.dict_find_list("url-list");
  365|  3.58k|		bdecode_node const httpseeds = rd.dict_find_list("httpseeds");
  366|  3.58k|		if (url_list || httpseeds)
  ------------------
  |  Branch (366:7): [True: 151, False: 3.43k]
  |  Branch (366:19): [True: 49, False: 3.38k]
  ------------------
  367|    200|		{
  368|       |			// since we found http seeds in the resume data, they should replace
  369|       |			// whatever web seeds are specified in the .torrent, by default
  370|    200|			ret.flags |= torrent_flags::override_web_seeds;
  371|    200|		}
  372|       |
  373|  3.58k|		if (url_list)
  ------------------
  |  Branch (373:7): [True: 151, False: 3.43k]
  ------------------
  374|    151|		{
  375|   988k|			for (int i = 0; i < url_list.list_size(); ++i)
  ------------------
  |  Branch (375:20): [True: 988k, False: 151]
  ------------------
  376|   988k|			{
  377|   988k|				auto url = url_list.list_string_value_at(i);
  378|   988k|				if (url.empty()) continue;
  ------------------
  |  Branch (378:9): [True: 536k, False: 451k]
  ------------------
  379|   451k|				ret.url_seeds.push_back(url.to_string());
  380|   451k|			}
  381|    151|		}
  382|       |
  383|  3.58k|		if (httpseeds)
  ------------------
  |  Branch (383:7): [True: 66, False: 3.51k]
  ------------------
  384|     66|		{
  385|   583k|			for (int i = 0; i < httpseeds.list_size(); ++i)
  ------------------
  |  Branch (385:20): [True: 583k, False: 66]
  ------------------
  386|   583k|			{
  387|   583k|				auto url = httpseeds.list_string_value_at(i);
  388|   583k|				if (url.empty()) continue;
  ------------------
  |  Branch (388:9): [True: 531k, False: 52.0k]
  ------------------
  389|  52.0k|				ret.http_seeds.push_back(url.to_string());
  390|  52.0k|			}
  391|     66|		}
  392|       |
  393|       |		// some sanity checking. Maybe we shouldn't be in seed mode anymore
  394|  3.58k|		if (bdecode_node const pieces = rd.dict_find_string("pieces"))
  ------------------
  |  Branch (394:26): [True: 224, False: 3.35k]
  ------------------
  395|    224|		{
  396|    224|			if (file_version == 1)
  ------------------
  |  Branch (396:8): [True: 164, False: 60]
  ------------------
  397|    164|			{
  398|    164|				char const* pieces_str = pieces.string_ptr();
  399|    164|				int const pieces_len = pieces.string_length();
  400|    164|				ret.have_pieces.resize(pieces_len);
  401|    164|				ret.verified_pieces.resize(pieces_len);
  402|    164|				bool any_verified = false;
  403|  2.59M|				for (piece_index_t i(0); i < ret.verified_pieces.end_index(); ++i)
  ------------------
  |  Branch (403:30): [True: 2.59M, False: 164]
  ------------------
  404|  2.59M|				{
  405|       |					// being in seed mode and missing a piece is not compatible.
  406|       |					// Leave seed mode if that happens
  407|  2.59M|					if (pieces_str[static_cast<int>(i)] & 1) ret.have_pieces.set_bit(i);
  ------------------
  |  Branch (407:10): [True: 1.45M, False: 1.13M]
  ------------------
  408|  1.13M|					else ret.have_pieces.clear_bit(i);
  409|       |
  410|  2.59M|					if (pieces_str[static_cast<int>(i)] & 2)
  ------------------
  |  Branch (410:10): [True: 415k, False: 2.17M]
  ------------------
  411|   415k|					{
  412|   415k|						ret.verified_pieces.set_bit(i);
  413|   415k|						any_verified = true;
  414|   415k|					}
  415|  2.17M|					else
  416|  2.17M|					{
  417|  2.17M|						ret.verified_pieces.clear_bit(i);
  418|  2.17M|					}
  419|  2.59M|				}
  420|    164|				if (!any_verified) ret.verified_pieces.clear();
  ------------------
  |  Branch (420:9): [True: 44, False: 120]
  ------------------
  421|    164|			}
  422|     60|			else if (file_version == 2)
  ------------------
  |  Branch (422:13): [True: 60, False: 0]
  ------------------
  423|     60|			{
  424|     60|				string_view const str = pieces.string_value();
  425|     60|				ret.have_pieces.assign(str.data(), int(str.size()) * 8);
  426|     60|			}
  427|    224|		}
  428|       |
  429|  3.58k|		if (bdecode_node const verified = rd.dict_find_string("verified"))
  ------------------
  |  Branch (429:26): [True: 106, False: 3.47k]
  ------------------
  430|    106|		{
  431|    106|			string_view const str = verified.string_value();
  432|    106|			ret.verified_pieces.assign(str.data(), int(str.size()) * 8);
  433|    106|		}
  434|       |
  435|  3.58k|		if (bdecode_node const piece_priority = rd.dict_find_string("piece_priority"))
  ------------------
  |  Branch (435:26): [True: 39, False: 3.54k]
  ------------------
  436|     39|		{
  437|     39|			char const* prio_str = piece_priority.string_ptr();
  438|     39|			ret.piece_priorities.resize(aux::numeric_cast<std::size_t>(piece_priority.string_length()));
  439|  7.70k|			for (std::size_t i = 0; i < ret.piece_priorities.size(); ++i)
  ------------------
  |  Branch (439:28): [True: 7.66k, False: 39]
  ------------------
  440|  7.66k|			{
  441|  7.66k|				ret.piece_priorities[i] = download_priority_t(aux::clamp(
  442|  7.66k|					static_cast<std::uint8_t>(prio_str[i])
  443|  7.66k|					, static_cast<std::uint8_t>(dont_download)
  444|  7.66k|					, static_cast<std::uint8_t>(top_priority)));
  445|  7.66k|			}
  446|     39|		}
  447|       |
  448|  3.58k|		int const v6_size = 18;
  449|  3.58k|		int const v4_size = 6;
  450|  3.58k|		using namespace libtorrent::aux; // for read_*_endpoint()
  451|  3.58k|		if (bdecode_node const peers_entry = rd.dict_find_string("peers"))
  ------------------
  |  Branch (451:26): [True: 76, False: 3.50k]
  ------------------
  452|     76|		{
  453|     76|			char const* ptr = peers_entry.string_ptr();
  454|  38.7k|			for (int i = v4_size - 1; i < peers_entry.string_length(); i += v4_size)
  ------------------
  |  Branch (454:30): [True: 38.7k, False: 76]
  ------------------
  455|  38.7k|				ret.peers.push_back(read_v4_endpoint<tcp::endpoint>(ptr));
  456|     76|		}
  457|       |
  458|  3.58k|		if (bdecode_node const peers_entry = rd.dict_find_string("peers6"))
  ------------------
  |  Branch (458:26): [True: 33, False: 3.55k]
  ------------------
  459|     33|		{
  460|     33|			char const* ptr = peers_entry.string_ptr();
  461|  4.32k|			for (int i = v6_size - 1; i < peers_entry.string_length(); i += v6_size)
  ------------------
  |  Branch (461:30): [True: 4.29k, False: 33]
  ------------------
  462|  4.29k|				ret.peers.push_back(read_v6_endpoint<tcp::endpoint>(ptr));
  463|     33|		}
  464|       |
  465|  3.58k|		if (bdecode_node const peers_entry = rd.dict_find_string("banned_peers"))
  ------------------
  |  Branch (465:26): [True: 53, False: 3.53k]
  ------------------
  466|     53|		{
  467|     53|			char const* ptr = peers_entry.string_ptr();
  468|  70.3k|			for (int i = v4_size; i < peers_entry.string_length(); i += v4_size)
  ------------------
  |  Branch (468:26): [True: 70.3k, False: 53]
  ------------------
  469|  70.3k|				ret.banned_peers.push_back(read_v4_endpoint<tcp::endpoint>(ptr));
  470|     53|		}
  471|       |
  472|  3.58k|		if (bdecode_node const peers_entry = rd.dict_find_string("banned_peers6"))
  ------------------
  |  Branch (472:26): [True: 34, False: 3.54k]
  ------------------
  473|     34|		{
  474|     34|			char const* ptr = peers_entry.string_ptr();
  475|  14.6k|			for (int i = v6_size - 1; i < peers_entry.string_length(); i += v6_size)
  ------------------
  |  Branch (475:30): [True: 14.6k, False: 34]
  ------------------
  476|  14.6k|				ret.banned_peers.push_back(read_v6_endpoint<tcp::endpoint>(ptr));
  477|     34|		}
  478|       |
  479|       |		// parse unfinished pieces
  480|  3.58k|		if (bdecode_node const unfinished_entry = rd.dict_find_list("unfinished"))
  ------------------
  |  Branch (480:26): [True: 54, False: 3.52k]
  ------------------
  481|     54|		{
  482|   529k|			for (int i = 0; i < unfinished_entry.list_size(); ++i)
  ------------------
  |  Branch (482:20): [True: 529k, False: 54]
  ------------------
  483|   529k|			{
  484|   529k|				bdecode_node const e = unfinished_entry.list_at(i);
  485|   529k|				if (e.type() != bdecode_node::dict_t) continue;
  ------------------
  |  Branch (485:9): [True: 33.2k, False: 496k]
  ------------------
  486|   496k|				piece_index_t const piece = piece_index_t(int(e.dict_find_int_value("piece", -1)));
  487|   496k|				if (piece < piece_index_t(0)) continue;
  ------------------
  |  Branch (487:9): [True: 496k, False: 0]
  ------------------
  488|       |
  489|      0|				bdecode_node const bitmask = e.dict_find_string("bitmask");
  490|      0|				if (!bitmask || bitmask.string_length() == 0) continue;
  ------------------
  |  Branch (490:9): [True: 0, False: 0]
  |  Branch (490:21): [True: 0, False: 0]
  ------------------
  491|      0|				ret.unfinished_pieces[piece].assign(
  492|      0|					bitmask.string_ptr(), bitmask.string_length() * CHAR_BIT);
  493|      0|			}
  494|     54|		}
  495|       |
  496|       |		// we're loading this torrent from resume data. There's no need to
  497|       |		// re-save the resume data immediately.
  498|  3.58k|		ret.flags &= ~torrent_flags::need_save_resume;
  499|       |
  500|  3.58k|		return ret;
  501|  3.62k|	}
_ZN10libtorrent16read_resume_dataENS_4spanIKcEERN5boost6system10error_codeERKNS_19load_torrent_limitsE:
  505|  5.02k|	{
  506|  5.02k|		int pos;
  507|  5.02k|		bdecode_node rd = bdecode(buffer, ec, &pos, cfg.max_decode_depth
  508|  5.02k|			, cfg.max_decode_tokens);
  509|  5.02k|		if (ec) return add_torrent_params();
  ------------------
  |  Branch (509:7): [True: 846, False: 4.17k]
  ------------------
  510|       |
  511|  4.17k|		return read_resume_data(rd, ec, cfg.max_pieces);
  512|  5.02k|	}
read_resume_data.cpp:_ZN10libtorrent12_GLOBAL__N_110apply_flagERNS_5flags13bitfield_flagImNS_17torrent_flags_tagEvEERKNS_12bdecode_nodeEPKcS4_:
   56|  46.5k|	{
   57|  46.5k|		if (n.dict_find_int_value(name, (flag & torrent_flags::default_flags) ? 1 : 0) == 0)
  ------------------
  |  Branch (57:7): [True: 35.1k, False: 11.4k]
  |  Branch (57:35): [True: 10.7k, False: 35.8k]
  ------------------
   58|  35.1k|		{
   59|  35.1k|			current_flags &= ~flag;
   60|  35.1k|		}
   61|  11.4k|		else
   62|  11.4k|		{
   63|  11.4k|			current_flags |= flag;
   64|  11.4k|		}
   65|  46.5k|	}

ssl.cpp:_ZN10libtorrent3ssl12_GLOBAL__N_19lifecycleC2Ev:
  180|      2|		{
  181|      2|			OPENSSL_init_crypto(OPENSSL_INIT_ADD_ALL_CIPHERS | OPENSSL_INIT_ADD_ALL_DIGESTS, nullptr);
  182|      2|		}

_ZN10libtorrent8is_spaceEc:
   83|  10.5k|	{
   84|  10.5k|		return c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\f' || c == '\v';
  ------------------
  |  Branch (84:10): [True: 317, False: 10.2k]
  |  Branch (84:22): [True: 326, False: 9.89k]
  |  Branch (84:35): [True: 466, False: 9.43k]
  |  Branch (84:48): [True: 303, False: 9.13k]
  |  Branch (84:61): [True: 231, False: 8.89k]
  |  Branch (84:74): [True: 213, False: 8.68k]
  ------------------
   85|  10.5k|	}
_ZN10libtorrent16string_ends_withEN5boost17basic_string_viewIcNSt3__111char_traitsIcEEEES5_:
  128|  3.38M|	{
  129|  3.38M|		return s1.size() >= s2.size() && std::equal(s2.rbegin(), s2.rend(), s1.rbegin());
  ------------------
  |  Branch (129:10): [True: 1.55k, False: 3.38M]
  |  Branch (129:36): [True: 197, False: 1.35k]
  ------------------
  130|  3.38M|	}
_ZN10libtorrent10is_i2p_urlERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE:
  430|  3.38M|	{
  431|  3.38M|		using std::ignore;
  432|  3.38M|		std::string hostname;
  433|  3.38M|		error_code ec;
  434|  3.38M|		std::tie(ignore, ignore, hostname, ignore, ignore)
  435|  3.38M|			= parse_url_components(url, ec);
  436|  3.38M|		return string_ends_with(hostname, ".i2p");
  437|  3.38M|	}

_ZN10libtorrent12torrent_infoC2ERKNS_11info_hash_tE:
 1060|     98|		: m_info_hash(info_hash)
 1061|     98|	{}
_ZN10libtorrent12torrent_infoD2Ev:
 1063|     98|	torrent_info::~torrent_info() = default;
_ZN10libtorrent12torrent_info18parse_info_sectionERKNS_12bdecode_nodeERN5boost6system10error_codeEi:
 1129|     98|	{
 1130|     98|		if (info.type() != bdecode_node::dict_t)
  ------------------
  |  Branch (1130:7): [True: 0, False: 98]
  ------------------
 1131|      0|		{
 1132|      0|			ec = errors::torrent_info_no_dict;
 1133|      0|			return false;
 1134|      0|		}
 1135|       |
 1136|       |		// hash the info-field to calculate info-hash
 1137|     98|		auto section = info.data_section();
 1138|     98|		m_info_hash.v1 = hasher(section).final();
 1139|     98|		m_info_hash.v2 = hasher256(section).final();
 1140|     98|		if (info.data_section().size() >= std::numeric_limits<int>::max())
  ------------------
  |  Branch (1140:7): [True: 0, False: 98]
  ------------------
 1141|      0|		{
 1142|      0|			ec = errors::metadata_too_large;
 1143|      0|			return false;
 1144|      0|		}
 1145|       |
 1146|     98|		if (section.empty() || section[0] != 'd' || section[section.size() - 1] != 'e')
  ------------------
  |  Branch (1146:7): [True: 0, False: 98]
  |  Branch (1146:26): [True: 0, False: 98]
  |  Branch (1146:47): [True: 0, False: 98]
  ------------------
 1147|      0|		{
 1148|      0|			ec = errors::invalid_bencoding;
 1149|      0|			return false;
 1150|      0|		}
 1151|       |
 1152|       |		// copy the info section
 1153|     98|		m_info_section_size = int(section.size());
 1154|     98|		m_info_section.reset(new char[aux::numeric_cast<std::size_t>(m_info_section_size)]);
 1155|     98|		std::memcpy(m_info_section.get(), section.data(), aux::numeric_cast<std::size_t>(m_info_section_size));
 1156|       |
 1157|       |		// this is the offset from the start of the torrent file buffer to the
 1158|       |		// info-dictionary (within the torrent file).
 1159|       |		// we need this because we copy just the info dictionary buffer and pull
 1160|       |		// out parsed data (strings) from the bdecode_node and need to make them
 1161|       |		// point into our copy of the buffer.
 1162|     98|		std::ptrdiff_t const info_offset = info.data_offset();
 1163|       |
 1164|       |		// check for a version key
 1165|     98|		int const version = int(info.dict_find_int_value("meta version", -1));
 1166|     98|		if (version > 0)
  ------------------
  |  Branch (1166:7): [True: 0, False: 98]
  ------------------
 1167|      0|		{
 1168|      0|			char error_string[200];
 1169|      0|			if (info.has_soft_error(error_string))
  ------------------
  |  Branch (1169:8): [True: 0, False: 0]
  ------------------
 1170|      0|			{
 1171|      0|				ec = errors::invalid_bencoding;
 1172|      0|				return false;
 1173|      0|			}
 1174|       |
 1175|      0|			if (version > 2)
  ------------------
  |  Branch (1175:8): [True: 0, False: 0]
  ------------------
 1176|      0|			{
 1177|      0|				ec = errors::torrent_unknown_version;
 1178|      0|				return false;
 1179|      0|			}
 1180|      0|		}
 1181|       |
 1182|     98|		if (version < 2)
  ------------------
  |  Branch (1182:7): [True: 98, False: 0]
  ------------------
 1183|     98|		{
 1184|       |			// this is a v1 torrent so the v2 info hash has no meaning
 1185|       |			// clear it just to make sure no one tries to use it
 1186|     98|			m_info_hash.v2.clear();
 1187|     98|		}
 1188|       |
 1189|       |		// extract piece length
 1190|     98|		std::int64_t const piece_length = info.dict_find_int_value("piece length", -1);
 1191|     98|		if (piece_length <= 0 || piece_length > file_storage::max_piece_size)
  ------------------
  |  Branch (1191:7): [True: 98, False: 0]
  |  Branch (1191:28): [True: 0, False: 0]
  ------------------
 1192|     98|		{
 1193|     98|			ec = errors::torrent_missing_piece_length;
 1194|     98|			return false;
 1195|     98|		}
 1196|       |
 1197|       |		// according to BEP 52: "It must be a power of two and at least 16KiB."
 1198|      0|		if (version > 1 && (piece_length < default_block_size
  ------------------
  |  Branch (1198:7): [True: 0, False: 0]
  |  Branch (1198:23): [True: 0, False: 0]
  ------------------
 1199|      0|			|| (piece_length & (piece_length - 1)) != 0))
  ------------------
  |  Branch (1199:7): [True: 0, False: 0]
  ------------------
 1200|      0|		{
 1201|      0|			ec = errors::torrent_missing_piece_length;
 1202|      0|			return false;
 1203|      0|		}
 1204|       |
 1205|      0|		file_storage files;
 1206|      0|		files.set_piece_length(static_cast<int>(piece_length));
 1207|       |
 1208|       |		// extract file name (or the directory name if it's a multi file libtorrent)
 1209|      0|		bdecode_node name_ent = info.dict_find_string("name.utf-8");
 1210|      0|		if (!name_ent) name_ent = info.dict_find_string("name");
  ------------------
  |  Branch (1210:7): [True: 0, False: 0]
  ------------------
 1211|      0|		if (!name_ent)
  ------------------
  |  Branch (1211:7): [True: 0, False: 0]
  ------------------
 1212|      0|		{
 1213|      0|			ec = errors::torrent_missing_name;
 1214|       |			// mark the torrent as invalid
 1215|      0|			m_files.set_piece_length(0);
 1216|      0|			return false;
 1217|      0|		}
 1218|       |
 1219|      0|		std::string name;
 1220|      0|		aux::sanitize_append_path_element(name, name_ent.string_value());
 1221|      0|		if (name.empty())
  ------------------
  |  Branch (1221:7): [True: 0, False: 0]
  ------------------
 1222|      0|		{
 1223|      0|			if (m_info_hash.has_v1())
  ------------------
  |  Branch (1223:8): [True: 0, False: 0]
  ------------------
 1224|      0|				name = aux::to_hex(m_info_hash.v1);
 1225|      0|			else
 1226|      0|				name = aux::to_hex(m_info_hash.v2);
 1227|      0|		}
 1228|       |
 1229|       |		// extract file list
 1230|       |
 1231|       |		// save a copy so that we can extract both v1 and v2 files then compare the results
 1232|      0|		file_storage v1_files;
 1233|      0|		if (version >= 2)
  ------------------
  |  Branch (1233:7): [True: 0, False: 0]
  ------------------
 1234|      0|			v1_files = files;
 1235|       |
 1236|      0|		bdecode_node const files_node = info.dict_find_list("files");
 1237|       |
 1238|      0|		bdecode_node const file_tree_node = info.dict_find_dict("file tree");
 1239|      0|		if (version >= 2 && file_tree_node)
  ------------------
  |  Branch (1239:7): [True: 0, False: 0]
  |  Branch (1239:23): [True: 0, False: 0]
  ------------------
 1240|      0|		{
 1241|      0|			if (!extract_files2(file_tree_node, files, name, info_offset
  ------------------
  |  Branch (1241:8): [True: 0, False: 0]
  ------------------
 1242|      0|				, m_info_section.get(), bool(files_node), 0, ec))
 1243|      0|			{
 1244|       |				// mark the torrent as invalid
 1245|      0|				m_files.set_piece_length(0);
 1246|      0|				return false;
 1247|      0|			}
 1248|       |
 1249|      0|			files.sanitize_symlinks();
 1250|      0|			if (files.num_files() > 1)
  ------------------
  |  Branch (1250:8): [True: 0, False: 0]
  ------------------
 1251|      0|				m_flags |= multifile;
 1252|      0|			else
 1253|      0|				m_flags &= ~multifile;
 1254|      0|		}
 1255|      0|		else if (version >= 2)
  ------------------
  |  Branch (1255:12): [True: 0, False: 0]
  ------------------
 1256|      0|		{
 1257|       |			// mark the torrent as invalid
 1258|      0|			m_files.set_piece_length(0);
 1259|      0|			ec = errors::torrent_missing_file_tree;
 1260|      0|			return false;
 1261|      0|		}
 1262|      0|		else if (file_tree_node)
  ------------------
  |  Branch (1262:12): [True: 0, False: 0]
  ------------------
 1263|      0|		{
 1264|       |			// mark the torrent as invalid
 1265|      0|			m_files.set_piece_length(0);
 1266|      0|			ec = errors::torrent_missing_meta_version;
 1267|      0|			return false;
 1268|      0|		}
 1269|       |
 1270|      0|		if (!files_node)
  ------------------
  |  Branch (1270:7): [True: 0, False: 0]
  ------------------
 1271|      0|		{
 1272|       |			// if this is a v2 torrent it is ok for the length key to be missing
 1273|       |			// that means it is a v2 only torrent
 1274|      0|			if (version < 2 || info.dict_find("length"))
  ------------------
  |  Branch (1274:8): [True: 0, False: 0]
  |  Branch (1274:8): [True: 0, False: 0]
  |  Branch (1274:23): [True: 0, False: 0]
  ------------------
 1275|      0|			{
 1276|       |				// if there's no list of files, there has to be a length
 1277|       |				// field.
 1278|      0|				if (!extract_single_file(info, version == 2 ? v1_files : files, ""
  ------------------
  |  Branch (1278:9): [True: 0, False: 0]
  |  Branch (1278:36): [True: 0, False: 0]
  ------------------
 1279|      0|					, info_offset, m_info_section.get(), true, ec))
 1280|      0|				{
 1281|       |					// mark the torrent as invalid
 1282|      0|					m_files.set_piece_length(0);
 1283|      0|					return false;
 1284|      0|				}
 1285|       |
 1286|      0|				m_flags &= ~multifile;
 1287|      0|			}
 1288|      0|			else
 1289|      0|			{
 1290|       |				// this is a v2 only torrent so clear the v1 info hash to make sure no one uses it
 1291|      0|				m_info_hash.v1.clear();
 1292|      0|			}
 1293|      0|		}
 1294|      0|		else
 1295|      0|		{
 1296|      0|			if (!extract_files(files_node, version == 2 ? v1_files : files, name
  ------------------
  |  Branch (1296:8): [True: 0, False: 0]
  |  Branch (1296:35): [True: 0, False: 0]
  ------------------
 1297|      0|				, info_offset, m_info_section.get(), ec))
 1298|      0|			{
 1299|       |				// mark the torrent as invalid
 1300|      0|				m_files.set_piece_length(0);
 1301|      0|				return false;
 1302|      0|			}
 1303|      0|			m_flags |= multifile;
 1304|      0|		}
 1305|      0|		if (files.num_files() == 0)
  ------------------
  |  Branch (1305:7): [True: 0, False: 0]
  ------------------
 1306|      0|		{
 1307|      0|			ec = errors::no_files_in_torrent;
 1308|       |			// mark the torrent as invalid
 1309|      0|			m_files.set_piece_length(0);
 1310|      0|			return false;
 1311|      0|		}
 1312|      0|		if (files.name().empty())
  ------------------
  |  Branch (1312:7): [True: 0, False: 0]
  ------------------
 1313|      0|		{
 1314|      0|			ec = errors::torrent_missing_name;
 1315|       |			// mark the torrent as invalid
 1316|      0|			m_files.set_piece_length(0);
 1317|      0|			return false;
 1318|      0|		}
 1319|       |
 1320|       |		// ensure hybrid torrents have compatible v1 and v2 file storages
 1321|      0|		if (version >= 2 && v1_files.num_files() > 0)
  ------------------
  |  Branch (1321:7): [True: 0, False: 0]
  |  Branch (1321:23): [True: 0, False: 0]
  ------------------
 1322|      0|		{
 1323|       |			// previous versions of libtorrent did not not create hybrid
 1324|       |			// torrents with "tail-padding". When loading, accept both.
 1325|      0|			if (files.num_files() == v1_files.num_files() + 1)
  ------------------
  |  Branch (1325:8): [True: 0, False: 0]
  ------------------
 1326|      0|			{
 1327|      0|				files.remove_tail_padding();
 1328|      0|			}
 1329|       |
 1330|      0|			if (!aux::files_compatible(files, v1_files))
  ------------------
  |  Branch (1330:8): [True: 0, False: 0]
  ------------------
 1331|      0|			{
 1332|       |				// mark the torrent as invalid
 1333|      0|				m_files.set_piece_length(0);
 1334|      0|				ec = errors::torrent_inconsistent_files;
 1335|      0|				return false;
 1336|      0|			}
 1337|      0|		}
 1338|       |
 1339|       |		// extract SHA-1 hashes for all pieces
 1340|       |		// we want this division to round upwards, that's why we have the
 1341|       |		// extra addition
 1342|       |
 1343|      0|		if (files.total_size() / files.piece_length() > file_storage::max_num_pieces)
  ------------------
  |  Branch (1343:7): [True: 0, False: 0]
  ------------------
 1344|      0|		{
 1345|      0|			ec = errors::too_many_pieces_in_torrent;
 1346|       |			// mark the torrent as invalid
 1347|      0|			m_files.set_piece_length(0);
 1348|      0|			return false;
 1349|      0|		}
 1350|       |
 1351|      0|		files.set_num_pieces(int((files.total_size() + files.piece_length() - 1)
 1352|      0|			/ files.piece_length()));
 1353|       |
 1354|       |		// we expect the piece hashes to be < 2 GB in size
 1355|      0|		if (files.num_pieces() >= std::numeric_limits<int>::max() / 20
  ------------------
  |  Branch (1355:7): [True: 0, False: 0]
  ------------------
 1356|      0|			|| files.num_pieces() > max_pieces)
  ------------------
  |  Branch (1356:7): [True: 0, False: 0]
  ------------------
 1357|      0|		{
 1358|      0|			ec = errors::too_many_pieces_in_torrent;
 1359|       |			// mark the torrent as invalid
 1360|      0|			m_files.set_piece_length(0);
 1361|      0|			return false;
 1362|      0|		}
 1363|       |
 1364|      0|		bdecode_node const pieces = info.dict_find_string("pieces");
 1365|      0|		if (!pieces)
  ------------------
  |  Branch (1365:7): [True: 0, False: 0]
  ------------------
 1366|      0|		{
 1367|      0|			if (version < 2)
  ------------------
  |  Branch (1367:8): [True: 0, False: 0]
  ------------------
 1368|      0|			{
 1369|      0|				ec = errors::torrent_missing_pieces;
 1370|       |				// mark the torrent as invalid
 1371|      0|				m_files.set_piece_length(0);
 1372|      0|				return false;
 1373|      0|			}
 1374|      0|		}
 1375|      0|		else
 1376|      0|		{
 1377|      0|			if (pieces.string_length() != files.num_pieces() * 20)
  ------------------
  |  Branch (1377:8): [True: 0, False: 0]
  ------------------
 1378|      0|			{
 1379|      0|				ec = errors::torrent_invalid_hashes;
 1380|       |				// mark the torrent as invalid
 1381|      0|				m_files.set_piece_length(0);
 1382|      0|				return false;
 1383|      0|			}
 1384|       |
 1385|      0|			std::ptrdiff_t const hash_offset = pieces.string_offset() - info_offset;
 1386|      0|			TORRENT_ASSERT(hash_offset < std::numeric_limits<std::int32_t>::max());
  ------------------
  |  |   95|      0|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|      0|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1387|      0|			TORRENT_ASSERT(hash_offset >= 0);
  ------------------
  |  |   95|      0|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|      0|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1388|      0|			m_piece_hashes = static_cast<std::int32_t>(hash_offset);
 1389|      0|			TORRENT_ASSERT(m_piece_hashes > 0);
  ------------------
  |  |   95|      0|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|      0|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1390|      0|			TORRENT_ASSERT(m_piece_hashes < m_info_section_size);
  ------------------
  |  |   95|      0|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|      0|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1391|      0|		}
 1392|       |
 1393|      0|		m_flags |= (info.dict_find_int_value("private", 0) != 0)
  ------------------
  |  Branch (1393:14): [True: 0, False: 0]
  ------------------
 1394|      0|			? private_torrent : torrent_info_flags_t{};
 1395|       |
 1396|      0|#ifndef TORRENT_DISABLE_MUTABLE_TORRENTS
 1397|      0|		bdecode_node const similar = info.dict_find_list("similar");
 1398|      0|		if (similar)
  ------------------
  |  Branch (1398:7): [True: 0, False: 0]
  ------------------
 1399|      0|		{
 1400|      0|			for (int i = 0; i < similar.list_size(); ++i)
  ------------------
  |  Branch (1400:20): [True: 0, False: 0]
  ------------------
 1401|      0|			{
 1402|      0|				if (similar.list_at(i).type() != bdecode_node::string_t)
  ------------------
  |  Branch (1402:9): [True: 0, False: 0]
  ------------------
 1403|      0|					continue;
 1404|       |
 1405|      0|				if (similar.list_at(i).string_length() != 20)
  ------------------
  |  Branch (1405:9): [True: 0, False: 0]
  ------------------
 1406|      0|					continue;
 1407|      0|				m_similar_torrents.push_back(static_cast<std::int32_t>(
 1408|      0|					similar.list_at(i).string_offset() - info_offset));
 1409|      0|			}
 1410|      0|		}
 1411|       |
 1412|      0|		bdecode_node const collections = info.dict_find_list("collections");
 1413|      0|		if (collections)
  ------------------
  |  Branch (1413:7): [True: 0, False: 0]
  ------------------
 1414|      0|		{
 1415|      0|			for (int i = 0; i < collections.list_size(); ++i)
  ------------------
  |  Branch (1415:20): [True: 0, False: 0]
  ------------------
 1416|      0|			{
 1417|      0|				bdecode_node const str = collections.list_at(i);
 1418|       |
 1419|      0|				if (str.type() != bdecode_node::string_t) continue;
  ------------------
  |  Branch (1419:9): [True: 0, False: 0]
  ------------------
 1420|       |
 1421|      0|				m_collections.emplace_back(std::int32_t(str.string_offset() - info_offset)
 1422|      0|					, str.string_length());
 1423|      0|			}
 1424|      0|		}
 1425|      0|#endif // TORRENT_DISABLE_MUTABLE_TORRENTS
 1426|       |
 1427|      0|		if (info.dict_find_string("ssl-cert"))
  ------------------
  |  Branch (1427:7): [True: 0, False: 0]
  ------------------
 1428|      0|			m_flags |= ssl_torrent;
 1429|       |
 1430|      0|		if (files.total_size() == 0)
  ------------------
  |  Branch (1430:7): [True: 0, False: 0]
  ------------------
 1431|      0|		{
 1432|      0|			ec = errors::torrent_invalid_length;
 1433|       |			// mark the torrent as invalid
 1434|      0|			m_files.set_piece_length(0);
 1435|      0|			return false;
 1436|      0|		}
 1437|       |
 1438|       |		// now, commit the files structure we just parsed out
 1439|       |		// into the torrent_info object.
 1440|      0|		m_files.swap(files);
 1441|       |
 1442|      0|		TORRENT_ASSERT(m_info_hash.has_v2() == m_files.v2());
  ------------------
  |  |   95|      0|	do { if (x) {} else libtorrent::assert_fail(#x, __LINE__, __FILE__, __func__, nullptr, 0); } TORRENT_WHILE_0
  |  |  ------------------
  |  |  |  |   60|      0|#define TORRENT_WHILE_0 while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:32): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (95:11): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1443|      0|		return true;
 1444|      0|	}

_ZN10libtorrent17write_resume_dataERKNS_18add_torrent_paramsE:
   75|  5.02k|	{
   76|  5.02k|		entry ret;
   77|       |
   78|  5.02k|		using namespace libtorrent::aux; // for write_*_endpoint()
   79|  5.02k|		ret["file-format"] = "libtorrent resume file";
   80|  5.02k|		ret["file-version"] = 1;
   81|  5.02k|		ret["libtorrent-version"] = lt::version_str;
   82|  5.02k|		ret["allocation"] = atp.storage_mode == storage_mode_allocate
  ------------------
  |  Branch (82:23): [True: 2, False: 5.01k]
  ------------------
   83|  5.02k|			? "allocate" : "sparse";
   84|       |
   85|  5.02k|		ret["total_uploaded"] = atp.total_uploaded;
   86|  5.02k|		ret["total_downloaded"] = atp.total_downloaded;
   87|       |
   88|       |		// cast to seconds in case that internal values doesn't have ratio<1>
   89|  5.02k|		ret["active_time"] = atp.active_time;
   90|  5.02k|		ret["finished_time"] = atp.finished_time;
   91|  5.02k|		ret["seeding_time"] = atp.seeding_time;
   92|  5.02k|		ret["last_seen_complete"] = atp.last_seen_complete;
   93|  5.02k|		ret["last_download"] = atp.last_download;
   94|  5.02k|		ret["last_upload"] = atp.last_upload;
   95|       |
   96|  5.02k|		ret["num_complete"] = atp.num_complete;
   97|  5.02k|		ret["num_incomplete"] = atp.num_incomplete;
   98|  5.02k|		ret["num_downloaded"] = atp.num_downloaded;
   99|       |
  100|  5.02k|		ret["seed_mode"] = bool(atp.flags & torrent_flags::seed_mode);
  101|  5.02k|		ret["upload_mode"] = bool(atp.flags & torrent_flags::upload_mode);
  102|  5.02k|#ifndef TORRENT_DISABLE_SHARE_MODE
  103|  5.02k|		ret["share_mode"] = bool(atp.flags & torrent_flags::share_mode);
  104|  5.02k|#endif
  105|  5.02k|		ret["apply_ip_filter"] = bool(atp.flags & torrent_flags::apply_ip_filter);
  106|  5.02k|		ret["paused"] = bool(atp.flags & torrent_flags::paused);
  107|  5.02k|		ret["auto_managed"] = bool(atp.flags & torrent_flags::auto_managed);
  108|  5.02k|#ifndef TORRENT_DISABLE_SUPERSEEDING
  109|  5.02k|		ret["super_seeding"] = bool(atp.flags & torrent_flags::super_seeding);
  110|  5.02k|#endif
  111|  5.02k|#if TORRENT_USE_I2P
  112|  5.02k|		ret["i2p"] = bool(atp.flags & torrent_flags::i2p_torrent);
  113|  5.02k|#endif
  114|  5.02k|		ret["sequential_download"] = bool(atp.flags & torrent_flags::sequential_download);
  115|  5.02k|		ret["stop_when_ready"] = bool(atp.flags & torrent_flags::stop_when_ready);
  116|  5.02k|		ret["disable_dht"] = bool(atp.flags & torrent_flags::disable_dht);
  117|  5.02k|		ret["disable_lsd"] = bool(atp.flags & torrent_flags::disable_lsd);
  118|  5.02k|		ret["disable_pex"] = bool(atp.flags & torrent_flags::disable_pex);
  119|       |
  120|  5.02k|		ret["added_time"] = atp.added_time;
  121|  5.02k|		ret["completed_time"] = atp.completed_time;
  122|       |
  123|  5.02k|		ret["save_path"] = atp.save_path;
  124|       |
  125|  5.02k|		if (!atp.name.empty()) ret["name"] = atp.name;
  ------------------
  |  Branch (125:7): [True: 16, False: 5.00k]
  ------------------
  126|       |
  127|  5.02k|#if TORRENT_ABI_VERSION == 1
  128|       |		// deprecated in 1.2
  129|  5.02k|		if (!atp.url.empty()) ret["url"] = atp.url;
  ------------------
  |  Branch (129:7): [True: 41, False: 4.98k]
  ------------------
  130|  5.02k|#endif
  131|       |
  132|  5.02k|		ret["info-hash"] = atp.info_hashes.v1;
  133|  5.02k|		ret["info-hash2"] = atp.info_hashes.v2;
  134|       |
  135|  5.02k|		if (atp.ti)
  ------------------
  |  Branch (135:7): [True: 98, False: 4.92k]
  ------------------
  136|     98|		{
  137|     98|			auto const info = atp.ti->info_section();
  138|     98|			ret["info"].preformatted().assign(info.data(), info.data() + info.size());
  139|     98|			if (!atp.ti->comment().empty())
  ------------------
  |  Branch (139:8): [True: 0, False: 98]
  ------------------
  140|      0|				ret["comment"] = atp.ti->comment();
  141|     98|			if (atp.ti->creation_date() != 0)
  ------------------
  |  Branch (141:8): [True: 0, False: 98]
  ------------------
  142|      0|				ret["creation date"] = atp.ti->creation_date();
  143|     98|			if (!atp.ti->creator().empty())
  ------------------
  |  Branch (143:8): [True: 0, False: 98]
  ------------------
  144|      0|				ret["created by"] = atp.ti->creator();
  145|     98|		}
  146|       |
  147|  5.02k|		if (!atp.merkle_trees.empty())
  ------------------
  |  Branch (147:7): [True: 0, False: 5.02k]
  ------------------
  148|      0|		{
  149|      0|			auto& trees = atp.merkle_trees;
  150|      0|			auto& ret_trees = ret["trees"].list();
  151|      0|			ret_trees.reserve(atp.merkle_trees.size());
  152|      0|			for (file_index_t f(0); f < file_index_t{int(atp.merkle_trees.size())}; ++f)
  ------------------
  |  Branch (152:28): [True: 0, False: 0]
  ------------------
  153|      0|			{
  154|      0|				auto const& tree = trees[f];
  155|      0|				ret_trees.emplace_back(entry::dictionary_t);
  156|      0|				auto& ret_dict = ret_trees.back().dict();
  157|      0|				auto& ret_tree = ret_dict["hashes"].string();
  158|       |
  159|      0|				ret_tree.reserve(tree.size() * 32);
  160|      0|				for (auto const& n : tree)
  ------------------
  |  Branch (160:24): [True: 0, False: 0]
  ------------------
  161|      0|					ret_tree.append(n.data(), n.size());
  162|       |
  163|      0|				if (f < atp.verified_leaf_hashes.end_index())
  ------------------
  |  Branch (163:9): [True: 0, False: 0]
  ------------------
  164|      0|				{
  165|      0|					auto const& verified = atp.verified_leaf_hashes[f];
  166|      0|					if (!verified.empty())
  ------------------
  |  Branch (166:10): [True: 0, False: 0]
  ------------------
  167|      0|					{
  168|      0|						auto& ret_verified = ret_dict["verified"].string();
  169|      0|						ret_verified.reserve(verified.size());
  170|      0|						for (auto const bit : verified)
  ------------------
  |  Branch (170:27): [True: 0, False: 0]
  ------------------
  171|      0|							ret_verified.push_back(bit ? '1' : '0');
  ------------------
  |  Branch (171:31): [True: 0, False: 0]
  ------------------
  172|      0|					}
  173|      0|				}
  174|       |
  175|      0|				if (f < atp.merkle_tree_mask.end_index())
  ------------------
  |  Branch (175:9): [True: 0, False: 0]
  ------------------
  176|      0|				{
  177|      0|					auto const& mask = atp.merkle_tree_mask[f];
  178|      0|					if (!mask.empty())
  ------------------
  |  Branch (178:10): [True: 0, False: 0]
  ------------------
  179|      0|					{
  180|      0|						auto& ret_mask = ret_dict["mask"].string();
  181|      0|						ret_mask.reserve(mask.size());
  182|      0|						for (auto const bit : mask)
  ------------------
  |  Branch (182:27): [True: 0, False: 0]
  ------------------
  183|      0|							ret_mask.push_back(bit ? '1' : '0');
  ------------------
  |  Branch (183:27): [True: 0, False: 0]
  ------------------
  184|      0|					}
  185|      0|				}
  186|      0|			}
  187|      0|		}
  188|       |
  189|  5.02k|		if (!atp.unfinished_pieces.empty())
  ------------------
  |  Branch (189:7): [True: 0, False: 5.02k]
  ------------------
  190|      0|		{
  191|      0|			entry::list_type& up = ret["unfinished"].list();
  192|      0|			up.reserve(atp.unfinished_pieces.size());
  193|       |
  194|       |			// info for each unfinished piece
  195|      0|			for (auto const& p : atp.unfinished_pieces)
  ------------------
  |  Branch (195:23): [True: 0, False: 0]
  ------------------
  196|      0|			{
  197|      0|				entry piece_struct(entry::dictionary_t);
  198|       |
  199|       |				// the unfinished piece's index
  200|      0|				piece_struct["piece"] = static_cast<int>(p.first);
  201|      0|				piece_struct["bitmask"] = std::string(p.second.data(), std::size_t(p.second.size() + 7) / 8);
  202|       |				// push the struct onto the unfinished-piece list
  203|      0|				up.push_back(std::move(piece_struct));
  204|      0|			}
  205|      0|		}
  206|       |
  207|       |		// save trackers
  208|  5.02k|		ret["trackers"] = build_tracker_list(atp.trackers, atp.tracker_tiers);
  209|       |
  210|       |		// save web seeds
  211|       |		// if we removed the web seeds, make sure to record that in the resume
  212|       |		// data
  213|  5.02k|		entry::list_type& url_list = ret["url-list"].list();
  214|  5.02k|		std::copy(atp.url_seeds.begin(), atp.url_seeds.end(), std::back_inserter(url_list));
  215|       |
  216|  5.02k|		entry::list_type& httpseeds_list = ret["httpseeds"].list();
  217|  5.02k|		std::copy(atp.http_seeds.begin(), atp.http_seeds.end(), std::back_inserter(httpseeds_list));
  218|       |
  219|       |		// write have bitmask
  220|  5.02k|		entry::string_type& pieces = ret["pieces"].string();
  221|  5.02k|		pieces.resize(aux::numeric_cast<std::size_t>(std::max(
  222|  5.02k|			atp.have_pieces.size(), atp.verified_pieces.size())));
  223|       |
  224|  5.02k|		std::size_t piece(0);
  225|  5.02k|		for (auto const bit : atp.have_pieces)
  ------------------
  |  Branch (225:23): [True: 9.17M, False: 5.02k]
  ------------------
  226|  9.17M|		{
  227|  9.17M|			pieces[piece] = bit ? 1 : 0;
  ------------------
  |  Branch (227:20): [True: 4.52M, False: 4.65M]
  ------------------
  228|  9.17M|			++piece;
  229|  9.17M|		}
  230|       |
  231|  5.02k|		piece = 0;
  232|  5.02k|		for (auto const bit : atp.verified_pieces)
  ------------------
  |  Branch (232:23): [True: 5.56M, False: 5.02k]
  ------------------
  233|  5.56M|		{
  234|  5.56M|			pieces[piece] |= bit ? 2 : 0;
  ------------------
  |  Branch (234:21): [True: 2.02M, False: 3.53M]
  ------------------
  235|  5.56M|			++piece;
  236|  5.56M|		}
  237|       |
  238|       |		// write renamed files
  239|  5.02k|		if (!atp.renamed_files.empty())
  ------------------
  |  Branch (239:7): [True: 238, False: 4.78k]
  ------------------
  240|    238|		{
  241|    238|			entry::list_type& fl = ret["mapped_files"].list();
  242|    238|			for (auto const& ent : atp.renamed_files)
  ------------------
  |  Branch (242:25): [True: 61.7k, False: 238]
  ------------------
  243|  61.7k|			{
  244|  61.7k|				auto const idx = static_cast<std::size_t>(static_cast<int>(ent.first));
  245|  61.7k|				if (idx >= fl.size()) fl.resize(idx + 1);
  ------------------
  |  Branch (245:9): [True: 61.7k, False: 0]
  ------------------
  246|  61.7k|				fl[idx] = ent.second;
  247|  61.7k|			}
  248|    238|		}
  249|       |
  250|       |		// write local peers
  251|  5.02k|		if (!atp.peers.empty())
  ------------------
  |  Branch (251:7): [True: 84, False: 4.93k]
  ------------------
  252|     84|		{
  253|     84|			std::back_insert_iterator<entry::string_type> ptr(ret["peers"].string());
  254|     84|			std::back_insert_iterator<entry::string_type> ptr6(ret["peers6"].string());
  255|     84|			for (auto const& p : atp.peers)
  ------------------
  |  Branch (255:23): [True: 42.9k, False: 84]
  ------------------
  256|  42.9k|			{
  257|  42.9k|				if (is_v6(p))
  ------------------
  |  Branch (257:9): [True: 4.29k, False: 38.7k]
  ------------------
  258|  4.29k|					write_endpoint(p, ptr6);
  259|  38.7k|				else
  260|  38.7k|					write_endpoint(p, ptr);
  261|  42.9k|			}
  262|     84|		}
  263|       |
  264|  5.02k|		if (!atp.banned_peers.empty())
  ------------------
  |  Branch (264:7): [True: 75, False: 4.94k]
  ------------------
  265|     75|		{
  266|     75|			std::back_insert_iterator<entry::string_type> ptr(ret["banned_peers"].string());
  267|     75|			std::back_insert_iterator<entry::string_type> ptr6(ret["banned_peers6"].string());
  268|     75|			for (auto const& p : atp.banned_peers)
  ------------------
  |  Branch (268:23): [True: 84.9k, False: 75]
  ------------------
  269|  84.9k|			{
  270|  84.9k|				if (is_v6(p))
  ------------------
  |  Branch (270:9): [True: 14.6k, False: 70.3k]
  ------------------
  271|  14.6k|					write_endpoint(p, ptr6);
  272|  70.3k|				else
  273|  70.3k|					write_endpoint(p, ptr);
  274|  84.9k|			}
  275|     75|		}
  276|       |
  277|  5.02k|		ret["upload_rate_limit"] = atp.upload_limit;
  278|  5.02k|		ret["download_rate_limit"] = atp.download_limit;
  279|  5.02k|		ret["max_connections"] = atp.max_connections;
  280|  5.02k|		ret["max_uploads"] = atp.max_uploads;
  281|       |
  282|  5.02k|		if (!atp.file_priorities.empty())
  ------------------
  |  Branch (282:7): [True: 0, False: 5.02k]
  ------------------
  283|      0|		{
  284|       |			// write file priorities
  285|      0|			entry::list_type& prio = ret["file_priority"].list();
  286|      0|			prio.reserve(atp.file_priorities.size());
  287|      0|			for (auto const p : atp.file_priorities)
  ------------------
  |  Branch (287:22): [True: 0, False: 0]
  ------------------
  288|      0|				prio.emplace_back(static_cast<std::uint8_t>(p));
  289|      0|		}
  290|       |
  291|  5.02k|		if (!atp.piece_priorities.empty())
  ------------------
  |  Branch (291:7): [True: 37, False: 4.98k]
  ------------------
  292|     37|		{
  293|       |			// write piece priorities
  294|     37|			entry::string_type& prio = ret["piece_priority"].string();
  295|     37|			prio.reserve(atp.piece_priorities.size());
  296|     37|			for (auto const p : atp.piece_priorities)
  ------------------
  |  Branch (296:22): [True: 7.66k, False: 37]
  ------------------
  297|  7.66k|				prio.push_back(static_cast<char>(static_cast<std::uint8_t>(p)));
  298|     37|		}
  299|       |
  300|  5.02k|		return ret;
  301|  5.02k|	}
_ZN10libtorrent21write_resume_data_bufERKNS_18add_torrent_paramsE:
  433|  5.02k|	{
  434|  5.02k|		std::vector<char> ret;
  435|  5.02k|		entry rd = write_resume_data(atp);
  436|  5.02k|		bencode(std::back_inserter(ret), rd);
  437|  5.02k|		return ret;
  438|  5.02k|	}
write_resume_data.cpp:_ZN10libtorrent12_GLOBAL__N_118build_tracker_listERKNSt3__16vectorINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS6_IS8_EEEERKNS2_IiNS6_IiEEEE:
   52|  5.02k|	{
   53|  5.02k|		entry ret;
   54|  5.02k|		entry::list_type& tr_list = ret.list();
   55|  5.02k|		if (trackers.empty()) return ret;
  ------------------
  |  Branch (55:7): [True: 4.11k, False: 902]
  ------------------
   56|       |
   57|    902|		tr_list.emplace_back(entry::list_type());
   58|    902|		std::size_t tier = 0;
   59|    902|		auto tier_it = tracker_tiers.begin();
   60|    902|		for (std::string const& tr : trackers)
  ------------------
  |  Branch (60:30): [True: 3.38M, False: 902]
  ------------------
   61|  3.38M|		{
   62|  3.38M|			if (tier_it != tracker_tiers.end())
  ------------------
  |  Branch (62:8): [True: 3.38M, False: 0]
  ------------------
   63|  3.38M|				tier = aux::clamp(std::size_t(*tier_it++), std::size_t{0}, std::size_t{1024});
   64|       |
   65|  3.38M|			if (tr_list.size() <= tier)
  ------------------
  |  Branch (65:8): [True: 7.09k, False: 3.37M]
  ------------------
   66|  7.09k|				tr_list.resize(tier + 1);
   67|       |
   68|  3.38M|			tr_list[tier].list().emplace_back(tr);
   69|  3.38M|		}
   70|    902|		return ret;
   71|  5.02k|	}