_ZNK5boost15source_location9file_nameEv:
   52|    135|    {
   53|    135|        return file_;
   54|    135|    }
_ZNK5boost15source_location4lineEv:
   62|    135|    {
   63|    135|        return line_;
   64|    135|    }
_ZNK5boost15source_location13function_nameEv:
   57|    135|    {
   58|    135|        return function_;
   59|    135|    }
_ZNK5boost15source_location6columnEv:
   67|    135|    {
   68|    135|        return column_;
   69|    135|    }
_ZN5boost15source_locationC2EPKcjS2_j:
   39|    135|    BOOST_CONSTEXPR source_location( char const * file, boost::uint_least32_t ln, char const * function, boost::uint_least32_t col = 0 ) BOOST_NOEXCEPT: file_( file ), function_( function ), line_( ln ), column_( col )
   40|    135|    {
   41|    135|    }

_ZN5boost15throw_exceptionISt13runtime_errorEEvRKT_RKNS_15source_locationE:
  169|    135|{
  170|    135|    throw_exception_assert_compatibility( e );
  171|    135|    throw wrapexcept<E>( e, loc );
  172|    135|}
_ZN5boost36throw_exception_assert_compatibilityERKSt9exception:
  140|    135|inline void throw_exception_assert_compatibility( std::exception const & ) {}
_ZN5boost10wrapexceptISt13runtime_errorEC2ERKS1_RKNS_15source_locationE:
  102|    135|    explicit wrapexcept( E const & e, boost::source_location const & loc ): E( e )
  103|    135|    {
  104|    135|        copy_from( &e );
  105|       |
  106|    135|        set_info( *this, throw_file( loc.file_name() ) );
  107|    135|        set_info( *this, throw_line( static_cast<int>( loc.line() ) ) );
  108|    135|        set_info( *this, throw_function( loc.function_name() ) );
  109|    135|        set_info( *this, throw_column( static_cast<int>( loc.column() ) ) );
  110|    135|    }
_ZN5boost10wrapexceptISt13runtime_errorE9copy_fromEPKv:
   87|    135|    {
   88|    135|    }

_ZN5boost5uuids6detail20basic_name_generatorINS1_4sha1EEC2ERKNS0_4uuidE:
   41|    139|        : namespace_uuid_( namespace_uuid )
   42|    139|    {}
_ZNK5boost5uuids6detail20basic_name_generatorINS1_4sha1EEclIcNSt3__111char_traitsIcEENS6_9allocatorIcEEEENS0_4uuidERKNS6_12basic_stringIT_T0_T1_EE:
   56|      4|    {
   57|      4|        HashAlgo hash;
   58|       |
   59|      4|        hash.process_bytes( namespace_uuid_.begin(), namespace_uuid_.size() );
   60|      4|        process_characters( hash, name.c_str(), name.length() );
   61|       |
   62|      4|        return hash_to_uuid( hash );
   63|      4|    }
_ZNK5boost5uuids6detail20basic_name_generatorINS1_4sha1EE18process_charactersERS3_PKcm:
   78|      4|    {
   79|      4|        hash.process_bytes( p, n );
   80|      4|    }
_ZNK5boost5uuids6detail20basic_name_generatorINS1_4sha1EE12hash_to_uuidERS3_:
  191|      4|    {
  192|      4|        digest_type digest;
  193|      4|        hash.get_digest(digest);
  194|       |
  195|      4|        BOOST_UUID_STATIC_ASSERT( sizeof(digest_type) >= 16 );
  ------------------
  |  |    8|      4|#define BOOST_UUID_STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
  ------------------
  196|       |
  197|      4|        uuid u;
  198|      4|        std::memcpy( u.data, digest, 16 );
  199|       |
  200|       |        // set variant: must be 0b10xxxxxx
  201|      4|        *(u.begin()+8) &= 0x3F;
  202|      4|        *(u.begin()+8) |= 0x80;
  203|       |
  204|       |        // set version
  205|      4|        unsigned char hashver = hash.get_version();
  206|      4|        *(u.begin()+6) &= 0x0F;             // clear out the relevant bits
  207|      4|        *(u.begin()+6) |= (hashver << 4);   // and apply them
  208|       |
  209|      4|        return u;
  210|      4|    }

_ZN5boost5uuids6detail15load_little_u32EPKv:
  163|     48|{
  164|     48|    std::uint32_t tmp;
  165|     48|    std::memcpy( &tmp, p, sizeof( tmp ) );
  166|       |
  167|     48|#if BOOST_UUID_BYTE_ORDER == BOOST_UUID_ORDER_LITTLE_ENDIAN
  168|       |
  169|     48|    return tmp;
  170|       |
  171|       |#else
  172|       |
  173|       |    return detail::byteswap( tmp );
  174|       |
  175|       |#endif
  176|     48|}
_ZN5boost5uuids6detail13store_big_u32EPvj:
  328|     20|{
  329|     20|#if BOOST_UUID_BYTE_ORDER != BOOST_UUID_ORDER_BIG_ENDIAN
  330|       |
  331|     20|    v = detail::byteswap( v );
  332|       |
  333|     20|#endif
  334|       |
  335|     20|    std::memcpy( p, &v, sizeof( v ) );
  336|     20|}
_ZN5boost5uuids6detail8byteswapEj:
   55|     20|{
   56|     20|    return __builtin_bswap32( x );
   57|     20|}

_ZN5boost5uuids6detail11hash_mix_mxEm:
   23|     48|{
   24|     48|    x *= 0xD96AAA55;
   25|     48|    x ^= x >> 16;
   26|     48|    return x;
   27|     48|}
_ZN5boost5uuids6detail12hash_mix_fmxEm:
   33|     12|{
   34|     12|    x *= 0x7DF954AB;
   35|     12|    x ^= x >> 16;
   36|     12|    return x;
   37|     12|}

_ZN5boost5uuids6detail4sha1C2Ev:
   64|      4|{
   65|      4|    reset();
   66|      4|}
_ZN5boost5uuids6detail4sha15resetEv:
   69|      4|{
   70|      4|    h_[0] = 0x67452301;
   71|      4|    h_[1] = 0xEFCDAB89;
   72|      4|    h_[2] = 0x98BADCFE;
   73|      4|    h_[3] = 0x10325476;
   74|      4|    h_[4] = 0xC3D2E1F0;
   75|       |
   76|      4|    block_byte_index_ = 0;
   77|      4|    bit_count_low = 0;
   78|      4|    bit_count_high = 0;
   79|      4|}
_ZN5boost5uuids6detail4sha113process_bytesEPKvm:
  116|      8|{
  117|      8|    unsigned char const* b = static_cast<unsigned char const*>(buffer);
  118|      8|    process_block(b, b+byte_count);
  119|      8|}
_ZN5boost5uuids6detail4sha113process_blockEPKvS4_:
  107|      8|{
  108|      8|    unsigned char const* begin = static_cast<unsigned char const*>(bytes_begin);
  109|      8|    unsigned char const* end = static_cast<unsigned char const*>(bytes_end);
  110|    212|    for(; begin != end; ++begin) {
  ------------------
  |  Branch (110:11): [True: 204, False: 8]
  ------------------
  111|    204|        process_byte(*begin);
  112|    204|    }
  113|      8|}
_ZN5boost5uuids6detail4sha112process_byteEh:
   82|    204|{
   83|    204|    process_byte_impl(byte);
   84|       |
   85|       |    // size_t max value = 0xFFFFFFFF
   86|       |    //if (bit_count_low + 8 >= 0x100000000) { // would overflow
   87|       |    //if (bit_count_low >= 0x100000000-8) {
   88|    204|    if (bit_count_low < 0xFFFFFFF8) {
  ------------------
  |  Branch (88:9): [True: 204, False: 0]
  ------------------
   89|    204|        bit_count_low += 8;
   90|    204|    } else {
   91|      0|        bit_count_low = 0;
   92|      0|        ++bit_count_high;
   93|      0|    }
   94|    204|}
_ZN5boost5uuids6detail4sha117process_byte_implEh:
   97|    256|{
   98|    256|    block_[block_byte_index_++] = byte;
   99|       |
  100|    256|    if (block_byte_index_ == 64) {
  ------------------
  |  Branch (100:9): [True: 4, False: 252]
  ------------------
  101|      4|        block_byte_index_ = 0;
  102|      4|        process_block();
  103|      4|    }
  104|    256|}
_ZN5boost5uuids6detail4sha113process_blockEv:
  122|      4|{
  123|      4|    unsigned int w[80];
  124|     68|    for (std::size_t i=0; i<16; ++i) {
  ------------------
  |  Branch (124:27): [True: 64, False: 4]
  ------------------
  125|     64|        w[i]  = (block_[i*4 + 0] << 24);
  126|     64|        w[i] |= (block_[i*4 + 1] << 16);
  127|     64|        w[i] |= (block_[i*4 + 2] << 8);
  128|     64|        w[i] |= (block_[i*4 + 3]);
  129|     64|    }
  130|    260|    for (std::size_t i=16; i<80; ++i) {
  ------------------
  |  Branch (130:28): [True: 256, False: 4]
  ------------------
  131|    256|        w[i] = left_rotate((w[i-3] ^ w[i-8] ^ w[i-14] ^ w[i-16]), 1);
  132|    256|    }
  133|       |
  134|      4|    unsigned int a = h_[0];
  135|      4|    unsigned int b = h_[1];
  136|      4|    unsigned int c = h_[2];
  137|      4|    unsigned int d = h_[3];
  138|      4|    unsigned int e = h_[4];
  139|       |
  140|    324|    for (std::size_t i=0; i<80; ++i) {
  ------------------
  |  Branch (140:27): [True: 320, False: 4]
  ------------------
  141|    320|        unsigned int f;
  142|    320|        unsigned int k;
  143|       |
  144|    320|        if (i<20) {
  ------------------
  |  Branch (144:13): [True: 80, False: 240]
  ------------------
  145|     80|            f = (b & c) | (~b & d);
  146|     80|            k = 0x5A827999;
  147|    240|        } else if (i<40) {
  ------------------
  |  Branch (147:20): [True: 80, False: 160]
  ------------------
  148|     80|            f = b ^ c ^ d;
  149|     80|            k = 0x6ED9EBA1;
  150|    160|        } else if (i<60) {
  ------------------
  |  Branch (150:20): [True: 80, False: 80]
  ------------------
  151|     80|            f = (b & c) | (b & d) | (c & d);
  152|     80|            k = 0x8F1BBCDC;
  153|     80|        } else {
  154|     80|            f = b ^ c ^ d;
  155|     80|            k = 0xCA62C1D6;
  156|     80|        }
  157|       |
  158|    320|        unsigned temp = left_rotate(a, 5) + f + e + k + w[i];
  159|    320|        e = d;
  160|    320|        d = c;
  161|    320|        c = left_rotate(b, 30);
  162|    320|        b = a;
  163|    320|        a = temp;
  164|    320|    }
  165|       |
  166|      4|    h_[0] += a;
  167|      4|    h_[1] += b;
  168|      4|    h_[2] += c;
  169|      4|    h_[3] += d;
  170|      4|    h_[4] += e;
  171|      4|}
_ZN5boost5uuids6detail11left_rotateEjm:
   24|    896|{
   25|    896|    return (x<<n) ^ (x>> (32-n));
   26|    896|}
_ZN5boost5uuids6detail4sha110get_digestERA20_h:
  180|      4|{
  181|       |    // append the bit '1' to the message
  182|      4|    process_byte_impl(0x80);
  183|       |
  184|       |    // append k bits '0', where k is the minimum number >= 0
  185|       |    // such that the resulting message length is congruent to 56 (mod 64)
  186|       |    // check if there is enough space for padding and bit_count
  187|      4|    if (block_byte_index_ > 56) {
  ------------------
  |  Branch (187:9): [True: 0, False: 4]
  ------------------
  188|       |        // finish this block
  189|      0|        while (block_byte_index_ != 0) {
  ------------------
  |  Branch (189:16): [True: 0, False: 0]
  ------------------
  190|      0|            process_byte_impl(0);
  191|      0|        }
  192|       |
  193|       |        // one more block
  194|      0|        while (block_byte_index_ < 56) {
  ------------------
  |  Branch (194:16): [True: 0, False: 0]
  ------------------
  195|      0|            process_byte_impl(0);
  196|      0|        }
  197|      4|    } else {
  198|     20|        while (block_byte_index_ < 56) {
  ------------------
  |  Branch (198:16): [True: 16, False: 4]
  ------------------
  199|     16|            process_byte_impl(0);
  200|     16|        }
  201|      4|    }
  202|       |
  203|       |    // append length of message (before pre-processing)
  204|       |    // as a 64-bit big-endian integer
  205|      4|    process_byte_impl( static_cast<unsigned char>((bit_count_high>>24) & 0xFF) );
  206|      4|    process_byte_impl( static_cast<unsigned char>((bit_count_high>>16) & 0xFF) );
  207|      4|    process_byte_impl( static_cast<unsigned char>((bit_count_high>>8 ) & 0xFF) );
  208|      4|    process_byte_impl( static_cast<unsigned char>((bit_count_high)     & 0xFF) );
  209|      4|    process_byte_impl( static_cast<unsigned char>((bit_count_low>>24) & 0xFF) );
  210|      4|    process_byte_impl( static_cast<unsigned char>((bit_count_low>>16) & 0xFF) );
  211|      4|    process_byte_impl( static_cast<unsigned char>((bit_count_low>>8 ) & 0xFF) );
  212|      4|    process_byte_impl( static_cast<unsigned char>((bit_count_low)     & 0xFF) );
  213|       |
  214|       |    // get final digest
  215|      4|    detail::store_big_u32( digest +  0, h_[0] );
  216|      4|    detail::store_big_u32( digest +  4, h_[1] );
  217|      4|    detail::store_big_u32( digest +  8, h_[2] );
  218|      4|    detail::store_big_u32( digest + 12, h_[3] );
  219|      4|    detail::store_big_u32( digest + 16, h_[4] );
  220|      4|}
_ZNK5boost5uuids6detail4sha111get_versionEv:
  174|      4|{
  175|       |    // RFC 4122 Section 4.1.3
  176|      4|        return uuid::version_name_based_sha1;
  177|      4|}

_ZN5boost5uuids6detail8to_charsIcEEPT_RKNS0_4uuidES4_:
   45|      4|{
   46|      4|    constexpr Ch const* p = digits( static_cast<Ch const*>( nullptr ) );
   47|       |
   48|     68|    for( std::size_t i = 0; i < 16; ++i )
  ------------------
  |  Branch (48:29): [True: 64, False: 4]
  ------------------
   49|     64|    {
   50|     64|        std::uint8_t ch = u.data()[ i ];
   51|       |
   52|     64|        *out++ = p[ (ch >> 4) & 0x0F ];
   53|     64|        *out++ = p[ ch & 0x0F ];
   54|       |
   55|     64|        if( i == 3 || i == 5 || i == 7 || i == 9 )
  ------------------
  |  Branch (55:13): [True: 4, False: 60]
  |  Branch (55:23): [True: 4, False: 56]
  |  Branch (55:33): [True: 4, False: 52]
  |  Branch (55:43): [True: 4, False: 48]
  ------------------
   56|     16|        {
   57|     16|            *out++ = p[ 16 ];
   58|     16|        }
   59|     64|    }
   60|       |
   61|      4|    return out;
   62|      4|}
_ZN5boost5uuids6detail8to_charsIwEEPT_RKNS0_4uuidES4_:
   45|      4|{
   46|      4|    constexpr Ch const* p = digits( static_cast<Ch const*>( nullptr ) );
   47|       |
   48|     68|    for( std::size_t i = 0; i < 16; ++i )
  ------------------
  |  Branch (48:29): [True: 64, False: 4]
  ------------------
   49|     64|    {
   50|     64|        std::uint8_t ch = u.data()[ i ];
   51|       |
   52|     64|        *out++ = p[ (ch >> 4) & 0x0F ];
   53|     64|        *out++ = p[ ch & 0x0F ];
   54|       |
   55|     64|        if( i == 3 || i == 5 || i == 7 || i == 9 )
  ------------------
  |  Branch (55:13): [True: 4, False: 60]
  |  Branch (55:23): [True: 4, False: 56]
  |  Branch (55:33): [True: 4, False: 52]
  |  Branch (55:43): [True: 4, False: 48]
  ------------------
   56|     16|        {
   57|     16|            *out++ = p[ 16 ];
   58|     16|        }
   59|     64|    }
   60|       |
   61|      4|    return out;
   62|      4|}

_ZN5boost5uuids4uuid4swapERS1_:
  117|      4|{
  118|      4|    __m128i mm_this = uuids::detail::load_unaligned_si128(data);
  119|      4|    __m128i mm_rhs = uuids::detail::load_unaligned_si128(rhs.data);
  120|      4|    _mm_storeu_si128(reinterpret_cast< __m128i* >(rhs.data+0), mm_this);
  121|      4|    _mm_storeu_si128(reinterpret_cast< __m128i* >(data+0), mm_rhs);
  122|      4|}
_ZN5boost5uuids6detail20load_unaligned_si128EPKh:
   53|      8|{
   54|      8|    return _mm_loadu_si128(reinterpret_cast< const __m128i* >(p));
   55|      8|}

_ZN5boost5uuids19name_generator_sha1C2ERKNS0_4uuidE:
   21|    139|        detail::basic_name_generator<detail::sha1>( namespace_uuid )
   22|    139|    {
   23|    139|    }

_ZN5boost5uuids2ns3urlEv:
   24|    139|{
   25|    139|    uuid result = {{
   26|    139|        0x6b, 0xa7, 0xb8, 0x11, 0x9d, 0xad, 0x11, 0xd1,
   27|    139|        0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8 }};
   28|    139|    return result;
   29|    139|}

_ZNK5boost5uuids16string_generatorclIcNSt3__111char_traitsIcEENS3_9allocatorIcEEEENS0_4uuidERKNS3_12basic_stringIT_T0_T1_EE:
   37|    139|    {
   38|    139|        return operator()(s.begin(), s.end());
   39|    139|    }
_ZNK5boost5uuids16string_generatorclINSt3__111__wrap_iterIPKcEEEENS0_4uuidET_S9_:
   53|    139|    {
   54|    139|        using char_type = typename std::iterator_traits<CharIterator>::value_type;
   55|       |
   56|    139|        int ipos = 0;
   57|       |
   58|       |        // check open brace
   59|    139|        char_type c = get_next_char( begin, end, ipos );
   60|       |
   61|    139|        bool has_open_brace = is_open_brace( c );
   62|       |
   63|    139|        char_type open_brace_char = c;
   64|       |
   65|    139|        if( has_open_brace )
  ------------------
  |  Branch (65:13): [True: 17, False: 122]
  ------------------
   66|     17|        {
   67|     17|            c = get_next_char( begin, end, ipos );
   68|     17|        }
   69|       |
   70|    139|        bool has_dashes = false;
   71|       |
   72|    139|        uuid u;
   73|       |
   74|    139|        int i = 0;
   75|       |
   76|    978|        for( uuid::iterator it_byte = u.begin(); it_byte != u.end(); ++it_byte, ++i )
  ------------------
  |  Branch (76:50): [True: 839, False: 139]
  ------------------
   77|    839|        {
   78|    839|            if( it_byte != u.begin() )
  ------------------
  |  Branch (78:17): [True: 701, False: 138]
  ------------------
   79|    701|            {
   80|    701|                c = get_next_char( begin, end, ipos );
   81|    701|            }
   82|       |
   83|    839|            if( i == 4 )
  ------------------
  |  Branch (83:17): [True: 76, False: 763]
  ------------------
   84|     76|            {
   85|     76|                has_dashes = is_dash( c );
   86|       |
   87|     76|                if( has_dashes )
  ------------------
  |  Branch (87:21): [True: 29, False: 47]
  ------------------
   88|     29|                {
   89|     29|                    c = get_next_char( begin, end, ipos );
   90|     29|                }
   91|     76|            }
   92|    763|            else if( i == 6 || i == 8 || i == 10 )
  ------------------
  |  Branch (92:22): [True: 66, False: 697]
  |  Branch (92:32): [True: 31, False: 666]
  |  Branch (92:42): [True: 28, False: 638]
  ------------------
   93|    114|            {
   94|       |                // if there are dashes, they must be in every slot
   95|    114|                if( has_dashes )
  ------------------
  |  Branch (95:21): [True: 29, False: 85]
  ------------------
   96|     29|                {
   97|     29|                    if( is_dash( c ) )
  ------------------
  |  Branch (97:25): [True: 14, False: 15]
  ------------------
   98|     14|                    {
   99|     14|                        c = get_next_char( begin, end, ipos );
  100|     14|                    }
  101|     15|                    else
  102|     15|                    {
  103|     15|                        throw_invalid( ipos - 1, "dash expected" );
  104|     15|                    }
  105|     29|                }
  106|    114|            }
  107|       |
  108|    839|            *it_byte = get_value( c, ipos - 1 );
  109|       |
  110|    839|            c = get_next_char( begin, end, ipos );
  111|       |
  112|    839|            *it_byte <<= 4;
  113|    839|            *it_byte |= get_value( c, ipos - 1 );
  114|    839|        }
  115|       |
  116|       |        // check close brace
  117|    139|        if( has_open_brace )
  ------------------
  |  Branch (117:13): [True: 14, False: 125]
  ------------------
  118|     14|        {
  119|     14|            c = get_next_char( begin, end, ipos );
  120|     14|            check_close_brace( c, open_brace_char, ipos - 1 );
  121|     14|        }
  122|       |
  123|       |        // check end of string - any additional data is an invalid uuid
  124|    139|        if( begin != end )
  ------------------
  |  Branch (124:13): [True: 7, False: 132]
  ------------------
  125|      7|        {
  126|      7|            throw_invalid( ipos, "unexpected extra input" );
  127|      7|        }
  128|       |
  129|    139|        return u;
  130|    139|    }
_ZNK5boost5uuids16string_generator13get_next_charINSt3__111__wrap_iterIPKcEEEENS3_15iterator_traitsIT_E10value_typeERS9_S9_Ri:
  145|  1.67k|    {
  146|  1.67k|        if( begin == end )
  ------------------
  |  Branch (146:13): [True: 34, False: 1.63k]
  ------------------
  147|     34|        {
  148|     34|            throw_invalid( ipos, "unexpected end of input" );
  149|     34|        }
  150|       |
  151|  1.67k|        ++ipos;
  152|  1.67k|        return *begin++;
  153|  1.67k|    }
_ZNK5boost5uuids16string_generator13is_open_braceEc:
  205|    139|    {
  206|    139|        return c == '{';
  207|    139|    }
_ZNK5boost5uuids16string_generator7is_dashEc:
  194|    105|    {
  195|    105|        return c == '-';
  196|    105|    }
_ZNK5boost5uuids16string_generator13throw_invalidEiPKc:
  135|    135|    {
  136|    135|        char buffer[ 16 ];
  137|    135|        std::snprintf( buffer, sizeof( buffer ), "%d", ipos );
  138|       |
  139|    135|        BOOST_THROW_EXCEPTION( std::runtime_error( std::string( "Invalid UUID string at position " ) + buffer + ": " + error ) );
  ------------------
  |  |  182|    135|#define BOOST_THROW_EXCEPTION(x) ::boost::throw_exception(x, BOOST_CURRENT_LOCATION)
  |  |  ------------------
  |  |  |  |  175|    135|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN())
  |  |  ------------------
  ------------------
  140|    135|    }
_ZNK5boost5uuids16string_generator9get_valueEci:
  156|  1.55k|    {
  157|  1.55k|        static char const digits_begin[] = "0123456789abcdefABCDEF";
  158|  1.55k|        static size_t digits_len = (sizeof(digits_begin) / sizeof(char)) - 1;
  159|  1.55k|        static char const* const digits_end = digits_begin + digits_len;
  160|       |
  161|  1.55k|        static unsigned char const values[] =
  162|  1.55k|            { 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,10,11,12,13,14,15 };
  163|       |
  164|  1.55k|        size_t pos = std::find( digits_begin, digits_end, c ) - digits_begin;
  165|       |
  166|  1.55k|        if( pos >= digits_len )
  ------------------
  |  Branch (166:13): [True: 68, False: 1.48k]
  ------------------
  167|     68|        {
  168|     68|            throw_invalid( ipos, "hex digit expected" );
  169|     68|        }
  170|       |
  171|  1.55k|        return values[ pos ];
  172|  1.55k|    }
_ZNK5boost5uuids16string_generator17check_close_braceEcci:
  215|     13|    {
  216|     13|        if( open_brace == '{' && c == '}' )
  ------------------
  |  Branch (216:13): [True: 13, False: 0]
  |  Branch (216:34): [True: 2, False: 11]
  ------------------
  217|      2|        {
  218|       |            //great
  219|      2|        }
  220|     11|        else
  221|     11|        {
  222|     11|            throw_invalid( ipos, "closing brace expected" );
  223|     11|        }
  224|     13|    }

_ZN5boost5uuids4uuidC2ERA16_Kh:
  126|    139|    {
  127|    139|        if( __builtin_is_constant_evaluated() )
  ------------------
  |  Branch (127:13): [Folded - Ignored]
  ------------------
  128|      0|        {
  129|      0|            for( int i = 0; i < 16; ++i ) data[ i ] = r[ i ];
  ------------------
  |  Branch (129:29): [True: 0, False: 0]
  ------------------
  130|      0|        }
  131|    139|        else
  132|    139|        {
  133|    139|            std::memcpy( data, r, 16 );
  134|    139|        }
  135|    139|    }
_ZN5boost5uuids4uuid9data_typecvRA16_hEv:
   79|  1.15k|        BOOST_CXX14_CONSTEXPR operator repr_type& () noexcept { return repr_; }
_ZN5boost5uuids4uuidC2Ev:
  114|    424|    uuid() = default;
_ZNKSt3__14hashIN5boost5uuids4uuidEEclERKS3_:
  391|      8|    {
  392|      8|        return boost::uuids::hash_value( value );
  393|      8|    }
_ZN5boost5uuids10hash_valueERKNS0_4uuidE:
  355|     12|{
  356|     12|    std::uint64_t r = 0;
  357|       |
  358|     12|    r = detail::hash_mix_mx( r + detail::load_little_u32( u.data +  0 ) );
  359|     12|    r = detail::hash_mix_mx( r + detail::load_little_u32( u.data +  4 ) );
  360|     12|    r = detail::hash_mix_mx( r + detail::load_little_u32( u.data +  8 ) );
  361|     12|    r = detail::hash_mix_mx( r + detail::load_little_u32( u.data + 12 ) );
  362|       |
  363|     12|    return static_cast<std::size_t>( detail::hash_mix_fmx( r ) );
  364|     12|}
_ZNK5boost5uuids4uuid9data_typecvRA16_KhEv:
   80|     52|        constexpr operator repr_type const& () const noexcept { return repr_; }
_ZNK5boost5uuids4uuid9data_typeclEv:
   83|    128|        constexpr std::uint8_t const* operator()() const noexcept { return repr_; }
_ZN5boost5uuids4swapERNS0_4uuidES2_:
  348|      4|{
  349|      4|    lhs.swap( rhs );
  350|      4|}
_ZN5boost5uuids4uuid5beginEv:
  156|    993|    iterator begin() noexcept { return data; }
_ZN5boost5uuids4uuid3endEv:
  159|    862|    iterator end() noexcept { return data() + size(); }
_ZN5boost5uuids4uuid9data_typeclEv:
   82|    862|        BOOST_CXX14_CONSTEXPR std::uint8_t* operator()() noexcept { return repr_; }
_ZNK5boost5uuids4uuid4sizeEv:
  164|    866|    constexpr size_type size() const noexcept { return static_size(); }
_ZN5boost5uuids4uuid11static_sizeEv:
  170|    866|    static constexpr size_type static_size() noexcept { return 16; }
_ZNK5boost5uuids4uuid5beginEv:
  157|      4|    const_iterator begin() const noexcept { return data; }

_ZN5boost5uuids9to_stringERKNS0_4uuidE:
  154|      4|{
  155|      4|    std::string result( 36, char() );
  156|       |
  157|       |    // string::data() returns const char* before C++17
  158|      4|    detail::to_chars( u, &result[0] );
  159|      4|    return result;
  160|      4|}
_ZN5boost5uuids10to_wstringERKNS0_4uuidE:
  163|      4|{
  164|      4|    std::wstring result( 36, wchar_t() );
  165|       |
  166|      4|    detail::to_chars( u, &result[0] );
  167|      4|    return result;
  168|      4|}

LLVMFuzzerTestOneInput:
   24|    139|extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size){
   25|       |    
   26|    139|    try{
   27|    139|        FuzzedDataProvider fdp(Data, Size);
   28|    139|        std::string s = fdp.ConsumeRemainingBytesAsString();
   29|       |
   30|    139|        string_generator gen_string;
   31|    139|        name_generator_sha1 gen_name(ns::url());
   32|    139|        hash<uuid> hasher;
   33|       |
   34|    139|        uuid u_string, u_name;
   35|       |
   36|    139|        u_string = gen_string(s);
   37|    139|        u_name = gen_name(s);
   38|       |        
   39|    139|        size_t string_hash = hasher(u_string);
   40|    139|        size_t name_hash = hash_value(u_name);
   41|    139|        size_t uuid_hash_value = hasher(boost::uuids::uuid());
   42|       |
   43|    139|        string out_string = to_string(u_string);
   44|    139|        wstring out_wstring = to_wstring(u_string);
   45|       |
   46|    139|        swap(u_string, u_name);
   47|    139|    } catch(...) {
   48|    135|    }
   49|       |
   50|    139|    return 0;
   51|    139|}