_ZN5boost3anyD2Ev:
  108|   258k|        {
  109|   258k|            delete content;
  110|   258k|        }
_ZN5boost3anyC2Ev:
   40|   213k|          : content(0)
   41|   213k|        {
   42|   213k|        }
_ZNK5boost3any5emptyEv:
  181|  36.9k|        {
  182|  36.9k|            return !content;
  183|  36.9k|        }
_ZN5boost3anyaSERKS0_:
  136|  11.2k|        {
  137|  11.2k|            any(rhs).swap(*this);
  138|  11.2k|            return *this;
  139|  11.2k|        }
_ZN5boost3anyC2ERKS0_:
   71|  22.4k|          : content(other.content ? other.content->clone() : 0)
  ------------------
  |  Branch (71:21): [True: 22.4k, False: 0]
  ------------------
   72|  22.4k|        {
   73|  22.4k|        }
_ZN5boost3any4swapERS0_:
  119|  79.7k|        {
  120|  79.7k|            placeholder* tmp = content;
  121|  79.7k|            content = rhs.content;
  122|  79.7k|            rhs.content = tmp;
  123|  79.7k|            return *this;
  124|  79.7k|        }
_ZN5boost8any_castINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEPKT_PKNS_3anyE:
  299|    232|    {
  300|    232|        return boost::any_cast<ValueType>(const_cast<any *>(operand));
  301|    232|    }
_ZN5boost8any_castINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEPT_PNS_3anyE:
  289|    232|    {
  290|    232|        return operand && operand->type() == boost::typeindex::type_id<ValueType>()
  ------------------
  |  Branch (290:16): [True: 232, False: 0]
  |  Branch (290:27): [True: 232, False: 0]
  ------------------
  291|    232|            ? boost::unsafe_any_cast<typename std::remove_cv<ValueType>::type>(operand)
  292|    232|            : 0;
  293|    232|    }
_ZNK5boost3any4typeEv:
  198|  12.6k|        {
  199|  12.6k|            return content ? content->type() : boost::typeindex::type_id<void>().type_info();
  ------------------
  |  Branch (199:20): [True: 12.6k, False: 0]
  ------------------
  200|  12.6k|        }
_ZN5boost15unsafe_any_castINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEPT_PNS_3anyE:
  272|    232|    {
  273|    232|        return std::addressof(
  274|    232|            static_cast<any::holder<ValueType> *>(operand->content)->held
  275|    232|        );
  276|    232|    }
_ZN5boost8any_castIiEEPKT_PKNS_3anyE:
  299|    414|    {
  300|    414|        return boost::any_cast<ValueType>(const_cast<any *>(operand));
  301|    414|    }
_ZN5boost8any_castIiEEPT_PNS_3anyE:
  289|    414|    {
  290|    414|        return operand && operand->type() == boost::typeindex::type_id<ValueType>()
  ------------------
  |  Branch (290:16): [True: 414, False: 0]
  |  Branch (290:27): [True: 414, False: 0]
  ------------------
  291|    414|            ? boost::unsafe_any_cast<typename std::remove_cv<ValueType>::type>(operand)
  292|    414|            : 0;
  293|    414|    }
_ZN5boost15unsafe_any_castIiEEPT_PNS_3anyE:
  272|    414|    {
  273|    414|        return std::addressof(
  274|    414|            static_cast<any::holder<ValueType> *>(operand->content)->held
  275|    414|        );
  276|    414|    }
_ZN5boost3anyC2IiEEOT_PNSt3__19enable_ifIXntsr3std7is_sameIRS0_S2_EE5valueEvE4typeEPNS5_IXntsr8is_constIS2_EE5valueEvE4typeE:
   96|    506|          : content(new holder< typename std::decay<ValueType>::type >(std::forward<ValueType>(value)))
   97|    506|        {
   98|    506|            static_assert(
   99|    506|                !anys::detail::is_basic_any<typename std::decay<ValueType>::type>::value,
  100|    506|                "boost::any shall not be constructed from boost::anys::basic_any"
  101|    506|            );
  102|    506|        }
_ZN5boost3any6holderIiEC2EOi:
  222|    506|              : held(static_cast< ValueType&& >(value))
  223|    506|            {
  224|    506|            }
_ZNK5boost3any6holderIiE4typeEv:
  229|    414|            {
  230|    414|                return boost::typeindex::type_id<ValueType>().type_info();
  231|    414|            }
_ZN5boost3anyaSEOS0_:
  150|  34.2k|        {
  151|  34.2k|            rhs.swap(*this);
  152|  34.2k|            any().swap(rhs);
  153|  34.2k|            return *this;
  154|  34.2k|        }
_ZN5boost8any_castIfEEPKT_PKNS_3anyE:
  299|    430|    {
  300|    430|        return boost::any_cast<ValueType>(const_cast<any *>(operand));
  301|    430|    }
_ZN5boost8any_castIfEEPT_PNS_3anyE:
  289|    430|    {
  290|    430|        return operand && operand->type() == boost::typeindex::type_id<ValueType>()
  ------------------
  |  Branch (290:16): [True: 430, False: 0]
  |  Branch (290:27): [True: 430, False: 0]
  ------------------
  291|    430|            ? boost::unsafe_any_cast<typename std::remove_cv<ValueType>::type>(operand)
  292|    430|            : 0;
  293|    430|    }
_ZN5boost15unsafe_any_castIfEEPT_PNS_3anyE:
  272|    430|    {
  273|    430|        return std::addressof(
  274|    430|            static_cast<any::holder<ValueType> *>(operand->content)->held
  275|    430|        );
  276|    430|    }
_ZN5boost3anyC2IfEEOT_PNSt3__19enable_ifIXntsr3std7is_sameIRS0_S2_EE5valueEvE4typeEPNS5_IXntsr8is_constIS2_EE5valueEvE4typeE:
   96|    571|          : content(new holder< typename std::decay<ValueType>::type >(std::forward<ValueType>(value)))
   97|    571|        {
   98|    571|            static_assert(
   99|    571|                !anys::detail::is_basic_any<typename std::decay<ValueType>::type>::value,
  100|    571|                "boost::any shall not be constructed from boost::anys::basic_any"
  101|    571|            );
  102|    571|        }
_ZN5boost3any6holderIfEC2EOf:
  222|    571|              : held(static_cast< ValueType&& >(value))
  223|    571|            {
  224|    571|            }
_ZNK5boost3any6holderIfE4typeEv:
  229|    430|            {
  230|    430|                return boost::typeindex::type_id<ValueType>().type_info();
  231|    430|            }
_ZN5boost8any_castIdEEPKT_PKNS_3anyE:
  299|     60|    {
  300|     60|        return boost::any_cast<ValueType>(const_cast<any *>(operand));
  301|     60|    }
_ZN5boost8any_castIdEEPT_PNS_3anyE:
  289|     60|    {
  290|     60|        return operand && operand->type() == boost::typeindex::type_id<ValueType>()
  ------------------
  |  Branch (290:16): [True: 60, False: 0]
  |  Branch (290:27): [True: 60, False: 0]
  ------------------
  291|     60|            ? boost::unsafe_any_cast<typename std::remove_cv<ValueType>::type>(operand)
  292|     60|            : 0;
  293|     60|    }
_ZN5boost15unsafe_any_castIdEEPT_PNS_3anyE:
  272|     60|    {
  273|     60|        return std::addressof(
  274|     60|            static_cast<any::holder<ValueType> *>(operand->content)->held
  275|     60|        );
  276|     60|    }
_ZN5boost3anyC2IdEEOT_PNSt3__19enable_ifIXntsr3std7is_sameIRS0_S2_EE5valueEvE4typeEPNS5_IXntsr8is_constIS2_EE5valueEvE4typeE:
   96|     72|          : content(new holder< typename std::decay<ValueType>::type >(std::forward<ValueType>(value)))
   97|     72|        {
   98|     72|            static_assert(
   99|     72|                !anys::detail::is_basic_any<typename std::decay<ValueType>::type>::value,
  100|     72|                "boost::any shall not be constructed from boost::anys::basic_any"
  101|     72|            );
  102|     72|        }
_ZN5boost3any6holderIdEC2EOd:
  222|     72|              : held(static_cast< ValueType&& >(value))
  223|     72|            {
  224|     72|            }
_ZNK5boost3any6holderIdE4typeEv:
  229|     60|            {
  230|     60|                return boost::typeindex::type_id<ValueType>().type_info();
  231|     60|            }
_ZN5boost8any_castIbEEPKT_PKNS_3anyE:
  299|  11.5k|    {
  300|  11.5k|        return boost::any_cast<ValueType>(const_cast<any *>(operand));
  301|  11.5k|    }
_ZN5boost8any_castIbEEPT_PNS_3anyE:
  289|  11.5k|    {
  290|  11.5k|        return operand && operand->type() == boost::typeindex::type_id<ValueType>()
  ------------------
  |  Branch (290:16): [True: 11.5k, False: 0]
  |  Branch (290:27): [True: 11.5k, False: 0]
  ------------------
  291|  11.5k|            ? boost::unsafe_any_cast<typename std::remove_cv<ValueType>::type>(operand)
  292|  11.5k|            : 0;
  293|  11.5k|    }
_ZN5boost15unsafe_any_castIbEEPT_PNS_3anyE:
  272|  11.5k|    {
  273|  11.5k|        return std::addressof(
  274|  11.5k|            static_cast<any::holder<ValueType> *>(operand->content)->held
  275|  11.5k|        );
  276|  11.5k|    }
_ZN5boost3anyC2IbEERKT_:
   52|  21.1k|          : content(new holder<
   53|  21.1k|                typename std::remove_cv<typename std::decay<const ValueType>::type>::type
   54|  21.1k|            >(value))
   55|  21.1k|        {
   56|  21.1k|            static_assert(
   57|  21.1k|                !anys::detail::is_basic_any<ValueType>::value,
   58|  21.1k|                "boost::any shall not be constructed from boost::anys::basic_any"
   59|  21.1k|            );
   60|  21.1k|        }
_ZN5boost3any6holderIbEC2ERKb:
  217|  43.5k|              : held(value)
  218|  43.5k|            {
  219|  43.5k|            }
_ZNK5boost3any6holderIbE4typeEv:
  229|  11.5k|            {
  230|  11.5k|                return boost::typeindex::type_id<ValueType>().type_info();
  231|  11.5k|            }
_ZNK5boost3any6holderIbE5cloneEv:
  234|  22.4k|            {
  235|  22.4k|                return new holder(held);
  236|  22.4k|            }
_ZN5boost3anyC2IbEEOT_PNSt3__19enable_ifIXntsr3std7is_sameIRS0_S2_EE5valueEvE4typeEPNS5_IXntsr8is_constIS2_EE5valueEvE4typeE:
   96|    458|          : content(new holder< typename std::decay<ValueType>::type >(std::forward<ValueType>(value)))
   97|    458|        {
   98|    458|            static_assert(
   99|    458|                !anys::detail::is_basic_any<typename std::decay<ValueType>::type>::value,
  100|    458|                "boost::any shall not be constructed from boost::anys::basic_any"
  101|    458|            );
  102|    458|        }
_ZN5boost3any6holderIbEC2EOb:
  222|    458|              : held(static_cast< ValueType&& >(value))
  223|    458|            {
  224|    458|            }
_ZN5boost3anyC2INSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEERKT_:
   52|    294|          : content(new holder<
   53|    294|                typename std::remove_cv<typename std::decay<const ValueType>::type>::type
   54|    294|            >(value))
   55|    294|        {
   56|    294|            static_assert(
   57|    294|                !anys::detail::is_basic_any<ValueType>::value,
   58|    294|                "boost::any shall not be constructed from boost::anys::basic_any"
   59|    294|            );
   60|    294|        }
_ZN5boost3any6holderINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEC2ERKS8_:
  217|    294|              : held(value)
  218|    294|            {
  219|    294|            }
_ZNK5boost3any6holderINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE4typeEv:
  229|    232|            {
  230|    232|                return boost::typeindex::type_id<ValueType>().type_info();
  231|    232|            }

_ZN5boost4anys6detail11placeholderD2Ev:
   24|  45.4k|    virtual ~placeholder() {}

_ZN5boost14checked_deleteIKNS_15program_options14value_semanticEEEvPT_:
   32|  65.5k|{
   33|  65.5k|#if defined(__cpp_static_assert) && __cpp_static_assert >= 200410L
   34|       |
   35|  65.5k|    static_assert( sizeof(T) != 0, "Type must be complete" );
   36|       |
   37|       |#else
   38|       |
   39|       |    typedef char type_must_be_complete[ sizeof(T) ];
   40|       |    (void) sizeof(type_must_be_complete);
   41|       |
   42|       |#endif
   43|       |
   44|  65.5k|    delete x;
   45|  65.5k|}
_ZN5boost14checked_deleteINS_15program_options18option_descriptionEEEvPT_:
   32|  65.5k|{
   33|  65.5k|#if defined(__cpp_static_assert) && __cpp_static_assert >= 200410L
   34|       |
   35|  65.5k|    static_assert( sizeof(T) != 0, "Type must be complete" );
   36|       |
   37|       |#else
   38|       |
   39|       |    typedef char type_must_be_complete[ sizeof(T) ];
   40|       |    (void) sizeof(type_must_be_complete);
   41|       |
   42|       |#endif
   43|       |
   44|  65.5k|    delete x;
   45|  65.5k|}

_ZN5boost4core8copysignIfEET_S2_S2_:
  286|      3|{
  287|      3|    return boost::core::detail::copysign_impl( x, y );
  288|      3|}
_ZN5boost4core6detail13copysign_implEff:
  269|      3|{
  270|      3|    return __builtin_copysignf( x, y );
  271|      3|}
_ZN5boost4core8copysignIdEET_S2_S2_:
  286|      1|{
  287|      1|    return boost::core::detail::copysign_impl( x, y );
  288|      1|}
_ZN5boost4core6detail13copysign_implEdd:
  274|      1|{
  275|      1|    return __builtin_copysign( x, y );
  276|      1|}

_ZN5boost6detail16basic_pointerbufIcNSt3__115basic_streambufIcNS2_11char_traitsIcEEEEEC2Ev:
   43|    958|   basic_pointerbuf() : base_type() { this_type::setbuf(0, 0); }
_ZN5boost6detail16basic_pointerbufIcNSt3__115basic_streambufIcNS2_11char_traitsIcEEEEE6setbufEPcl:
   66|  1.91k|{
   67|  1.91k|   this->setg(s, s, s + n);
   68|  1.91k|   return this;
   69|  1.91k|}

_ZN5boost6detail19lcast_set_precisionIfEEvRNSt3__18ios_baseEPT_:
   68|    738|{
   69|    738|    stream.precision(lcast_precision<T>::value);
   70|    738|}
_ZN5boost6detail19lcast_set_precisionIdEEvRNSt3__18ios_baseEPT_:
   68|    220|{
   69|    220|    stream.precision(lcast_precision<T>::value);
   70|    220|}

_ZN5boost15program_options6detail18utf8_codecvt_facetC2Em:
   49|      2|    std::codecvt<wchar_t, char, std::mbstate_t>(no_locale_manage)
   50|      2|{}

_ZN5boost13function_baseC2Ev:
  497|  65.5k|  function_base() : vtable(0) { }
_ZNK5boost13function_base5emptyEv:
  500|  12.6k|  bool empty() const { return !vtable; }

_ZNK5boost10function_nIvJRKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEcvbEv:
  888|    232|    explicit operator bool () const { return !this->empty(); }
_ZN5boost10function_nIvJRKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEED2Ev:
  782|  8.46k|    ~function_n() { clear(); }
_ZN5boost10function_nIvJRKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEE5clearEv:
  880|  8.46k|    {
  881|  8.46k|      if (vtable) {
  ------------------
  |  Branch (881:11): [True: 0, False: 8.46k]
  ------------------
  882|      0|        if (!this->has_trivial_copy_and_destroy())
  ------------------
  |  Branch (882:13): [True: 0, False: 0]
  ------------------
  883|      0|          get_vtable()->clear(this->functor);
  884|      0|        vtable = 0;
  885|      0|      }
  886|  8.46k|    }
_ZNK5boost10function_nIvJRKiEEcvbEv:
  888|    414|    explicit operator bool () const { return !this->empty(); }
_ZN5boost10function_nIvJRKiEED2Ev:
  782|  10.5k|    ~function_n() { clear(); }
_ZN5boost10function_nIvJRKiEE5clearEv:
  880|  10.5k|    {
  881|  10.5k|      if (vtable) {
  ------------------
  |  Branch (881:11): [True: 0, False: 10.5k]
  ------------------
  882|      0|        if (!this->has_trivial_copy_and_destroy())
  ------------------
  |  Branch (882:13): [True: 0, False: 0]
  ------------------
  883|      0|          get_vtable()->clear(this->functor);
  884|      0|        vtable = 0;
  885|      0|      }
  886|  10.5k|    }
_ZNK5boost10function_nIvJRKfEEcvbEv:
  888|    430|    explicit operator bool () const { return !this->empty(); }
_ZN5boost10function_nIvJRKfEED2Ev:
  782|  23.2k|    ~function_n() { clear(); }
_ZN5boost10function_nIvJRKfEE5clearEv:
  880|  23.2k|    {
  881|  23.2k|      if (vtable) {
  ------------------
  |  Branch (881:11): [True: 0, False: 23.2k]
  ------------------
  882|      0|        if (!this->has_trivial_copy_and_destroy())
  ------------------
  |  Branch (882:13): [True: 0, False: 0]
  ------------------
  883|      0|          get_vtable()->clear(this->functor);
  884|      0|        vtable = 0;
  885|      0|      }
  886|  23.2k|    }
_ZNK5boost10function_nIvJRKdEEcvbEv:
  888|     60|    explicit operator bool () const { return !this->empty(); }
_ZN5boost10function_nIvJRKdEED2Ev:
  782|  2.11k|    ~function_n() { clear(); }
_ZN5boost10function_nIvJRKdEE5clearEv:
  880|  2.11k|    {
  881|  2.11k|      if (vtable) {
  ------------------
  |  Branch (881:11): [True: 0, False: 2.11k]
  ------------------
  882|      0|        if (!this->has_trivial_copy_and_destroy())
  ------------------
  |  Branch (882:13): [True: 0, False: 0]
  ------------------
  883|      0|          get_vtable()->clear(this->functor);
  884|      0|        vtable = 0;
  885|      0|      }
  886|  2.11k|    }
_ZNK5boost10function_nIvJRKbEEcvbEv:
  888|  11.5k|    explicit operator bool () const { return !this->empty(); }
_ZN5boost10function_nIvJRKbEED2Ev:
  782|  21.1k|    ~function_n() { clear(); }
_ZN5boost10function_nIvJRKbEE5clearEv:
  880|  21.1k|    {
  881|  21.1k|      if (vtable) {
  ------------------
  |  Branch (881:11): [True: 0, False: 21.1k]
  ------------------
  882|      0|        if (!this->has_trivial_copy_and_destroy())
  ------------------
  |  Branch (882:13): [True: 0, False: 0]
  ------------------
  883|      0|          get_vtable()->clear(this->functor);
  884|      0|        vtable = 0;
  885|      0|      }
  886|  21.1k|    }

_ZN5boost9iteratorsneINS_15program_options6detail27common_config_file_iteratorEKNS2_12basic_optionIcEENS0_21forward_traversal_tagERS7_lS4_S7_S8_S9_lEENS0_6detail23enable_if_interoperableIT_T4_NS_3mpl6apply2INSA_12always_bool2ESC_SD_E4typeEE4typeERKNS0_15iterator_facadeISC_T0_T1_T2_T3_EERKNSL_ISD_T5_T6_T7_T8_EE:
  961|  1.44M|  {                                                                             \
  962|  1.44M|      /* For those compilers that do not support enable_if */                   \
  963|  1.44M|      BOOST_STATIC_ASSERT((                                                     \
  ------------------
  |  |   71|  1.44M|#     define BOOST_STATIC_ASSERT( ... ) static_assert(__VA_ARGS__, #__VA_ARGS__)
  ------------------
  964|  1.44M|          is_interoperable< Derived1, Derived2 >::value                         \
  965|  1.44M|      ));                                                                       \
  966|  1.44M|      return_prefix iterator_core_access::base_op(                              \
  967|  1.44M|          *static_cast<Derived1 const*>(&lhs)                                   \
  968|  1.44M|        , *static_cast<Derived2 const*>(&rhs)                                   \
  969|  1.44M|        , BOOST_ITERATOR_CONVERTIBLE(Derived2,Derived1)                         \
  ------------------
  |  |  956|  1.44M|#  define BOOST_ITERATOR_CONVERTIBLE(a,b) is_convertible<a,b>()
  ------------------
  970|  1.44M|      );                                                                        \
  971|  1.44M|  }
_ZN5boost9iterators20iterator_core_access5equalINS_15program_options6detail27common_config_file_iteratorES5_EEbRKT_RKT0_N4mpl_5bool_ILb1EEE:
  648|  1.44M|      {
  649|  1.44M|          return f1.equal(f2);
  650|  1.44M|      }
_ZNK5boost9iterators6detail20iterator_facade_baseINS_15program_options6detail27common_config_file_iteratorEKNS3_12basic_optionIcEENS0_21forward_traversal_tagERS8_lLb0ELb0EEdeEv:
  736|  1.43M|        {
  737|  1.43M|            return iterator_core_access::dereference(this->derived());
  738|  1.43M|        }
_ZN5boost9iterators20iterator_core_access11dereferenceINS_15program_options6detail27common_config_file_iteratorEEENT_9referenceERKS6_:
  630|  1.43M|      {
  631|  1.43M|          return f.dereference();
  632|  1.43M|      }
_ZNK5boost9iterators6detail20iterator_facade_baseINS_15program_options6detail27common_config_file_iteratorEKNS3_12basic_optionIcEENS0_21forward_traversal_tagERS8_lLb0ELb0EE7derivedEv:
  761|  1.43M|        {
  762|  1.43M|            return *static_cast<Derived const*>(this);
  763|  1.43M|        }
_ZN5boost9iterators6detail20iterator_facade_baseINS_15program_options6detail27common_config_file_iteratorEKNS3_12basic_optionIcEENS0_21forward_traversal_tagERS8_lLb0ELb0EEppEv:
  746|  1.43M|        {
  747|  1.43M|            iterator_core_access::increment(this->derived());
  748|  1.43M|            return this->derived();
  749|  1.43M|        }
_ZN5boost9iterators20iterator_core_access9incrementINS_15program_options6detail27common_config_file_iteratorEEEvRT_:
  636|  1.43M|      {
  637|  1.43M|          f.increment();
  638|  1.43M|      }
_ZN5boost9iterators6detail20iterator_facade_baseINS_15program_options6detail27common_config_file_iteratorEKNS3_12basic_optionIcEENS0_21forward_traversal_tagERS8_lLb0ELb0EE7derivedEv:
  756|  2.87M|        {
  757|  2.87M|            return *static_cast<Derived*>(this);
  758|  2.87M|        }

_ZN5boost12lexical_castIiNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEET_RKT0_:
   39|    641|    {
   40|    641|        Target result = Target();
   41|       |
   42|    641|        if (!boost::conversion::detail::try_lexical_convert(arg, result)) {
  ------------------
  |  Branch (42:13): [True: 135, False: 506]
  ------------------
   43|    135|            boost::conversion::detail::throw_bad_cast<Source, Target>();
   44|    135|        }
   45|       |
   46|    641|        return result;
   47|    641|    }
_ZN5boost12lexical_castIfNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEET_RKT0_:
   39|    761|    {
   40|    761|        Target result = Target();
   41|       |
   42|    761|        if (!boost::conversion::detail::try_lexical_convert(arg, result)) {
  ------------------
  |  Branch (42:13): [True: 190, False: 571]
  ------------------
   43|    190|            boost::conversion::detail::throw_bad_cast<Source, Target>();
   44|    190|        }
   45|       |
   46|    761|        return result;
   47|    761|    }
_ZN5boost12lexical_castIdNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEET_RKT0_:
   39|    230|    {
   40|    230|        Target result = Target();
   41|       |
   42|    230|        if (!boost::conversion::detail::try_lexical_convert(arg, result)) {
  ------------------
  |  Branch (42:13): [True: 158, False: 72]
  ------------------
   43|    158|            boost::conversion::detail::throw_bad_cast<Source, Target>();
   44|    158|        }
   45|       |
   46|    230|        return result;
   47|    230|    }
_ZN5boost12lexical_castINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbEET_RKT0_:
   39|  21.1k|    {
   40|  21.1k|        Target result = Target();
   41|       |
   42|  21.1k|        if (!boost::conversion::detail::try_lexical_convert(arg, result)) {
  ------------------
  |  Branch (42:13): [True: 0, False: 21.1k]
  ------------------
   43|      0|            boost::conversion::detail::throw_bad_cast<Source, Target>();
   44|      0|        }
   45|       |
   46|  21.1k|        return result;
   47|  21.1k|    }

_ZN5boost10conversion6detail14throw_bad_castINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEiEEvv:
   92|    135|        inline void throw_bad_cast() {
   93|    135|            boost::throw_exception(bad_lexical_cast(typeid(S), typeid(T)));
   94|    135|        }
_ZN5boost16bad_lexical_castC2ERKS0_:
   53|    483|        bad_lexical_cast(const bad_lexical_cast&) = default;
_ZN5boost16bad_lexical_castC2ERKSt9type_infoS3_:
   67|    483|            : source(&source_type_arg), target(&target_type_arg)
   68|    483|        {}
_ZN5boost10conversion6detail14throw_bad_castINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEfEEvv:
   92|    190|        inline void throw_bad_cast() {
   93|    190|            boost::throw_exception(bad_lexical_cast(typeid(S), typeid(T)));
   94|    190|        }
_ZN5boost10conversion6detail14throw_bad_castINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEdEEvv:
   92|    158|        inline void throw_bad_cast() {
   93|    158|            boost::throw_exception(bad_lexical_cast(typeid(S), typeid(T)));
   94|    158|        }

_ZN5boost6detail22lexical_converter_implIiNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE11try_convertERKS8_Ri:
  461|    641|            static inline bool try_convert(const Source& arg, Target& result) {
  462|    641|                from_src_stream src_stream;
  463|    641|                if (!src_stream.stream_in(lcast::exact<Source>{arg}))
  ------------------
  |  Branch (463:21): [True: 0, False: 641]
  ------------------
  464|      0|                    return false;
  465|       |
  466|    641|                to_target_stream out(src_stream.cbegin(), src_stream.cend());
  467|    641|                if (!out.stream_out(result))
  ------------------
  |  Branch (467:21): [True: 135, False: 506]
  ------------------
  468|    135|                    return false;
  469|       |
  470|    506|                return true;
  471|    641|            }
_ZN5boost6detail22lexical_converter_implIfNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE11try_convertERKS8_Rf:
  461|    761|            static inline bool try_convert(const Source& arg, Target& result) {
  462|    761|                from_src_stream src_stream;
  463|    761|                if (!src_stream.stream_in(lcast::exact<Source>{arg}))
  ------------------
  |  Branch (463:21): [True: 0, False: 761]
  ------------------
  464|      0|                    return false;
  465|       |
  466|    761|                to_target_stream out(src_stream.cbegin(), src_stream.cend());
  467|    761|                if (!out.stream_out(result))
  ------------------
  |  Branch (467:21): [True: 190, False: 571]
  ------------------
  468|    190|                    return false;
  469|       |
  470|    571|                return true;
  471|    761|            }
_ZN5boost6detail22lexical_converter_implIdNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE11try_convertERKS8_Rd:
  461|    230|            static inline bool try_convert(const Source& arg, Target& result) {
  462|    230|                from_src_stream src_stream;
  463|    230|                if (!src_stream.stream_in(lcast::exact<Source>{arg}))
  ------------------
  |  Branch (463:21): [True: 0, False: 230]
  ------------------
  464|      0|                    return false;
  465|       |
  466|    230|                to_target_stream out(src_stream.cbegin(), src_stream.cend());
  467|    230|                if (!out.stream_out(result))
  ------------------
  |  Branch (467:21): [True: 158, False: 72]
  ------------------
  468|    158|                    return false;
  469|       |
  470|     72|                return true;
  471|    230|            }
_ZN5boost6detail22lexical_converter_implINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEbE11try_convertERKbRS8_:
  461|  21.1k|            static inline bool try_convert(const Source& arg, Target& result) {
  462|  21.1k|                from_src_stream src_stream;
  463|  21.1k|                if (!src_stream.stream_in(lcast::exact<Source>{arg}))
  ------------------
  |  Branch (463:21): [True: 0, False: 21.1k]
  ------------------
  464|      0|                    return false;
  465|       |
  466|  21.1k|                to_target_stream out(src_stream.cbegin(), src_stream.cend());
  467|  21.1k|                if (!out.stream_out(result))
  ------------------
  |  Branch (467:21): [True: 0, False: 21.1k]
  ------------------
  468|      0|                    return false;
  469|       |
  470|  21.1k|                return true;
  471|  21.1k|            }

_ZN5boost6detail5lcast20optimized_src_streamIcNSt3__111char_traitsIcEELm2EEC2Ev:
  124|  22.7k|          : start(buffer)
  125|  22.7k|          , finish(buffer + CharacterBufferSize)
  126|  22.7k|        {}
_ZN5boost6detail5lcast20optimized_src_streamIcNSt3__111char_traitsIcEELm2EE9stream_inIS5_NS3_9allocatorIcEEEEbNS1_5exactINS3_12basic_stringIcT_T0_EEEE:
  269|  1.63k|        bool stream_in(lcast::exact<std::basic_string<CharT,CharTraits,Alloc>> x) noexcept {
  270|  1.63k|            start = x.payload.data();
  271|  1.63k|            finish = start + x.payload.length();
  272|  1.63k|            return true;
  273|  1.63k|        }
_ZNK5boost6detail5lcast20optimized_src_streamIcNSt3__111char_traitsIcEELm2EE6cbeginEv:
  128|  22.7k|        const CharT* cbegin() const noexcept {
  129|  22.7k|            return start;
  130|  22.7k|        }
_ZNK5boost6detail5lcast20optimized_src_streamIcNSt3__111char_traitsIcEELm2EE4cendEv:
  132|  22.7k|        const CharT* cend() const noexcept {
  133|  22.7k|            return finish;
  134|  22.7k|        }
_ZN5boost6detail5lcast16to_target_streamIcNSt3__111char_traitsIcEEEC2EPKcS8_:
  492|  22.7k|          : start(begin)
  493|  22.7k|          , finish(end)
  494|  22.7k|        {}
_ZN5boost6detail5lcast16to_target_streamIcNSt3__111char_traitsIcEEE10stream_outERi:
  629|    641|        bool stream_out(int& output)                        { return shr_signed(output); }
_ZN5boost6detail5lcast16to_target_streamIcNSt3__111char_traitsIcEEE10shr_signedIiEEbRT_:
  525|    641|        bool shr_signed(Type& output) {
  526|    641|            if (start == finish) return false;
  ------------------
  |  Branch (526:17): [True: 22, False: 619]
  ------------------
  527|    619|            CharT const minus = lcast_char_constants<CharT>::minus;
  528|    619|            CharT const plus = lcast_char_constants<CharT>::plus;
  529|    619|            typedef typename make_unsigned<Type>::type utype;
  530|    619|            utype out_tmp = 0;
  531|    619|            bool const has_minus = Traits::eq(minus, *start);
  532|       |
  533|       |            /* We won`t use `start' any more, so no need in decrementing it after */
  534|    619|            if (has_minus || Traits::eq(plus, *start)) {
  ------------------
  |  Branch (534:17): [True: 135, False: 484]
  |  Branch (534:30): [True: 3, False: 481]
  ------------------
  535|    138|                ++start;
  536|    138|            }
  537|       |
  538|    619|            bool succeed = lcast_ret_unsigned<Traits, utype, CharT>(out_tmp, start, finish).convert();
  539|    619|            if (has_minus) {
  ------------------
  |  Branch (539:17): [True: 135, False: 484]
  ------------------
  540|    135|                utype const comp_val = (static_cast<utype>(1) << std::numeric_limits<Type>::digits);
  541|    135|                succeed = succeed && out_tmp<=comp_val;
  ------------------
  |  Branch (541:27): [True: 119, False: 16]
  |  Branch (541:38): [True: 118, False: 1]
  ------------------
  542|    135|                output = static_cast<Type>(0u - out_tmp);
  543|    484|            } else {
  544|    484|                utype const comp_val = static_cast<utype>((std::numeric_limits<Type>::max)());
  545|    484|                succeed = succeed && out_tmp<=comp_val;
  ------------------
  |  Branch (545:27): [True: 422, False: 62]
  |  Branch (545:38): [True: 388, False: 34]
  ------------------
  546|    484|                output = static_cast<Type>(out_tmp);
  547|    484|            }
  548|    619|            return succeed;
  549|    641|        }
_ZN5boost6detail5lcast16to_target_streamIcNSt3__111char_traitsIcEEE10stream_outERf:
  741|    761|        bool stream_out(float& output) { return float_types_converter_internal(output); }
_ZN5boost6detail5lcast16to_target_streamIcNSt3__111char_traitsIcEEE30float_types_converter_internalIfEEbRT_:
  714|    761|        bool float_types_converter_internal(T& output) {
  715|    761|            if (parse_inf_nan(start, finish, output)) return true;
  ------------------
  |  Branch (715:17): [True: 23, False: 738]
  ------------------
  716|    738|            bool const return_value = shr_using_base_class(output);
  717|       |
  718|       |            /* Some compilers and libraries successfully
  719|       |             * parse 'inf', 'INFINITY', '1.0E', '1.0E-'...
  720|       |             * We are trying to provide a unified behaviour,
  721|       |             * so we just forbid such conversions (as some
  722|       |             * of the most popular compilers/libraries do)
  723|       |             * */
  724|    738|            CharT const minus = lcast_char_constants<CharT>::minus;
  725|    738|            CharT const plus = lcast_char_constants<CharT>::plus;
  726|    738|            CharT const capital_e = lcast_char_constants<CharT>::capital_e;
  727|    738|            CharT const lowercase_e = lcast_char_constants<CharT>::lowercase_e;
  728|    738|            if ( return_value &&
  ------------------
  |  Branch (728:18): [True: 550, False: 188]
  ------------------
  729|    738|                 (
  730|    550|                    Traits::eq(*(finish-1), lowercase_e)                   // 1.0e
  ------------------
  |  Branch (730:21): [True: 1, False: 549]
  ------------------
  731|    550|                    || Traits::eq(*(finish-1), capital_e)                  // 1.0E
  ------------------
  |  Branch (731:24): [True: 1, False: 548]
  ------------------
  732|    550|                    || Traits::eq(*(finish-1), minus)                      // 1.0e- or 1.0E-
  ------------------
  |  Branch (732:24): [True: 0, False: 548]
  ------------------
  733|    550|                    || Traits::eq(*(finish-1), plus)                       // 1.0e+ or 1.0E+
  ------------------
  |  Branch (733:24): [True: 0, False: 548]
  ------------------
  734|    550|                 )
  735|    738|            ) return false;
  736|       |
  737|    736|            return return_value;
  738|    738|        }
_ZN5boost6detail5lcast16to_target_streamIcNSt3__111char_traitsIcEEE20shr_using_base_classIfEEbRT_:
  553|    738|        {
  554|    738|            static_assert(
  555|    738|                !boost::is_pointer<InputStreamable>::value,
  556|    738|                "boost::lexical_cast can not convert to pointers"
  557|    738|            );
  558|       |
  559|       |#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_LOCALE)
  560|       |            static_assert(boost::is_same<char, CharT>::value,
  561|       |                "boost::lexical_cast can not convert, because your STL library does not "
  562|       |                "support such conversions. Try updating it."
  563|       |            );
  564|       |#endif
  565|       |
  566|       |#if defined(BOOST_NO_STRINGSTREAM)
  567|       |            std::istrstream stream(start, static_cast<std::istrstream::streamsize>(finish - start));
  568|       |#else
  569|    738|            typedef detail::lcast::buffer_t<CharT, Traits> buffer_t;
  570|    738|            buffer_t buf;
  571|       |            // Usually `istream` and `basic_istream` do not modify
  572|       |            // content of buffer; `buffer_t` assures that this is true
  573|    738|            buf.setbuf(const_cast<CharT*>(start), static_cast<typename buffer_t::streamsize>(finish - start));
  574|       |#if defined(BOOST_NO_STD_LOCALE)
  575|       |            std::istream stream(&buf);
  576|       |#else
  577|    738|            std::basic_istream<CharT, Traits> stream(&buf);
  578|    738|#endif // BOOST_NO_STD_LOCALE
  579|    738|#endif // BOOST_NO_STRINGSTREAM
  580|       |
  581|    738|#ifndef BOOST_NO_EXCEPTIONS
  582|    738|            stream.exceptions(std::ios::badbit);
  583|    738|            try {
  584|    738|#endif
  585|    738|            stream.unsetf(std::ios::skipws);
  586|    738|            lcast_set_precision(stream, static_cast<InputStreamable*>(0));
  587|       |
  588|    738|            return (stream >> output)
  ------------------
  |  Branch (588:20): [True: 620, False: 118]
  ------------------
  589|    738|                && (stream.get() == Traits::eof());
  ------------------
  |  Branch (589:20): [True: 550, False: 70]
  ------------------
  590|       |
  591|    738|#ifndef BOOST_NO_EXCEPTIONS
  592|    738|            } catch (const ::std::ios_base::failure& /*f*/) {
  593|      0|                return false;
  594|      0|            }
  595|    738|#endif
  596|    738|        }
_ZN5boost6detail5lcast16to_target_streamIcNSt3__111char_traitsIcEEE10stream_outERd:
  742|    230|        bool stream_out(double& output) { return float_types_converter_internal(output); }
_ZN5boost6detail5lcast16to_target_streamIcNSt3__111char_traitsIcEEE30float_types_converter_internalIdEEbRT_:
  714|    230|        bool float_types_converter_internal(T& output) {
  715|    230|            if (parse_inf_nan(start, finish, output)) return true;
  ------------------
  |  Branch (715:17): [True: 10, False: 220]
  ------------------
  716|    220|            bool const return_value = shr_using_base_class(output);
  717|       |
  718|       |            /* Some compilers and libraries successfully
  719|       |             * parse 'inf', 'INFINITY', '1.0E', '1.0E-'...
  720|       |             * We are trying to provide a unified behaviour,
  721|       |             * so we just forbid such conversions (as some
  722|       |             * of the most popular compilers/libraries do)
  723|       |             * */
  724|    220|            CharT const minus = lcast_char_constants<CharT>::minus;
  725|    220|            CharT const plus = lcast_char_constants<CharT>::plus;
  726|    220|            CharT const capital_e = lcast_char_constants<CharT>::capital_e;
  727|    220|            CharT const lowercase_e = lcast_char_constants<CharT>::lowercase_e;
  728|    220|            if ( return_value &&
  ------------------
  |  Branch (728:18): [True: 65, False: 155]
  ------------------
  729|    220|                 (
  730|     65|                    Traits::eq(*(finish-1), lowercase_e)                   // 1.0e
  ------------------
  |  Branch (730:21): [True: 1, False: 64]
  ------------------
  731|     65|                    || Traits::eq(*(finish-1), capital_e)                  // 1.0E
  ------------------
  |  Branch (731:24): [True: 2, False: 62]
  ------------------
  732|     65|                    || Traits::eq(*(finish-1), minus)                      // 1.0e- or 1.0E-
  ------------------
  |  Branch (732:24): [True: 0, False: 62]
  ------------------
  733|     65|                    || Traits::eq(*(finish-1), plus)                       // 1.0e+ or 1.0E+
  ------------------
  |  Branch (733:24): [True: 0, False: 62]
  ------------------
  734|     65|                 )
  735|    220|            ) return false;
  736|       |
  737|    217|            return return_value;
  738|    220|        }
_ZN5boost6detail5lcast16to_target_streamIcNSt3__111char_traitsIcEEE20shr_using_base_classIdEEbRT_:
  553|    220|        {
  554|    220|            static_assert(
  555|    220|                !boost::is_pointer<InputStreamable>::value,
  556|    220|                "boost::lexical_cast can not convert to pointers"
  557|    220|            );
  558|       |
  559|       |#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_LOCALE)
  560|       |            static_assert(boost::is_same<char, CharT>::value,
  561|       |                "boost::lexical_cast can not convert, because your STL library does not "
  562|       |                "support such conversions. Try updating it."
  563|       |            );
  564|       |#endif
  565|       |
  566|       |#if defined(BOOST_NO_STRINGSTREAM)
  567|       |            std::istrstream stream(start, static_cast<std::istrstream::streamsize>(finish - start));
  568|       |#else
  569|    220|            typedef detail::lcast::buffer_t<CharT, Traits> buffer_t;
  570|    220|            buffer_t buf;
  571|       |            // Usually `istream` and `basic_istream` do not modify
  572|       |            // content of buffer; `buffer_t` assures that this is true
  573|    220|            buf.setbuf(const_cast<CharT*>(start), static_cast<typename buffer_t::streamsize>(finish - start));
  574|       |#if defined(BOOST_NO_STD_LOCALE)
  575|       |            std::istream stream(&buf);
  576|       |#else
  577|    220|            std::basic_istream<CharT, Traits> stream(&buf);
  578|    220|#endif // BOOST_NO_STD_LOCALE
  579|    220|#endif // BOOST_NO_STRINGSTREAM
  580|       |
  581|    220|#ifndef BOOST_NO_EXCEPTIONS
  582|    220|            stream.exceptions(std::ios::badbit);
  583|    220|            try {
  584|    220|#endif
  585|    220|            stream.unsetf(std::ios::skipws);
  586|    220|            lcast_set_precision(stream, static_cast<InputStreamable*>(0));
  587|       |
  588|    220|            return (stream >> output)
  ------------------
  |  Branch (588:20): [True: 120, False: 100]
  ------------------
  589|    220|                && (stream.get() == Traits::eof());
  ------------------
  |  Branch (589:20): [True: 65, False: 55]
  ------------------
  590|       |
  591|    220|#ifndef BOOST_NO_EXCEPTIONS
  592|    220|            } catch (const ::std::ios_base::failure& /*f*/) {
  593|      0|                return false;
  594|      0|            }
  595|    220|#endif
  596|    220|        }
_ZN5boost6detail5lcast20optimized_src_streamIcNSt3__111char_traitsIcEELm2EE9stream_inENS1_5exactIbEE:
  282|  21.1k|        bool stream_in(lcast::exact<bool> x) noexcept {
  283|  21.1k|            CharT const czero = lcast_char_constants<CharT>::zero;
  284|  21.1k|            Traits::assign(buffer[0], Traits::to_char_type(czero + x.payload));
  285|  21.1k|            finish = start + 1;
  286|  21.1k|            return true;
  287|  21.1k|        }
_ZN5boost6detail5lcast16to_target_streamIcNSt3__111char_traitsIcEEE10stream_outIS5_NS3_9allocatorIcEEEEbRNS3_12basic_stringIcT_T0_EE:
  657|  21.1k|        bool stream_out(std::basic_string<CharT,CharTraits,Alloc>& str) {
  658|  21.1k|            str.assign(start, finish); return true;
  659|  21.1k|        }

_ZN5boost6detail13parse_inf_nanIcfEEbPKT_S4_RT0_:
  170|    761|        bool parse_inf_nan(const CharT* begin, const CharT* end, T& value) noexcept {
  171|    761|            return parse_inf_nan_impl(begin, end, value
  172|    761|                               , "NAN", "nan"
  173|    761|                               , "INFINITY", "infinity"
  174|    761|                               , '(', ')');
  175|    761|        }
_ZN5boost6detail18parse_inf_nan_implIcfEEbPKT_S4_RT0_S4_S4_S4_S4_S2_S2_:
   56|    761|        {
   57|    761|            if (begin == end) return false;
  ------------------
  |  Branch (57:17): [True: 18, False: 743]
  ------------------
   58|    743|            const CharT minus = lcast_char_constants<CharT>::minus;
   59|    743|            const CharT plus = lcast_char_constants<CharT>::plus;
   60|    743|            const int inifinity_size = 8; // == sizeof("infinity") - 1
   61|       |
   62|       |            /* Parsing +/- */
   63|    743|            bool const has_minus = (*begin == minus);
   64|    743|            if (has_minus || *begin == plus) {
  ------------------
  |  Branch (64:17): [True: 43, False: 700]
  |  Branch (64:30): [True: 6, False: 694]
  ------------------
   65|     49|                ++ begin;
   66|     49|            }
   67|       |
   68|    743|            if (end - begin < 3) return false;
  ------------------
  |  Branch (68:17): [True: 528, False: 215]
  ------------------
   69|    215|            if (lc_iequal(begin, lc_nan, lc_NAN, 3)) {
  ------------------
  |  Branch (69:17): [True: 63, False: 152]
  ------------------
   70|     63|                begin += 3;
   71|     63|                if (end != begin) {
  ------------------
  |  Branch (71:21): [True: 50, False: 13]
  ------------------
   72|       |                    /* It is 'nan(...)' or some bad input*/
   73|       |
   74|     50|                    if (end - begin < 2) return false; // bad input
  ------------------
  |  Branch (74:25): [True: 1, False: 49]
  ------------------
   75|     49|                    -- end;
   76|     49|                    if (*begin != opening_brace || *end != closing_brace) return false; // bad input
  ------------------
  |  Branch (76:25): [True: 33, False: 16]
  |  Branch (76:52): [True: 15, False: 1]
  ------------------
   77|     49|                }
   78|       |
   79|     14|                if( !has_minus ) value = std::numeric_limits<T>::quiet_NaN();
  ------------------
  |  Branch (79:21): [True: 11, False: 3]
  ------------------
   80|      3|                else value = boost::core::copysign(std::numeric_limits<T>::quiet_NaN(), static_cast<T>(-1));
   81|     14|                return true;
   82|    152|            } else if (
   83|    152|                ( /* 'INF' or 'inf' */
   84|    152|                  end - begin == 3      // 3 == sizeof('inf') - 1
  ------------------
  |  Branch (84:19): [True: 58, False: 94]
  ------------------
   85|    152|                  && lc_iequal(begin, lc_infinity, lc_INFINITY, 3)
  ------------------
  |  Branch (85:22): [True: 8, False: 50]
  ------------------
   86|    152|                )
   87|    152|                ||
   88|    152|                ( /* 'INFINITY' or 'infinity' */
   89|    144|                  end - begin == inifinity_size
  ------------------
  |  Branch (89:19): [True: 20, False: 124]
  ------------------
   90|    144|                  && lc_iequal(begin, lc_infinity, lc_INFINITY, inifinity_size)
  ------------------
  |  Branch (90:22): [True: 1, False: 19]
  ------------------
   91|    144|                )
   92|    152|             )
   93|      9|            {
   94|      9|                if( !has_minus ) value = std::numeric_limits<T>::infinity();
  ------------------
  |  Branch (94:21): [True: 6, False: 3]
  ------------------
   95|      3|                else value = -std::numeric_limits<T>::infinity();
   96|      9|                return true;
   97|      9|            }
   98|       |
   99|    143|            return false;
  100|    215|        }
_ZN5boost6detail9lc_iequalIcEEbPKT_S4_S4_j:
   42|    504|        bool lc_iequal(const CharT* val, const CharT* lcase, const CharT* ucase, unsigned int len) noexcept {
   43|  1.03k|            for( unsigned int i=0; i < len; ++i ) {
  ------------------
  |  Branch (43:36): [True: 909, False: 123]
  ------------------
   44|    909|                if ( val[i] != lcase[i] && val[i] != ucase[i] ) return false;
  ------------------
  |  Branch (44:22): [True: 634, False: 275]
  |  Branch (44:44): [True: 381, False: 253]
  ------------------
   45|    909|            }
   46|       |
   47|    123|            return true;
   48|    504|        }
_ZN5boost6detail13parse_inf_nanIcdEEbPKT_S4_RT0_:
  170|    230|        bool parse_inf_nan(const CharT* begin, const CharT* end, T& value) noexcept {
  171|    230|            return parse_inf_nan_impl(begin, end, value
  172|    230|                               , "NAN", "nan"
  173|    230|                               , "INFINITY", "infinity"
  174|    230|                               , '(', ')');
  175|    230|        }
_ZN5boost6detail18parse_inf_nan_implIcdEEbPKT_S4_RT0_S4_S4_S4_S4_S2_S2_:
   56|    230|        {
   57|    230|            if (begin == end) return false;
  ------------------
  |  Branch (57:17): [True: 3, False: 227]
  ------------------
   58|    227|            const CharT minus = lcast_char_constants<CharT>::minus;
   59|    227|            const CharT plus = lcast_char_constants<CharT>::plus;
   60|    227|            const int inifinity_size = 8; // == sizeof("infinity") - 1
   61|       |
   62|       |            /* Parsing +/- */
   63|    227|            bool const has_minus = (*begin == minus);
   64|    227|            if (has_minus || *begin == plus) {
  ------------------
  |  Branch (64:17): [True: 5, False: 222]
  |  Branch (64:30): [True: 1, False: 221]
  ------------------
   65|      6|                ++ begin;
   66|      6|            }
   67|       |
   68|    227|            if (end - begin < 3) return false;
  ------------------
  |  Branch (68:17): [True: 74, False: 153]
  ------------------
   69|    153|            if (lc_iequal(begin, lc_nan, lc_NAN, 3)) {
  ------------------
  |  Branch (69:17): [True: 47, False: 106]
  ------------------
   70|     47|                begin += 3;
   71|     47|                if (end != begin) {
  ------------------
  |  Branch (71:21): [True: 43, False: 4]
  ------------------
   72|       |                    /* It is 'nan(...)' or some bad input*/
   73|       |
   74|     43|                    if (end - begin < 2) return false; // bad input
  ------------------
  |  Branch (74:25): [True: 1, False: 42]
  ------------------
   75|     42|                    -- end;
   76|     42|                    if (*begin != opening_brace || *end != closing_brace) return false; // bad input
  ------------------
  |  Branch (76:25): [True: 31, False: 11]
  |  Branch (76:52): [True: 9, False: 2]
  ------------------
   77|     42|                }
   78|       |
   79|      6|                if( !has_minus ) value = std::numeric_limits<T>::quiet_NaN();
  ------------------
  |  Branch (79:21): [True: 5, False: 1]
  ------------------
   80|      1|                else value = boost::core::copysign(std::numeric_limits<T>::quiet_NaN(), static_cast<T>(-1));
   81|      6|                return true;
   82|    106|            } else if (
   83|    106|                ( /* 'INF' or 'inf' */
   84|    106|                  end - begin == 3      // 3 == sizeof('inf') - 1
  ------------------
  |  Branch (84:19): [True: 38, False: 68]
  ------------------
   85|    106|                  && lc_iequal(begin, lc_infinity, lc_INFINITY, 3)
  ------------------
  |  Branch (85:22): [True: 3, False: 35]
  ------------------
   86|    106|                )
   87|    106|                ||
   88|    106|                ( /* 'INFINITY' or 'infinity' */
   89|    103|                  end - begin == inifinity_size
  ------------------
  |  Branch (89:19): [True: 20, False: 83]
  ------------------
   90|    103|                  && lc_iequal(begin, lc_infinity, lc_INFINITY, inifinity_size)
  ------------------
  |  Branch (90:22): [True: 1, False: 19]
  ------------------
   91|    103|                )
   92|    106|             )
   93|      4|            {
   94|      4|                if( !has_minus ) value = std::numeric_limits<T>::infinity();
  ------------------
  |  Branch (94:21): [True: 3, False: 1]
  ------------------
   95|      1|                else value = -std::numeric_limits<T>::infinity();
   96|      4|                return true;
   97|      4|            }
   98|       |
   99|    102|            return false;
  100|    153|        }

_ZN5boost6detail18lcast_ret_unsignedINSt3__111char_traitsIcEEjcEC2ERjPKcS8_:
  170|    619|                : m_multiplier_overflowed(false), m_multiplier(1), m_value(value), m_begin(begin), m_end(end)
  171|    619|            {
  172|    619|#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
  173|    619|                static_assert(!std::numeric_limits<T>::is_signed, "");
  174|       |
  175|       |                // GCC when used with flag -std=c++0x may not have std::numeric_limits
  176|       |                // specializations for __int128 and unsigned __int128 types.
  177|       |                // Try compilation with -std=gnu++0x or -std=gnu++11.
  178|       |                //
  179|       |                // http://gcc.gnu.org/bugzilla/show_bug.cgi?id=40856
  180|    619|                static_assert(std::numeric_limits<T>::is_specialized,
  181|    619|                    "std::numeric_limits are not specialized for integral type passed to boost::lexical_cast"
  182|    619|                );
  183|    619|#endif
  184|    619|            }
_ZN5boost6detail18lcast_ret_unsignedINSt3__111char_traitsIcEEjcE7convertEv:
  186|    619|            inline bool convert() {
  187|    619|                CharT const czero = lcast_char_constants<CharT>::zero;
  188|    619|                --m_end;
  189|    619|                m_value = static_cast<T>(0);
  190|       |
  191|    619|                if (m_begin > m_end || *m_end < czero || *m_end >= czero + 10)
  ------------------
  |  Branch (191:21): [True: 3, False: 616]
  |  Branch (191:40): [True: 23, False: 593]
  |  Branch (191:58): [True: 15, False: 578]
  ------------------
  192|     41|                    return false;
  193|    578|                m_value = static_cast<T>(*m_end - czero);
  194|    578|                --m_end;
  195|       |
  196|       |#ifdef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
  197|       |                return main_convert_loop();
  198|       |#else
  199|    578|                std::locale loc;
  200|    578|                if (loc == std::locale::classic()) {
  ------------------
  |  Branch (200:21): [True: 578, False: 0]
  ------------------
  201|    578|                    return main_convert_loop();
  202|    578|                }
  203|       |
  204|      0|                typedef std::numpunct<CharT> numpunct;
  205|      0|                numpunct const& np = BOOST_USE_FACET(numpunct, loc);
  206|      0|                std::string const& grouping = np.grouping();
  207|      0|                std::string::size_type const grouping_size = grouping.size();
  208|       |
  209|       |                /* According to Programming languages - C++
  210|       |                 * we MUST check for correct grouping
  211|       |                 */
  212|      0|                if (!grouping_size || grouping[0] <= 0) {
  ------------------
  |  Branch (212:21): [True: 0, False: 0]
  |  Branch (212:39): [True: 0, False: 0]
  ------------------
  213|      0|                    return main_convert_loop();
  214|      0|                }
  215|       |
  216|      0|                unsigned char current_grouping = 0;
  217|      0|                CharT const thousands_sep = np.thousands_sep();
  218|      0|                char remained = static_cast<char>(grouping[current_grouping] - 1);
  219|       |
  220|      0|                for (;m_end >= m_begin; --m_end)
  ------------------
  |  Branch (220:23): [True: 0, False: 0]
  ------------------
  221|      0|                {
  222|      0|                    if (remained) {
  ------------------
  |  Branch (222:25): [True: 0, False: 0]
  ------------------
  223|      0|                        if (!main_convert_iteration()) {
  ------------------
  |  Branch (223:29): [True: 0, False: 0]
  ------------------
  224|      0|                            return false;
  225|      0|                        }
  226|      0|                        --remained;
  227|      0|                    } else {
  228|      0|                        if ( !Traits::eq(*m_end, thousands_sep) ) //|| begin == end ) return false;
  ------------------
  |  Branch (228:30): [True: 0, False: 0]
  ------------------
  229|      0|                        {
  230|       |                            /*
  231|       |                             * According to Programming languages - C++
  232|       |                             * Digit grouping is checked. That is, the positions of discarded
  233|       |                             * separators is examined for consistency with
  234|       |                             * use_facet<numpunct<charT> >(loc ).grouping()
  235|       |                             *
  236|       |                             * BUT what if there is no separators at all and grouping()
  237|       |                             * is not empty? Well, we have no extraced separators, so we
  238|       |                             * won`t check them for consistency. This will allow us to
  239|       |                             * work with "C" locale from other locales
  240|       |                             */
  241|      0|                            return main_convert_loop();
  242|      0|                        } else {
  243|      0|                            if (m_begin == m_end) return false;
  ------------------
  |  Branch (243:33): [True: 0, False: 0]
  ------------------
  244|      0|                            if (current_grouping < grouping_size - 1) ++current_grouping;
  ------------------
  |  Branch (244:33): [True: 0, False: 0]
  ------------------
  245|      0|                            remained = grouping[current_grouping];
  246|      0|                        }
  247|      0|                    }
  248|      0|                } /*for*/
  249|       |
  250|      0|                return true;
  251|      0|#endif
  252|      0|            }
_ZN5boost6detail18lcast_ret_unsignedINSt3__111char_traitsIcEEjcE17main_convert_loopEv:
  285|    578|            bool main_convert_loop() noexcept {
  286|  2.95k|                for ( ; m_end >= m_begin; --m_end) {
  ------------------
  |  Branch (286:25): [True: 2.41k, False: 541]
  ------------------
  287|  2.41k|                    if (!main_convert_iteration()) {
  ------------------
  |  Branch (287:25): [True: 37, False: 2.37k]
  ------------------
  288|     37|                        return false;
  289|     37|                    }
  290|  2.41k|                }
  291|       |
  292|    541|                return true;
  293|    578|            }
_ZN5boost6detail18lcast_ret_unsignedINSt3__111char_traitsIcEEjcE22main_convert_iterationEv:
  260|  2.41k|            inline bool main_convert_iteration() noexcept {
  261|  2.41k|                CharT const czero = lcast_char_constants<CharT>::zero;
  262|  2.41k|                T const maxv = (std::numeric_limits<T>::max)();
  263|       |
  264|  2.41k|                m_multiplier_overflowed = m_multiplier_overflowed || (maxv/10 < m_multiplier);
  ------------------
  |  Branch (264:43): [True: 1.09k, False: 1.31k]
  |  Branch (264:70): [True: 25, False: 1.29k]
  ------------------
  265|  2.41k|                m_multiplier = static_cast<T>(m_multiplier * 10);
  266|       |
  267|  2.41k|                T const dig_value = static_cast<T>(*m_end - czero);
  268|  2.41k|                T const new_sub_value = static_cast<T>(m_multiplier * dig_value);
  269|       |
  270|       |                // We must correctly handle situations like `000000000000000000000000000001`.
  271|       |                // So we take care of overflow only if `dig_value` is not '0'.
  272|  2.41k|                if (*m_end < czero || *m_end >= czero + 10  // checking for correct digit
  ------------------
  |  Branch (272:21): [True: 22, False: 2.39k]
  |  Branch (272:39): [True: 9, False: 2.38k]
  ------------------
  273|  2.41k|                    || (dig_value && (                      // checking for overflow of ...
  ------------------
  |  Branch (273:25): [True: 991, False: 1.39k]
  ------------------
  274|    991|                        m_multiplier_overflowed                             // ... multiplier
  ------------------
  |  Branch (274:25): [True: 2, False: 989]
  ------------------
  275|    991|                        || static_cast<T>(maxv / dig_value) < m_multiplier  // ... subvalue
  ------------------
  |  Branch (275:28): [True: 1, False: 988]
  ------------------
  276|    991|                        || static_cast<T>(maxv - new_sub_value) < m_value   // ... whole expression
  ------------------
  |  Branch (276:28): [True: 3, False: 985]
  ------------------
  277|    991|                    ))
  278|  2.41k|                ) return false;
  279|       |
  280|  2.37k|                m_value = static_cast<T>(m_value + new_sub_value);
  281|       |
  282|  2.37k|                return true;
  283|  2.41k|            }

_ZN5boost10conversion6detail19try_lexical_convertIiNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEbRKT0_RT_:
   51|    641|        {
   52|    641|            static_assert(
   53|    641|                !boost::is_volatile<Source>::value,
   54|    641|                "Boost.LexicalCast does not support volatile input");
   55|       |
   56|    641|            typedef typename boost::detail::array_to_pointer_decay<Source>::type src;
   57|       |
   58|    641|            typedef boost::detail::is_arithmetic_and_not_xchars<Target, src >
   59|    641|                shall_we_copy_with_dynamic_check_t;
   60|       |
   61|    641|            typedef typename boost::conditional<
   62|    641|                 shall_we_copy_with_dynamic_check_t::value,
   63|    641|                 boost::detail::dynamic_num_converter_impl<Target, src >,
   64|    641|                 boost::detail::lexical_converter_impl<Target, src >
   65|    641|            >::type caster_type;
   66|       |
   67|    641|            return caster_type::try_convert(arg, result);
   68|    641|        }
_ZN5boost10conversion6detail19try_lexical_convertIfNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEbRKT0_RT_:
   51|    761|        {
   52|    761|            static_assert(
   53|    761|                !boost::is_volatile<Source>::value,
   54|    761|                "Boost.LexicalCast does not support volatile input");
   55|       |
   56|    761|            typedef typename boost::detail::array_to_pointer_decay<Source>::type src;
   57|       |
   58|    761|            typedef boost::detail::is_arithmetic_and_not_xchars<Target, src >
   59|    761|                shall_we_copy_with_dynamic_check_t;
   60|       |
   61|    761|            typedef typename boost::conditional<
   62|    761|                 shall_we_copy_with_dynamic_check_t::value,
   63|    761|                 boost::detail::dynamic_num_converter_impl<Target, src >,
   64|    761|                 boost::detail::lexical_converter_impl<Target, src >
   65|    761|            >::type caster_type;
   66|       |
   67|    761|            return caster_type::try_convert(arg, result);
   68|    761|        }
_ZN5boost10conversion6detail19try_lexical_convertIdNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEbRKT0_RT_:
   51|    230|        {
   52|    230|            static_assert(
   53|    230|                !boost::is_volatile<Source>::value,
   54|    230|                "Boost.LexicalCast does not support volatile input");
   55|       |
   56|    230|            typedef typename boost::detail::array_to_pointer_decay<Source>::type src;
   57|       |
   58|    230|            typedef boost::detail::is_arithmetic_and_not_xchars<Target, src >
   59|    230|                shall_we_copy_with_dynamic_check_t;
   60|       |
   61|    230|            typedef typename boost::conditional<
   62|    230|                 shall_we_copy_with_dynamic_check_t::value,
   63|    230|                 boost::detail::dynamic_num_converter_impl<Target, src >,
   64|    230|                 boost::detail::lexical_converter_impl<Target, src >
   65|    230|            >::type caster_type;
   66|       |
   67|    230|            return caster_type::try_convert(arg, result);
   68|    230|        }
_ZN5boost10conversion6detail19try_lexical_convertINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEbEEbRKT0_RT_:
   51|  21.1k|        {
   52|  21.1k|            static_assert(
   53|  21.1k|                !boost::is_volatile<Source>::value,
   54|  21.1k|                "Boost.LexicalCast does not support volatile input");
   55|       |
   56|  21.1k|            typedef typename boost::detail::array_to_pointer_decay<Source>::type src;
   57|       |
   58|  21.1k|            typedef boost::detail::is_arithmetic_and_not_xchars<Target, src >
   59|  21.1k|                shall_we_copy_with_dynamic_check_t;
   60|       |
   61|  21.1k|            typedef typename boost::conditional<
   62|  21.1k|                 shall_we_copy_with_dynamic_check_t::value,
   63|  21.1k|                 boost::detail::dynamic_num_converter_impl<Target, src >,
   64|  21.1k|                 boost::detail::lexical_converter_impl<Target, src >
   65|  21.1k|            >::type caster_type;
   66|       |
   67|  21.1k|            return caster_type::try_convert(arg, result);
   68|  21.1k|        }

_ZN5boost15program_options6detail26basic_config_file_iteratorIcE7getlineERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEE:
  168|  1.51M|    {
  169|  1.51M|        std::basic_string<charT> in;
  170|  1.51M|        if (std::getline(*is, in)) {
  ------------------
  |  Branch (170:13): [True: 1.51M, False: 1.93k]
  ------------------
  171|  1.51M|            s = to_internal(in);
  172|  1.51M|            return true;
  173|  1.51M|        } else {
  174|  1.93k|            return false;
  175|  1.93k|        }
  176|  1.51M|    }
_ZN5boost15program_options6detail26basic_config_file_iteratorIcEC2ERNSt3__113basic_istreamIcNS4_11char_traitsIcEEEERKNS4_3setINS4_12basic_stringIcS7_NS4_9allocatorIcEEEENS4_4lessISE_EENSC_ISE_EEEEb:
  155|  2.11k|    : common_config_file_iterator(allowed_options, allow_unregistered)
  156|  2.11k|    {
  157|  2.11k|        this->is.reset(&is, null_deleter());                 
  158|  2.11k|        get();
  159|  2.11k|    }
_ZNK5boost15program_options6detail12null_deleterclEPKv:
  146|  2.11k|        void operator()(void const *) const {}
_ZN5boost15program_options6detail26basic_config_file_iteratorIcEC2Ev:
  122|  1.98k|        {
  123|  1.98k|            found_eof();
  124|  1.98k|        }
_ZN5boost15program_options6detail27common_config_file_iteratorC2Ev:
   74|  1.98k|        common_config_file_iterator() { found_eof(); }

_ZN5boost15program_options20collect_unrecognizedIcEENSt3__16vectorINS2_12basic_stringIT_NS2_11char_traitsIS5_EENS2_9allocatorIS5_EEEENS8_ISA_EEEERKNS3_INS0_12basic_optionIS5_EENS8_ISE_EEEENS0_25collect_unrecognized_modeE:
  117|  1.15k|    {
  118|  1.15k|        std::vector< std::basic_string<charT> >  result;
  119|  1.40M|        for(unsigned i = 0; i < options.size(); ++i)
  ------------------
  |  Branch (119:29): [True: 1.40M, False: 1.15k]
  ------------------
  120|  1.40M|        {
  121|  1.40M|            if (options[i].unregistered ||
  ------------------
  |  Branch (121:17): [True: 1.40M, False: 1.48k]
  ------------------
  122|  1.40M|                (mode == include_positional && options[i].position_key != -1))
  ------------------
  |  Branch (122:18): [True: 0, False: 1.48k]
  |  Branch (122:48): [True: 0, False: 0]
  ------------------
  123|  1.40M|            {
  124|  1.40M|                copy(options[i].original_tokens.begin(),
  125|  1.40M|                     options[i].original_tokens.end(),
  126|  1.40M|                     back_inserter(result));
  127|  1.40M|            }
  128|  1.40M|        }
  129|  1.15k|        return result;
  130|  1.15k|    }

_ZN5boost15program_options5valueINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEPNS0_11typed_valueIT_cEEv:
  190|  8.46k|    {
  191|       |        // Explicit qualification is vc6 workaround.
  192|  8.46k|        return boost::program_options::value<T>(0);
  193|  8.46k|    }
_ZN5boost15program_options5valueINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEPNS0_11typed_valueIT_cEEPSA_:
  198|  8.46k|    {
  199|  8.46k|        typed_value<T>* r = new typed_value<T>(v);
  200|       |
  201|  8.46k|        return r;        
  202|  8.46k|    }
_ZNK5boost15program_options11typed_valueINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEcE6notifyERKNS_3anyE:
   39|    232|    {
   40|    232|        const T* value = boost::any_cast<T>(&value_store);
   41|    232|        if (m_store_to) {
  ------------------
  |  Branch (41:13): [True: 0, False: 232]
  ------------------
   42|      0|            *m_store_to = *value;
   43|      0|        }
   44|    232|        if (m_notifier) {
  ------------------
  |  Branch (44:13): [True: 0, False: 232]
  ------------------
   45|      0|            m_notifier(*value);
   46|      0|        }
   47|    232|    }
_ZNK5boost15program_options11typed_valueINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEcE6xparseERNS_3anyERKNS2_6vectorIS8_NS6_IS8_EEEE:
  177|    298|    {
  178|       |        // If no tokens were given, and the option accepts an implicit
  179|       |        // value, then assign the implicit value as the stored value;
  180|       |        // otherwise, validate the user-provided token(s).
  181|    298|        if (new_tokens.empty() && !m_implicit_value.empty())
  ------------------
  |  Branch (181:13): [True: 0, False: 298]
  |  Branch (181:35): [True: 0, False: 0]
  ------------------
  182|      0|            value_store = m_implicit_value;
  183|    298|        else
  184|    298|            validate(value_store, new_tokens, (T*)0, 0);
  185|    298|    }
_ZN5boost15program_options5valueIiEEPNS0_11typed_valueIT_cEEv:
  190|  10.5k|    {
  191|       |        // Explicit qualification is vc6 workaround.
  192|  10.5k|        return boost::program_options::value<T>(0);
  193|  10.5k|    }
_ZN5boost15program_options5valueIiEEPNS0_11typed_valueIT_cEEPS3_:
  198|  10.5k|    {
  199|  10.5k|        typed_value<T>* r = new typed_value<T>(v);
  200|       |
  201|  10.5k|        return r;        
  202|  10.5k|    }
_ZNK5boost15program_options11typed_valueIicE6notifyERKNS_3anyE:
   39|    414|    {
   40|    414|        const T* value = boost::any_cast<T>(&value_store);
   41|    414|        if (m_store_to) {
  ------------------
  |  Branch (41:13): [True: 0, False: 414]
  ------------------
   42|      0|            *m_store_to = *value;
   43|      0|        }
   44|    414|        if (m_notifier) {
  ------------------
  |  Branch (44:13): [True: 0, False: 414]
  ------------------
   45|      0|            m_notifier(*value);
   46|      0|        }
   47|    414|    }
_ZNK5boost15program_options11typed_valueIicE6xparseERNS_3anyERKNSt3__16vectorINS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEENSA_ISC_EEEE:
  177|    657|    {
  178|       |        // If no tokens were given, and the option accepts an implicit
  179|       |        // value, then assign the implicit value as the stored value;
  180|       |        // otherwise, validate the user-provided token(s).
  181|    657|        if (new_tokens.empty() && !m_implicit_value.empty())
  ------------------
  |  Branch (181:13): [True: 0, False: 657]
  |  Branch (181:35): [True: 0, False: 0]
  ------------------
  182|      0|            value_store = m_implicit_value;
  183|    657|        else
  184|    657|            validate(value_store, new_tokens, (T*)0, 0);
  185|    657|    }
_ZN5boost15program_options8validateIicEEvRNS_3anyERKNSt3__16vectorINS4_12basic_stringIT0_NS4_11char_traitsIS7_EENS4_9allocatorIS7_EEEENSA_ISC_EEEEPT_l:
   88|    657|    {
   89|    657|        validators::check_first_occurrence(v);
   90|    657|        std::basic_string<charT> s(validators::get_single_string(xs));
   91|    657|        try {
   92|    657|            v = any(lexical_cast<T>(s));
   93|    657|        }
   94|    657|        catch(const bad_lexical_cast&) {
   95|    135|            boost::throw_exception(invalid_option_value(s));
   96|    135|        }
   97|    657|    }
_ZN5boost15program_options10validators17get_single_stringIcEERKNSt3__112basic_stringIT_NS3_11char_traitsIS5_EENS3_9allocatorIS5_EEEERKNS3_6vectorISA_NS8_ISA_EEEEb:
   59|  2.62k|        {
   60|  2.62k|            static std::basic_string<charT> empty;
   61|  2.62k|            if (v.size() > 1)
  ------------------
  |  Branch (61:17): [True: 0, False: 2.62k]
  ------------------
   62|      0|                boost::throw_exception(validation_error(validation_error::multiple_values_not_allowed));
   63|  2.62k|            else if (v.size() == 1)
  ------------------
  |  Branch (63:22): [True: 2.62k, False: 0]
  ------------------
   64|  2.62k|                return v.front();
   65|      0|            else if (!allow_empty)
  ------------------
  |  Branch (65:22): [True: 0, False: 0]
  ------------------
   66|      0|                boost::throw_exception(validation_error(validation_error::at_least_one_value_required));
   67|      0|            return empty;
   68|  2.62k|        }
_ZN5boost15program_options5valueIfEEPNS0_11typed_valueIT_cEEv:
  190|  23.2k|    {
  191|       |        // Explicit qualification is vc6 workaround.
  192|  23.2k|        return boost::program_options::value<T>(0);
  193|  23.2k|    }
_ZN5boost15program_options5valueIfEEPNS0_11typed_valueIT_cEEPS3_:
  198|  23.2k|    {
  199|  23.2k|        typed_value<T>* r = new typed_value<T>(v);
  200|       |
  201|  23.2k|        return r;        
  202|  23.2k|    }
_ZNK5boost15program_options11typed_valueIfcE6notifyERKNS_3anyE:
   39|    430|    {
   40|    430|        const T* value = boost::any_cast<T>(&value_store);
   41|    430|        if (m_store_to) {
  ------------------
  |  Branch (41:13): [True: 0, False: 430]
  ------------------
   42|      0|            *m_store_to = *value;
   43|      0|        }
   44|    430|        if (m_notifier) {
  ------------------
  |  Branch (44:13): [True: 0, False: 430]
  ------------------
   45|      0|            m_notifier(*value);
   46|      0|        }
   47|    430|    }
_ZNK5boost15program_options11typed_valueIfcE6xparseERNS_3anyERKNSt3__16vectorINS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEENSA_ISC_EEEE:
  177|    779|    {
  178|       |        // If no tokens were given, and the option accepts an implicit
  179|       |        // value, then assign the implicit value as the stored value;
  180|       |        // otherwise, validate the user-provided token(s).
  181|    779|        if (new_tokens.empty() && !m_implicit_value.empty())
  ------------------
  |  Branch (181:13): [True: 0, False: 779]
  |  Branch (181:35): [True: 0, False: 0]
  ------------------
  182|      0|            value_store = m_implicit_value;
  183|    779|        else
  184|    779|            validate(value_store, new_tokens, (T*)0, 0);
  185|    779|    }
_ZN5boost15program_options8validateIfcEEvRNS_3anyERKNSt3__16vectorINS4_12basic_stringIT0_NS4_11char_traitsIS7_EENS4_9allocatorIS7_EEEENSA_ISC_EEEEPT_l:
   88|    779|    {
   89|    779|        validators::check_first_occurrence(v);
   90|    779|        std::basic_string<charT> s(validators::get_single_string(xs));
   91|    779|        try {
   92|    779|            v = any(lexical_cast<T>(s));
   93|    779|        }
   94|    779|        catch(const bad_lexical_cast&) {
   95|    190|            boost::throw_exception(invalid_option_value(s));
   96|    190|        }
   97|    779|    }
_ZN5boost15program_options5valueIdEEPNS0_11typed_valueIT_cEEv:
  190|  2.11k|    {
  191|       |        // Explicit qualification is vc6 workaround.
  192|  2.11k|        return boost::program_options::value<T>(0);
  193|  2.11k|    }
_ZN5boost15program_options5valueIdEEPNS0_11typed_valueIT_cEEPS3_:
  198|  2.11k|    {
  199|  2.11k|        typed_value<T>* r = new typed_value<T>(v);
  200|       |
  201|  2.11k|        return r;        
  202|  2.11k|    }
_ZNK5boost15program_options11typed_valueIdcE6notifyERKNS_3anyE:
   39|     60|    {
   40|     60|        const T* value = boost::any_cast<T>(&value_store);
   41|     60|        if (m_store_to) {
  ------------------
  |  Branch (41:13): [True: 0, False: 60]
  ------------------
   42|      0|            *m_store_to = *value;
   43|      0|        }
   44|     60|        if (m_notifier) {
  ------------------
  |  Branch (44:13): [True: 0, False: 60]
  ------------------
   45|      0|            m_notifier(*value);
   46|      0|        }
   47|     60|    }
_ZNK5boost15program_options11typed_valueIdcE6xparseERNS_3anyERKNSt3__16vectorINS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEENSA_ISC_EEEE:
  177|    231|    {
  178|       |        // If no tokens were given, and the option accepts an implicit
  179|       |        // value, then assign the implicit value as the stored value;
  180|       |        // otherwise, validate the user-provided token(s).
  181|    231|        if (new_tokens.empty() && !m_implicit_value.empty())
  ------------------
  |  Branch (181:13): [True: 0, False: 231]
  |  Branch (181:35): [True: 0, False: 0]
  ------------------
  182|      0|            value_store = m_implicit_value;
  183|    231|        else
  184|    231|            validate(value_store, new_tokens, (T*)0, 0);
  185|    231|    }
_ZN5boost15program_options8validateIdcEEvRNS_3anyERKNSt3__16vectorINS4_12basic_stringIT0_NS4_11char_traitsIS7_EENS4_9allocatorIS7_EEEENSA_ISC_EEEEPT_l:
   88|    231|    {
   89|    231|        validators::check_first_occurrence(v);
   90|    231|        std::basic_string<charT> s(validators::get_single_string(xs));
   91|    231|        try {
   92|    231|            v = any(lexical_cast<T>(s));
   93|    231|        }
   94|    231|        catch(const bad_lexical_cast&) {
   95|    158|            boost::throw_exception(invalid_option_value(s));
   96|    158|        }
   97|    231|    }
_ZNK5boost15program_options11typed_valueIbcE6notifyERKNS_3anyE:
   39|  11.5k|    {
   40|  11.5k|        const T* value = boost::any_cast<T>(&value_store);
   41|  11.5k|        if (m_store_to) {
  ------------------
  |  Branch (41:13): [True: 0, False: 11.5k]
  ------------------
   42|      0|            *m_store_to = *value;
   43|      0|        }
   44|  11.5k|        if (m_notifier) {
  ------------------
  |  Branch (44:13): [True: 0, False: 11.5k]
  ------------------
   45|      0|            m_notifier(*value);
   46|      0|        }
   47|  11.5k|    }
_ZNK5boost15program_options11typed_valueIbcE6xparseERNS_3anyERKNSt3__16vectorINS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEENSA_ISC_EEEE:
  177|    715|    {
  178|       |        // If no tokens were given, and the option accepts an implicit
  179|       |        // value, then assign the implicit value as the stored value;
  180|       |        // otherwise, validate the user-provided token(s).
  181|    715|        if (new_tokens.empty() && !m_implicit_value.empty())
  ------------------
  |  Branch (181:13): [True: 0, False: 715]
  |  Branch (181:35): [True: 0, False: 0]
  ------------------
  182|      0|            value_store = m_implicit_value;
  183|    715|        else
  184|    715|            validate(value_store, new_tokens, (T*)0, 0);
  185|    715|    }

_ZN5boost12eof_iteratorINS_15program_options6detail27common_config_file_iteratorENS1_12basic_optionIcEEEC2Ev:
   50|  4.10k|        : m_at_eof(false)
   51|  4.10k|        {}
_ZN5boost12eof_iteratorINS_15program_options6detail27common_config_file_iteratorENS1_12basic_optionIcEEE9found_eofEv:
   65|  5.90k|        {
   66|  5.90k|            m_at_eof = true;
   67|  5.90k|        }
_ZNK5boost12eof_iteratorINS_15program_options6detail27common_config_file_iteratorENS1_12basic_optionIcEEE5equalERKS6_:
   83|  1.44M|        {
   84|  1.44M|            if (m_at_eof && other.m_at_eof)
  ------------------
  |  Branch (84:17): [True: 1.93k, False: 1.43M]
  |  Branch (84:29): [True: 1.93k, False: 0]
  ------------------
   85|  1.93k|                return true;
   86|  1.43M|            else
   87|  1.43M|                return false;
   88|  1.44M|        }
_ZNK5boost12eof_iteratorINS_15program_options6detail27common_config_file_iteratorENS1_12basic_optionIcEEE11dereferenceEv:
   91|  1.43M|        {
   92|  1.43M|            return m_value;
   93|  1.43M|        }
_ZN5boost12eof_iteratorINS_15program_options6detail27common_config_file_iteratorENS1_12basic_optionIcEEE9incrementEv:
   78|  1.43M|        {
   79|  1.43M|            static_cast<Derived&>(*this).get();
   80|  1.43M|        }
_ZN5boost12eof_iteratorINS_15program_options6detail27common_config_file_iteratorENS1_12basic_optionIcEEE5valueEv:
   58|  10.0M|        {
   59|  10.0M|            return m_value;
   60|  10.0M|        }

_ZN5boost15program_options22error_with_option_name15set_option_nameERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
  175|    779|        {           set_substitute("option", option_name);}
_ZN5boost15program_options22error_with_option_name14set_substituteERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEESA_:
  148|  2.28k|        {           m_substitutions[parameter_name] = value;    }
_ZN5boost15program_options16validation_errorC2ENS1_6kind_tERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEESB_i:
  378|    727|        error_with_option_name(get_template(kind), option_name, original_token, option_style),
  379|    727|        m_kind(kind)
  380|    727|        {
  381|    727|        }
_ZN5boost15program_options5errorC2ERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
   40|    960|        error(const std::string& xwhat) : std::logic_error(xwhat) {}
_ZN5boost15program_options22error_with_option_name22set_substitute_defaultERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEESA_SA_:
  155|  2.88k|        {           
  156|  2.88k|            m_substitution_defaults[parameter_name] = std::make_pair(from, to); 
  157|  2.88k|        }
_ZN5boost15program_options22error_with_option_name11add_contextERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEESA_i:
  164|    779|        {
  165|    779|            set_option_name(option_name);
  166|    779|            set_original_token(original_token);
  167|    779|            set_prefix(option_style);
  168|    779|        }
_ZN5boost15program_options22error_with_option_name10set_prefixEi:
  171|    779|        {           m_option_style = option_style;}
_ZN5boost15program_options22error_with_option_name18set_original_tokenERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
  181|    779|        {           set_substitute("original_token", original_token);}
_ZN5boost15program_options20multiple_occurrencesC2Ev:
  221|     52|         : error_with_option_name("option '%canonical_option%' cannot be specified more than once"){}
_ZN5boost15program_options14invalid_syntaxC2ENS1_6kind_tERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEESB_i:
  318|    181|            error_with_option_name(get_template(kind), option_name, original_token, option_style),
  319|    181|            m_kind(kind)
  320|    181|        {
  321|    181|        }
_ZN5boost15program_options26invalid_config_file_syntaxC2ERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS0_14invalid_syntax6kind_tE:
  338|    181|            invalid_syntax(kind)
  339|    181|        {
  340|    181|            m_substitutions["invalid_line"] = invalid_line;
  341|    181|        }

_ZN5boost15program_options12basic_optionIcEC2Ev:
   27|  4.10k|        : position_key(-1)
   28|  4.10k|        , unregistered(false) 
   29|  4.10k|        , case_insensitive(false)
   30|  4.10k|        {}

_ZN5boost15program_options20basic_parsed_optionsIcEC2EPKNS0_19options_descriptionEi:
   40|  2.11k|        : description(xdescription), m_options_prefix(options_prefix) {}

_ZN5boost15program_options11typed_valueINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEcEC2EPS8_:
  190|  8.46k|        : m_store_to(store_to), m_composing(false),
  191|  8.46k|          m_implicit(false), m_multitoken(false),
  192|  8.46k|          m_zero_tokens(false), m_required(false)
  193|  8.46k|        {} 
_ZN5boost15program_options14value_semanticD2Ev:
   71|  65.5k|        virtual ~value_semantic() {}
_ZN5boost15program_options16typed_value_baseD2Ev:
  174|  65.5k|        virtual ~typed_value_base() {}
_ZNK5boost15program_options11typed_valueINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEcE12is_composingEv:
  304|    294|        bool is_composing() const { return m_composing; }
_ZNK5boost15program_options11typed_valueINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEcE11is_requiredEv:
  325|  4.62k|        bool is_required() const { return m_required; }
_ZNK5boost15program_options11typed_valueINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEcE13apply_defaultERNS_3anyE:
  338|  4.38k|        {
  339|  4.38k|            if (m_default_value.empty()) {
  ------------------
  |  Branch (339:17): [True: 4.38k, False: 0]
  ------------------
  340|  4.38k|                return false;
  341|  4.38k|            } else {
  342|      0|                value_store = m_default_value;
  343|      0|                return true;
  344|      0|            }
  345|  4.38k|        }
_ZN5boost15program_options11typed_valueIicEC2EPi:
  190|  10.5k|        : m_store_to(store_to), m_composing(false),
  191|  10.5k|          m_implicit(false), m_multitoken(false),
  192|  10.5k|          m_zero_tokens(false), m_required(false)
  193|  10.5k|        {} 
_ZNK5boost15program_options11typed_valueIicE12is_composingEv:
  304|    506|        bool is_composing() const { return m_composing; }
_ZNK5boost15program_options11typed_valueIicE11is_requiredEv:
  325|  5.77k|        bool is_required() const { return m_required; }
_ZNK5boost15program_options11typed_valueIicE13apply_defaultERNS_3anyE:
  338|  5.36k|        {
  339|  5.36k|            if (m_default_value.empty()) {
  ------------------
  |  Branch (339:17): [True: 5.36k, False: 0]
  ------------------
  340|  5.36k|                return false;
  341|  5.36k|            } else {
  342|      0|                value_store = m_default_value;
  343|      0|                return true;
  344|      0|            }
  345|  5.36k|        }
_ZN5boost15program_options11typed_valueIfcEC2EPf:
  190|  23.2k|        : m_store_to(store_to), m_composing(false),
  191|  23.2k|          m_implicit(false), m_multitoken(false),
  192|  23.2k|          m_zero_tokens(false), m_required(false)
  193|  23.2k|        {} 
_ZNK5boost15program_options11typed_valueIfcE12is_composingEv:
  304|    571|        bool is_composing() const { return m_composing; }
_ZNK5boost15program_options11typed_valueIfcE11is_requiredEv:
  325|  12.7k|        bool is_required() const { return m_required; }
_ZNK5boost15program_options11typed_valueIfcE13apply_defaultERNS_3anyE:
  338|  12.2k|        {
  339|  12.2k|            if (m_default_value.empty()) {
  ------------------
  |  Branch (339:17): [True: 12.2k, False: 0]
  ------------------
  340|  12.2k|                return false;
  341|  12.2k|            } else {
  342|      0|                value_store = m_default_value;
  343|      0|                return true;
  344|      0|            }
  345|  12.2k|        }
_ZN5boost15program_options11typed_valueIdcEC2EPd:
  190|  2.11k|        : m_store_to(store_to), m_composing(false),
  191|  2.11k|          m_implicit(false), m_multitoken(false),
  192|  2.11k|          m_zero_tokens(false), m_required(false)
  193|  2.11k|        {} 
_ZNK5boost15program_options11typed_valueIdcE12is_composingEv:
  304|     72|        bool is_composing() const { return m_composing; }
_ZNK5boost15program_options11typed_valueIdcE11is_requiredEv:
  325|  1.15k|        bool is_required() const { return m_required; }
_ZNK5boost15program_options11typed_valueIdcE13apply_defaultERNS_3anyE:
  338|  1.09k|        {
  339|  1.09k|            if (m_default_value.empty()) {
  ------------------
  |  Branch (339:17): [True: 1.09k, False: 0]
  ------------------
  340|  1.09k|                return false;
  341|  1.09k|            } else {
  342|      0|                value_store = m_default_value;
  343|      0|                return true;
  344|      0|            }
  345|  1.09k|        }
_ZN5boost15program_options11typed_valueIbcEC2EPb:
  190|  21.1k|        : m_store_to(store_to), m_composing(false),
  191|  21.1k|          m_implicit(false), m_multitoken(false),
  192|  21.1k|          m_zero_tokens(false), m_required(false)
  193|  21.1k|        {} 
_ZNK5boost15program_options11typed_valueIbcE12is_composingEv:
  304|    458|        bool is_composing() const { return m_composing; }
_ZNK5boost15program_options11typed_valueIbcE11is_requiredEv:
  325|  11.5k|        bool is_required() const { return m_required; }
_ZNK5boost15program_options11typed_valueIbcE13apply_defaultERNS_3anyE:
  338|  11.2k|        {
  339|  11.2k|            if (m_default_value.empty()) {
  ------------------
  |  Branch (339:17): [True: 0, False: 11.2k]
  ------------------
  340|      0|                return false;
  341|  11.2k|            } else {
  342|  11.2k|                value_store = m_default_value;
  343|  11.2k|                return true;
  344|  11.2k|            }
  345|  11.2k|        }
_ZN5boost15program_options11typed_valueIbcE13default_valueERKb:
  200|  21.1k|        {
  201|  21.1k|            m_default_value = boost::any(v);
  202|  21.1k|            m_default_value_as_text = boost::lexical_cast<std::string>(v);
  203|  21.1k|            return this;
  204|  21.1k|        }
_ZN5boost15program_options11typed_valueIbcE11zero_tokensEv:
  288|  21.1k|        {
  289|  21.1k|            m_zero_tokens = true;
  290|  21.1k|            return this;
  291|  21.1k|        }

_ZN5boost15program_options22abstract_variables_mapD2Ev:
  111|  2.11k|        virtual ~abstract_variables_map() {}
_ZN5boost15program_options14variable_valueC2Ev:
   60|  13.8k|        variable_value() : m_defaulted(false) {}
_ZN5boost15program_options14variable_valueC2ERKNS_3anyEb:
   62|  11.2k|        : v(xv), m_defaulted(xdefaulted)
   63|  11.2k|        {}
_ZNK5boost15program_options14variable_value9defaultedEv:
  196|  2.68k|    {
  197|  2.68k|        return m_defaulted;
  198|  2.68k|    }
_ZN5boost15program_options14variable_value5valueEv:
  210|  15.3k|    {
  211|  15.3k|        return v;
  212|  15.3k|    }

_ZN5boost6detail12shared_countD2Ev:
  392|   660k|    {
  393|   660k|        if( pi_ != 0 ) pi_->release();
  ------------------
  |  Branch (393:13): [True: 360k, False: 300k]
  ------------------
  394|       |#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
  395|       |        id_ = 0;
  396|       |#endif
  397|   660k|    }
_ZN5boost6detail12shared_countC2Ev:
  123|   162k|    constexpr shared_count() noexcept: pi_(0)
  124|       |#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
  125|       |        , id_(shared_count_id)
  126|       |#endif
  127|   162k|    {
  128|   162k|    }
_ZN5boost6detail12shared_countC2ERKS1_:
  399|   231k|    shared_count(shared_count const & r) noexcept: pi_(r.pi_)
  400|       |#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
  401|       |        , id_(shared_count_id)
  402|       |#endif
  403|   231k|    {
  404|   231k|        if( pi_ != 0 ) pi_->add_ref_copy();
  ------------------
  |  Branch (404:13): [True: 227k, False: 3.97k]
  ------------------
  405|   231k|    }
_ZN5boost6detail12shared_countC2EOS1_:
  407|   133k|    shared_count(shared_count && r) noexcept: pi_(r.pi_)
  408|       |#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
  409|       |        , id_(shared_count_id)
  410|       |#endif
  411|   133k|    {
  412|   133k|        r.pi_ = 0;
  413|   133k|    }
_ZN5boost6detail12shared_count4swapERS1_:
  433|   160k|    {
  434|   160k|        sp_counted_base * tmp = r.pi_;
  435|   160k|        r.pi_ = pi_;
  436|   160k|        pi_ = tmp;
  437|   160k|    }
_ZN5boost6detail12shared_countC2IKNS_15program_options14value_semanticEEEPT_:
  137|  65.5k|    template<class Y> explicit shared_count( Y * p ): pi_( 0 )
  138|       |#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
  139|       |        , id_(shared_count_id)
  140|       |#endif
  141|  65.5k|    {
  142|  65.5k|#ifndef BOOST_NO_EXCEPTIONS
  143|       |
  144|  65.5k|        try
  145|  65.5k|        {
  146|  65.5k|            pi_ = new sp_counted_impl_p<Y>( p );
  147|  65.5k|        }
  148|  65.5k|        catch(...)
  149|  65.5k|        {
  150|      0|            boost::checked_delete( p );
  151|      0|            throw;
  152|      0|        }
  153|       |
  154|       |#else
  155|       |
  156|       |        pi_ = new sp_counted_impl_p<Y>( p );
  157|       |
  158|       |        if( pi_ == 0 )
  159|       |        {
  160|       |            boost::checked_delete( p );
  161|       |            boost::throw_exception( std::bad_alloc() );
  162|       |        }
  163|       |
  164|       |#endif
  165|  65.5k|    }
_ZN5boost6detail12shared_countC2INS_15program_options18option_descriptionEEEPT_:
  137|  65.5k|    template<class Y> explicit shared_count( Y * p ): pi_( 0 )
  138|       |#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
  139|       |        , id_(shared_count_id)
  140|       |#endif
  141|  65.5k|    {
  142|  65.5k|#ifndef BOOST_NO_EXCEPTIONS
  143|       |
  144|  65.5k|        try
  145|  65.5k|        {
  146|  65.5k|            pi_ = new sp_counted_impl_p<Y>( p );
  147|  65.5k|        }
  148|  65.5k|        catch(...)
  149|  65.5k|        {
  150|      0|            boost::checked_delete( p );
  151|      0|            throw;
  152|      0|        }
  153|       |
  154|       |#else
  155|       |
  156|       |        pi_ = new sp_counted_impl_p<Y>( p );
  157|       |
  158|       |        if( pi_ == 0 )
  159|       |        {
  160|       |            boost::checked_delete( p );
  161|       |            boost::throw_exception( std::bad_alloc() );
  162|       |        }
  163|       |
  164|       |#endif
  165|  65.5k|    }
_ZN5boost6detail12shared_countC2IPNSt3__113basic_istreamIcNS3_11char_traitsIcEEEENS_15program_options6detail12null_deleterEEET_T0_:
  167|  2.11k|    template<class P, class D> shared_count( P p, D d ): pi_(0)
  168|       |#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
  169|       |        , id_(shared_count_id)
  170|       |#endif
  171|  2.11k|    {
  172|  2.11k|#ifndef BOOST_NO_EXCEPTIONS
  173|       |
  174|  2.11k|        try
  175|  2.11k|        {
  176|  2.11k|            pi_ = new sp_counted_impl_pd<P, D>(p, d);
  177|  2.11k|        }
  178|  2.11k|        catch(...)
  179|  2.11k|        {
  180|      0|            d(p); // delete p
  181|      0|            throw;
  182|      0|        }
  183|       |
  184|       |#else
  185|       |
  186|       |        pi_ = new sp_counted_impl_pd<P, D>(p, d);
  187|       |
  188|       |        if(pi_ == 0)
  189|       |        {
  190|       |            d(p); // delete p
  191|       |            boost::throw_exception(std::bad_alloc());
  192|       |        }
  193|       |
  194|       |#endif
  195|  2.11k|    }

_ZN5boost6detail15sp_counted_base7releaseEv:
  117|   360k|    {
  118|   360k|        if( atomic_decrement( &use_count_ ) == 1 )
  ------------------
  |  Branch (118:13): [True: 133k, False: 227k]
  ------------------
  119|   133k|        {
  120|   133k|            dispose();
  121|   133k|            weak_release();
  122|   133k|        }
  123|   360k|    }
_ZN5boost6detail16atomic_decrementEPj:
   39|   494k|{
   40|   494k|    return __atomic_fetch_sub( pw, 1, __ATOMIC_ACQ_REL );
   41|   494k|}
_ZN5boost6detail15sp_counted_base12weak_releaseEv:
  131|   133k|    {
  132|   133k|        if( atomic_decrement( &weak_count_ ) == 1 )
  ------------------
  |  Branch (132:13): [True: 133k, False: 0]
  ------------------
  133|   133k|        {
  134|   133k|            destroy();
  135|   133k|        }
  136|   133k|    }
_ZN5boost6detail15sp_counted_baseC2Ev:
   82|   133k|    sp_counted_base(): use_count_( 1 ), weak_count_( 1 )
   83|   133k|    {
   84|   133k|    }
_ZN5boost6detail15sp_counted_baseD2Ev:
   87|   133k|    {
   88|   133k|    }
_ZN5boost6detail15sp_counted_base7destroyEv:
   98|   133k|    {
   99|   133k|        delete this;
  100|   133k|    }
_ZN5boost6detail15sp_counted_base12add_ref_copyEv:
  107|   227k|    {
  108|   227k|        atomic_increment( &use_count_ );
  109|   227k|    }
_ZN5boost6detail16atomic_incrementEPj:
   34|   227k|{
   35|   227k|    __atomic_fetch_add( pw, 1, __ATOMIC_RELAXED );
   36|   227k|}

_ZN5boost6detail17sp_counted_impl_pIKNS_15program_options14value_semanticEEC2EPS4_:
   77|  65.5k|    explicit sp_counted_impl_p( X * px ): px_( px )
   78|  65.5k|    {
   79|       |#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
   80|       |        boost::sp_scalar_constructor_hook( px, sizeof(X), this );
   81|       |#endif
   82|  65.5k|    }
_ZN5boost6detail17sp_counted_impl_pIKNS_15program_options14value_semanticEE7disposeEv:
   85|  65.5k|    {
   86|       |#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
   87|       |        boost::sp_scalar_destructor_hook( px_, sizeof(X), this );
   88|       |#endif
   89|  65.5k|        boost::checked_delete( px_ );
   90|  65.5k|    }
_ZN5boost6detail17sp_counted_impl_pINS_15program_options18option_descriptionEEC2EPS3_:
   77|  65.5k|    explicit sp_counted_impl_p( X * px ): px_( px )
   78|  65.5k|    {
   79|       |#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
   80|       |        boost::sp_scalar_constructor_hook( px, sizeof(X), this );
   81|       |#endif
   82|  65.5k|    }
_ZN5boost6detail17sp_counted_impl_pINS_15program_options18option_descriptionEE7disposeEv:
   85|  65.5k|    {
   86|       |#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
   87|       |        boost::sp_scalar_destructor_hook( px_, sizeof(X), this );
   88|       |#endif
   89|  65.5k|        boost::checked_delete( px_ );
   90|  65.5k|    }
_ZN5boost6detail18sp_counted_impl_pdIPNSt3__113basic_istreamIcNS2_11char_traitsIcEEEENS_15program_options6detail12null_deleterEEC2ES7_RSA_:
  152|  2.11k|    sp_counted_impl_pd( P p, D & d ): ptr( p ), del( static_cast< D&& >( d ) )
  153|  2.11k|    {
  154|  2.11k|    }
_ZN5boost6detail18sp_counted_impl_pdIPNSt3__113basic_istreamIcNS2_11char_traitsIcEEEENS_15program_options6detail12null_deleterEE7disposeEv:
  161|  2.11k|    {
  162|  2.11k|        del( ptr );
  163|  2.11k|    }

_ZN5boost6detail26sp_enable_shared_from_thisEz:
  189|   133k|{
  190|   133k|}
_ZN5boost10shared_ptrIKNS_15program_options14value_semanticEEC2Ev:
  264|  25.0k|    constexpr shared_ptr() noexcept : px( 0 ), pn()
  265|  25.0k|    {
  266|  25.0k|    }
_ZN5boost10shared_ptrINS_15program_options18option_descriptionEEC2Ev:
  264|  2.68k|    constexpr shared_ptr() noexcept : px( 0 ), pn()
  265|  2.68k|    {
  266|  2.68k|    }
_ZN5boost10shared_ptrIKNS_15program_options14value_semanticEEC2IS3_EEPT_:
  281|  65.5k|    explicit shared_ptr( Y * p ): px( p ), pn() // Y must be complete
  282|  65.5k|    {
  283|  65.5k|        boost::detail::sp_pointer_construct( this, p, pn );
  284|  65.5k|    }
_ZN5boost6detail20sp_pointer_constructIKNS_15program_options14value_semanticES4_EEvPNS_10shared_ptrIT_EEPT0_RNS0_12shared_countE:
  204|  65.5k|{
  205|  65.5k|    boost::detail::shared_count( p ).swap( pn );
  206|  65.5k|    boost::detail::sp_enable_shared_from_this( ppx, p, p );
  207|  65.5k|}
_ZN5boost10shared_ptrIKNS_15program_options14value_semanticEEC2ERKS4_:
  315|  87.8k|    shared_ptr( shared_ptr const & r ) noexcept : px( r.px ), pn( r.pn )
  316|  87.8k|    {
  317|  87.8k|    }
_ZNK5boost10shared_ptrIKNS_15program_options14value_semanticEEptEv:
  549|  87.3k|    {
  550|  87.3k|        BOOST_ASSERT( px != 0 );
  ------------------
  |  |   66|  87.3k|# define BOOST_ASSERT(expr) assert(expr)
  ------------------
  551|  87.3k|        return px;
  552|  87.3k|    }
_ZN5boost10shared_ptrINS_15program_options18option_descriptionEEC2IS2_EEPT_:
  281|  65.5k|    explicit shared_ptr( Y * p ): px( p ), pn() // Y must be complete
  282|  65.5k|    {
  283|  65.5k|        boost::detail::sp_pointer_construct( this, p, pn );
  284|  65.5k|    }
_ZN5boost6detail20sp_pointer_constructINS_15program_options18option_descriptionES3_EEvPNS_10shared_ptrIT_EEPT0_RNS0_12shared_countE:
  204|  65.5k|{
  205|  65.5k|    boost::detail::shared_count( p ).swap( pn );
  206|  65.5k|    boost::detail::sp_enable_shared_from_this( ppx, p, p );
  207|  65.5k|}
_ZN5boost10shared_ptrINS_15program_options18option_descriptionEEC2ERKS3_:
  315|   133k|    shared_ptr( shared_ptr const & r ) noexcept : px( r.px ), pn( r.pn )
  316|   133k|    {
  317|   133k|    }
_ZN5boost10shared_ptrINS_15program_options18option_descriptionEEC2EOS3_:
  471|  65.5k|    shared_ptr( shared_ptr && r ) noexcept : px( r.px ), pn( static_cast< boost::detail::shared_count && >( r.pn ) )
  472|  65.5k|    {
  473|  65.5k|        r.px = 0;
  474|  65.5k|    }
_ZNK5boost10shared_ptrINS_15program_options18option_descriptionEEptEv:
  549|  85.7k|    {
  550|  85.7k|        BOOST_ASSERT( px != 0 );
  ------------------
  |  |   66|  85.7k|# define BOOST_ASSERT(expr) assert(expr)
  ------------------
  551|  85.7k|        return px;
  552|  85.7k|    }
_ZN5boost10shared_ptrINS_15program_options18option_descriptionEEaSERKS3_:
  408|  2.68k|    {
  409|  2.68k|        this_type(r).swap(*this);
  410|  2.68k|        return *this;
  411|  2.68k|    }
_ZN5boost10shared_ptrINS_15program_options18option_descriptionEE4swapERS3_:
  583|  2.68k|    {
  584|  2.68k|        std::swap(px, other.px);
  585|  2.68k|        pn.swap(other.pn);
  586|  2.68k|    }
_ZNK5boost10shared_ptrINS_15program_options18option_descriptionEE3getEv:
  563|  2.68k|    {
  564|  2.68k|        return px;
  565|  2.68k|    }
_ZNK5boost10shared_ptrINS_15program_options18option_descriptionEEdeEv:
  543|   101k|    {
  544|   101k|        BOOST_ASSERT( px != 0 );
  ------------------
  |  |   66|   101k|# define BOOST_ASSERT(expr) assert(expr)
  ------------------
  545|   101k|        return *px;
  546|   101k|    }
_ZNK5boost10shared_ptrINSt3__113basic_istreamIcNS1_11char_traitsIcEEEEEdeEv:
  543|  1.51M|    {
  544|  1.51M|        BOOST_ASSERT( px != 0 );
  ------------------
  |  |   66|  1.51M|# define BOOST_ASSERT(expr) assert(expr)
  ------------------
  545|  1.51M|        return *px;
  546|  1.51M|    }
_ZN5boost10shared_ptrINSt3__113basic_istreamIcNS1_11char_traitsIcEEEEEC2Ev:
  264|  4.10k|    constexpr shared_ptr() noexcept : px( 0 ), pn()
  265|  4.10k|    {
  266|  4.10k|    }
_ZN5boost10shared_ptrINSt3__113basic_istreamIcNS1_11char_traitsIcEEEEE5resetIS5_NS_15program_options6detail12null_deleterEEEvPT_T0_:
  523|  2.11k|    {
  524|  2.11k|        this_type( p, static_cast< D&& >( d ) ).swap( *this );
  525|  2.11k|    }
_ZN5boost10shared_ptrINSt3__113basic_istreamIcNS1_11char_traitsIcEEEEEC2IS5_NS_15program_options6detail12null_deleterEEEPT_T0_:
  292|  2.11k|    template<class Y, class D> shared_ptr( Y * p, D d ): px( p ), pn( p, static_cast< D&& >( d ) )
  293|  2.11k|    {
  294|  2.11k|        boost::detail::sp_deleter_construct( this, p );
  295|  2.11k|    }
_ZN5boost6detail20sp_deleter_constructINSt3__113basic_istreamIcNS2_11char_traitsIcEEEES6_EEvPNS_10shared_ptrIT_EEPT0_:
  224|  2.11k|{
  225|  2.11k|    boost::detail::sp_enable_shared_from_this( ppx, p, p );
  226|  2.11k|}
_ZN5boost10shared_ptrINSt3__113basic_istreamIcNS1_11char_traitsIcEEEEE4swapERS6_:
  583|  2.11k|    {
  584|  2.11k|        std::swap(px, other.px);
  585|  2.11k|        pn.swap(other.pn);
  586|  2.11k|    }
_ZN5boost10shared_ptrINSt3__113basic_istreamIcNS1_11char_traitsIcEEEEEC2EOS6_:
  471|  43.2k|    shared_ptr( shared_ptr && r ) noexcept : px( r.px ), pn( static_cast< boost::detail::shared_count && >( r.pn ) )
  472|  43.2k|    {
  473|  43.2k|        r.px = 0;
  474|  43.2k|    }
_ZN5boost10shared_ptrINSt3__113basic_istreamIcNS1_11char_traitsIcEEEEEC2ERKS6_:
  315|  9.93k|    shared_ptr( shared_ptr const & r ) noexcept : px( r.px ), pn( r.pn )
  316|  9.93k|    {
  317|  9.93k|    }
_ZN5boost10shared_ptrIKNS_15program_options14value_semanticEEaSEOS4_:
  485|  24.3k|    {
  486|  24.3k|        this_type( static_cast< shared_ptr && >( r ) ).swap( *this );
  487|  24.3k|        return *this;
  488|  24.3k|    }
_ZN5boost10shared_ptrIKNS_15program_options14value_semanticEEC2EOS4_:
  471|  24.3k|    shared_ptr( shared_ptr && r ) noexcept : px( r.px ), pn( static_cast< boost::detail::shared_count && >( r.pn ) )
  472|  24.3k|    {
  473|  24.3k|        r.px = 0;
  474|  24.3k|    }
_ZN5boost10shared_ptrIKNS_15program_options14value_semanticEE4swapERS4_:
  583|  24.3k|    {
  584|  24.3k|        std::swap(px, other.px);
  585|  24.3k|        pn.swap(other.pn);
  586|  24.3k|    }
_ZNK5boost10shared_ptrIKNS_15program_options14value_semanticEEcvbEv:
  568|  12.6k|    {
  569|  12.6k|        return px != 0;
  570|  12.6k|    }

_ZN5boost36throw_exception_assert_compatibilityERKSt9exception:
  140|  1.44k|inline void throw_exception_assert_compatibility( std::exception const & ) {}
_ZN5boost15throw_exceptionINS_16bad_lexical_castEEEvRKT_:
  163|    483|{
  164|    483|    throw_exception_assert_compatibility( e );
  165|    483|    throw wrapexcept<E>( e );
  166|    483|}
_ZN5boost10wrapexceptINS_16bad_lexical_castEEC2ERKS1_:
   97|    483|    explicit wrapexcept( E const & e ): E( e )
   98|    483|    {
   99|    483|        copy_from( &e );
  100|    483|    }
_ZN5boost10wrapexceptINS_16bad_lexical_castEE9copy_fromEPKv:
   87|    483|    {
   88|    483|    }
_ZN5boost15throw_exceptionINS_15program_options20invalid_option_valueEEEvRKT_:
  163|    483|{
  164|    483|    throw_exception_assert_compatibility( e );
  165|    483|    throw wrapexcept<E>( e );
  166|    483|}
_ZN5boost10wrapexceptINS_15program_options20invalid_option_valueEEC2ERKS2_:
   97|    483|    explicit wrapexcept( E const & e ): E( e )
   98|    483|    {
   99|    483|        copy_from( &e );
  100|    483|    }
_ZN5boost10wrapexceptINS_15program_options20invalid_option_valueEE9copy_fromEPKv:
   87|    483|    {
   88|    483|    }
_ZN5boost15throw_exceptionINS_15program_options20multiple_occurrencesEEEvRKT_:
  163|     52|{
  164|     52|    throw_exception_assert_compatibility( e );
  165|     52|    throw wrapexcept<E>( e );
  166|     52|}
_ZN5boost10wrapexceptINS_15program_options20multiple_occurrencesEEC2ERKS2_:
   97|     52|    explicit wrapexcept( E const & e ): E( e )
   98|     52|    {
   99|     52|        copy_from( &e );
  100|     52|    }
_ZN5boost10wrapexceptINS_15program_options20multiple_occurrencesEE9copy_fromEPKv:
   87|     52|    {
   88|     52|    }
_ZN5boost15throw_exceptionINS_15program_options18invalid_bool_valueEEEvRKT_:
  163|    244|{
  164|    244|    throw_exception_assert_compatibility( e );
  165|    244|    throw wrapexcept<E>( e );
  166|    244|}
_ZN5boost10wrapexceptINS_15program_options18invalid_bool_valueEEC2ERKS2_:
   97|    244|    explicit wrapexcept( E const & e ): E( e )
   98|    244|    {
   99|    244|        copy_from( &e );
  100|    244|    }
_ZN5boost10wrapexceptINS_15program_options18invalid_bool_valueEE9copy_fromEPKv:
   87|    244|    {
   88|    244|    }
_ZN5boost15throw_exceptionINS_15program_options26invalid_config_file_syntaxEEEvRKT_:
  163|    181|{
  164|    181|    throw_exception_assert_compatibility( e );
  165|    181|    throw wrapexcept<E>( e );
  166|    181|}
_ZN5boost10wrapexceptINS_15program_options26invalid_config_file_syntaxEEC2ERKS2_:
   97|    181|    explicit wrapexcept( E const & e ): E( e )
   98|    181|    {
   99|    181|        copy_from( &e );
  100|    181|    }
_ZN5boost10wrapexceptINS_15program_options26invalid_config_file_syntaxEE9copy_fromEPKv:
   87|    181|    {
   88|    181|    }

_ZN5boost9typeindex7type_idINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEENS0_14stl_type_indexEv:
  211|    464|inline type_index type_id() noexcept {
  212|    464|    return type_index::type_id<T>();
  213|    464|}
_ZN5boost9typeindex7type_idIiEENS0_14stl_type_indexEv:
  211|    828|inline type_index type_id() noexcept {
  212|    828|    return type_index::type_id<T>();
  213|    828|}
_ZN5boost9typeindex7type_idIfEENS0_14stl_type_indexEv:
  211|    860|inline type_index type_id() noexcept {
  212|    860|    return type_index::type_id<T>();
  213|    860|}
_ZN5boost9typeindex7type_idIdEENS0_14stl_type_indexEv:
  211|    120|inline type_index type_id() noexcept {
  212|    120|    return type_index::type_id<T>();
  213|    120|}
_ZN5boost9typeindex7type_idIbEENS0_14stl_type_indexEv:
  211|  23.1k|inline type_index type_id() noexcept {
  212|  23.1k|    return type_index::type_id<T>();
  213|  23.1k|}

_ZNK5boost9typeindex14stl_type_index5equalERKS1_:
  181|  12.6k|inline bool stl_type_index::equal(const stl_type_index& rhs) const noexcept {
  182|  12.6k|#ifdef BOOST_TYPE_INDEX_CLASSINFO_COMPARE_BY_NAMES
  183|  12.6k|    return raw_name() == rhs.raw_name() || !std::strcmp(raw_name(), rhs.raw_name());
  ------------------
  |  Branch (183:12): [True: 12.6k, False: 0]
  |  Branch (183:44): [True: 0, False: 0]
  ------------------
  184|       |#else
  185|       |    return !!(*data_ == *rhs.data_);
  186|       |#endif
  187|  12.6k|}
_ZNK5boost9typeindex14stl_type_index8raw_nameEv:
  101|  25.3k|inline const char* stl_type_index::raw_name() const noexcept {
  102|       |#ifdef _MSC_VER
  103|       |    return data_->raw_name();
  104|       |#else
  105|  25.3k|    return data_->name();
  106|  25.3k|#endif
  107|  25.3k|}
_ZN5boost9typeindex14stl_type_indexC2ERKSt9type_info:
   73|  38.0k|        : data_(&data)
   74|  38.0k|    {}
_ZNK5boost9typeindex14stl_type_index9type_infoEv:
   96|  12.6k|inline const stl_type_index::type_info_t& stl_type_index::type_info() const noexcept {
   97|  12.6k|    return *data_;
   98|  12.6k|}
_ZN5boost9typeindex14stl_type_index7type_idINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEES1_v:
  201|    464|inline stl_type_index stl_type_index::type_id() noexcept {
  202|    464|    typedef typename std::remove_reference<T>::type no_ref_t;
  203|    464|    typedef typename std::remove_cv<no_ref_t>::type no_cvr_t;
  204|    464|    return typeid(no_cvr_t);
  205|    464|}
_ZN5boost9typeindex14stl_type_index7type_idIiEES1_v:
  201|    828|inline stl_type_index stl_type_index::type_id() noexcept {
  202|    828|    typedef typename std::remove_reference<T>::type no_ref_t;
  203|    828|    typedef typename std::remove_cv<no_ref_t>::type no_cvr_t;
  204|    828|    return typeid(no_cvr_t);
  205|    828|}
_ZN5boost9typeindex14stl_type_index7type_idIfEES1_v:
  201|    860|inline stl_type_index stl_type_index::type_id() noexcept {
  202|    860|    typedef typename std::remove_reference<T>::type no_ref_t;
  203|    860|    typedef typename std::remove_cv<no_ref_t>::type no_cvr_t;
  204|    860|    return typeid(no_cvr_t);
  205|    860|}
_ZN5boost9typeindex14stl_type_index7type_idIdEES1_v:
  201|    120|inline stl_type_index stl_type_index::type_id() noexcept {
  202|    120|    typedef typename std::remove_reference<T>::type no_ref_t;
  203|    120|    typedef typename std::remove_cv<no_ref_t>::type no_cvr_t;
  204|    120|    return typeid(no_cvr_t);
  205|    120|}
_ZN5boost9typeindex14stl_type_index7type_idIbEES1_v:
  201|  23.1k|inline stl_type_index stl_type_index::type_id() noexcept {
  202|  23.1k|    typedef typename std::remove_reference<T>::type no_ref_t;
  203|  23.1k|    typedef typename std::remove_cv<no_ref_t>::type no_cvr_t;
  204|  23.1k|    return typeid(no_cvr_t);
  205|  23.1k|}

_ZN5boost9typeindexeqINS0_14stl_type_indexESt9type_infoEEbRKT0_RKNS0_17type_index_facadeIT_S4_EE:
  181|  12.6k|inline bool operator == (const TypeInfo& lhs, const type_index_facade<Derived, TypeInfo>& rhs) noexcept {
  182|  12.6k|    return Derived(lhs) == rhs;
  183|  12.6k|}
_ZN5boost9typeindexeqINS0_14stl_type_indexESt9type_infoEEbRKNS0_17type_index_facadeIT_T0_EES9_:
  148|  12.6k|BOOST_CXX14_CONSTEXPR inline bool operator == (const type_index_facade<Derived, TypeInfo>& lhs, const type_index_facade<Derived, TypeInfo>& rhs) noexcept {
  149|  12.6k|    return static_cast<Derived const&>(lhs).equal(static_cast<Derived const&>(rhs));
  150|  12.6k|}

_ZNK5boost17integral_constantIbLb1EEcvRKN4mpl_5bool_ILb1EEEEv:
   81|  1.44M|      {
   82|  1.44M|         static const char data[sizeof(long)] = { 0 };
   83|  1.44M|         static const void* pdata = data;
   84|  1.44M|         return *(reinterpret_cast<const mpl::bool_<val>*>(pdata));
   85|  1.44M|      }

_ZN5boost15program_options14invalid_syntax12get_templateENS1_6kind_tE:
   44|    181|    {
   45|       |        // Initially, store the message in 'const char*' variable,
   46|       |        // to avoid conversion to string in all cases.
   47|    181|        const char* msg;
   48|    181|        switch(kind)
   49|    181|        {
   50|      0|        case empty_adjacent_parameter:
  ------------------
  |  Branch (50:9): [True: 0, False: 181]
  ------------------
   51|      0|            msg = "the argument for option '%canonical_option%' should follow immediately after the equal sign";
   52|      0|            break;
   53|      0|        case missing_parameter:
  ------------------
  |  Branch (53:9): [True: 0, False: 181]
  ------------------
   54|      0|            msg = "the required argument for option '%canonical_option%' is missing";
   55|      0|            break;
   56|    181|        case unrecognized_line:
  ------------------
  |  Branch (56:9): [True: 181, False: 0]
  ------------------
   57|    181|            msg = "the options configuration file contains an invalid line '%invalid_line%'";
   58|    181|            break;
   59|       |        // none of the following are currently used:
   60|      0|        case long_not_allowed:
  ------------------
  |  Branch (60:9): [True: 0, False: 181]
  ------------------
   61|      0|            msg = "the unabbreviated option '%canonical_option%' is not valid";
   62|      0|            break;
   63|      0|        case long_adjacent_not_allowed:
  ------------------
  |  Branch (63:9): [True: 0, False: 181]
  ------------------
   64|      0|            msg = "the unabbreviated option '%canonical_option%' does not take any arguments";
   65|      0|            break;
   66|      0|        case short_adjacent_not_allowed:
  ------------------
  |  Branch (66:9): [True: 0, False: 181]
  ------------------
   67|      0|            msg = "the abbreviated option '%canonical_option%' does not take any arguments";
   68|      0|            break;
   69|      0|        case extra_parameter:
  ------------------
  |  Branch (69:9): [True: 0, False: 181]
  ------------------
   70|      0|            msg = "option '%canonical_option%' does not take any arguments";
   71|      0|            break;
   72|      0|        default:
  ------------------
  |  Branch (72:9): [True: 0, False: 181]
  ------------------
   73|      0|            msg = "unknown command line syntax error for '%s'";
   74|    181|        }
   75|    181|        return msg;
   76|    181|    }

_ZN5boost15program_options6detail27common_config_file_iteratorC2ERKNSt3__13setINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS3_4lessISA_EENS8_ISA_EEEEb:
   27|  2.11k|    : allowed_options(allowed_options),
   28|  2.11k|      m_allow_unregistered(allow_unregistered)
   29|  2.11k|    {
   30|  2.11k|        for(std::set<std::string>::const_iterator i = allowed_options.begin();
   31|  67.6k|            i != allowed_options.end(); 
  ------------------
  |  Branch (31:13): [True: 65.5k, False: 2.11k]
  ------------------
   32|  65.5k|            ++i)
   33|  65.5k|        {
   34|  65.5k|            add_option(i->c_str());
   35|  65.5k|        }
   36|  2.11k|    }
_ZN5boost15program_options6detail27common_config_file_iterator10add_optionEPKc:
   40|  65.5k|    {
   41|  65.5k|        string s(name);
   42|  65.5k|        assert(!s.empty());
   43|  65.5k|        if (*s.rbegin() == '*') {
  ------------------
  |  Branch (43:13): [True: 0, False: 65.5k]
  ------------------
   44|      0|            s.resize(s.size()-1);
   45|      0|            bool bad_prefixes(false);
   46|       |            // If 's' is a prefix of one of allowed suffix, then
   47|       |            // lower_bound will return that element.
   48|       |            // If some element is prefix of 's', then lower_bound will
   49|       |            // return the next element.
   50|      0|            set<string>::iterator i = allowed_prefixes.lower_bound(s);
   51|      0|            if (i != allowed_prefixes.end()) {
  ------------------
  |  Branch (51:17): [True: 0, False: 0]
  ------------------
   52|      0|                if (i->find(s) == 0)
  ------------------
  |  Branch (52:21): [True: 0, False: 0]
  ------------------
   53|      0|                    bad_prefixes = true;                    
   54|      0|            }
   55|      0|            if (i != allowed_prefixes.begin()) {
  ------------------
  |  Branch (55:17): [True: 0, False: 0]
  ------------------
   56|      0|                --i;
   57|      0|                if (s.find(*i) == 0)
  ------------------
  |  Branch (57:21): [True: 0, False: 0]
  ------------------
   58|      0|                    bad_prefixes = true;
   59|      0|            }
   60|      0|            if (bad_prefixes)
  ------------------
  |  Branch (60:17): [True: 0, False: 0]
  ------------------
   61|      0|                boost::throw_exception(error("options '" + string(name) + "' and '" +
   62|      0|                                             *i + "*' will both match the same "
   63|      0|                                             "arguments from the configuration file"));
   64|      0|            allowed_prefixes.insert(s);
   65|      0|        }
   66|  65.5k|    }
_ZN5boost15program_options6detail27common_config_file_iterator3getEv:
   84|  1.44M|    {
   85|  1.44M|        string s;
   86|  1.44M|        string::size_type n;
   87|  1.44M|        bool found = false;
   88|       |
   89|  1.51M|        while(this->getline(s)) {
  ------------------
  |  Branch (89:15): [True: 1.51M, False: 1.93k]
  ------------------
   90|       |
   91|       |            // strip '#' comments and whitespace
   92|  1.51M|            if ((n = s.find('#')) != string::npos)
  ------------------
  |  Branch (92:17): [True: 1.78k, False: 1.51M]
  ------------------
   93|  1.78k|                s = s.substr(0, n);
   94|  1.51M|            s = trim_ws(s);
   95|       |
   96|  1.51M|            if (!s.empty()) {
  ------------------
  |  Branch (96:17): [True: 1.44M, False: 75.0k]
  ------------------
   97|       |                // Handle section name
   98|  1.44M|                if (*s.begin() == '[' && *s.rbegin() == ']') {
  ------------------
  |  Branch (98:21): [True: 2.34k, False: 1.43M]
  |  Branch (98:21): [True: 2.10k, False: 1.43M]
  |  Branch (98:42): [True: 2.10k, False: 242]
  ------------------
   99|  2.10k|                    m_prefix = s.substr(1, s.size()-2);
  100|  2.10k|                    if (*m_prefix.rbegin() != '.')
  ------------------
  |  Branch (100:25): [True: 1.68k, False: 414]
  ------------------
  101|  1.68k|                        m_prefix += '.';
  102|  2.10k|                }
  103|  1.43M|                else if ((n = s.find('=')) != string::npos) {
  ------------------
  |  Branch (103:26): [True: 1.43M, False: 181]
  ------------------
  104|       |
  105|  1.43M|                    string name = m_prefix + trim_ws(s.substr(0, n));
  106|  1.43M|                    string value = trim_ws(s.substr(n+1));
  107|       |
  108|  1.43M|                    bool registered = allowed_option(name);
  109|  1.43M|                    if (!registered && !m_allow_unregistered)
  ------------------
  |  Branch (109:25): [True: 1.43M, False: 3.00k]
  |  Branch (109:40): [True: 0, False: 1.43M]
  ------------------
  110|      0|                        boost::throw_exception(unknown_option(name));
  111|       |
  112|  1.43M|                    found = true;
  113|  1.43M|                    this->value().string_key = name;
  114|  1.43M|                    this->value().value.clear();
  115|  1.43M|                    this->value().value.push_back(value);
  116|  1.43M|                    this->value().unregistered = !registered;
  117|  1.43M|                    this->value().original_tokens.clear();
  118|  1.43M|                    this->value().original_tokens.push_back(name);
  119|  1.43M|                    this->value().original_tokens.push_back(value);
  120|  1.43M|                    break;
  121|       |
  122|  1.43M|                } else {
  123|    181|                    boost::throw_exception(invalid_config_file_syntax(s, invalid_syntax::unrecognized_line));
  124|    181|                }
  125|  1.44M|            }
  126|  1.51M|        }
  127|  1.44M|        if (!found)
  ------------------
  |  Branch (127:13): [True: 1.93k, False: 1.43M]
  ------------------
  128|  1.93k|            found_eof();
  129|  1.44M|    }
_ZNK5boost15program_options6detail27common_config_file_iterator14allowed_optionERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
  134|  1.43M|    {
  135|  1.43M|        set<string>::const_iterator i = allowed_options.find(s);
  136|  1.43M|        if (i != allowed_options.end())
  ------------------
  |  Branch (136:13): [True: 3.00k, False: 1.43M]
  ------------------
  137|  3.00k|            return true;        
  138|       |        // If s is "pa" where "p" is allowed prefix then
  139|       |        // lower_bound should find the element after "p". 
  140|       |        // This depends on 'allowed_prefixes' invariant.
  141|  1.43M|        i = allowed_prefixes.lower_bound(s);
  142|  1.43M|        if (i != allowed_prefixes.begin() && s.find(*--i) == 0)
  ------------------
  |  Branch (142:13): [True: 0, False: 1.43M]
  |  Branch (142:13): [True: 0, False: 1.43M]
  |  Branch (142:46): [True: 0, False: 0]
  ------------------
  143|      0|            return true;
  144|  1.43M|        return false;
  145|  1.43M|    }
config_file.cpp:_ZN5boost15program_options6detail12_GLOBAL__N_17trim_wsERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
   70|  4.39M|        {
   71|  4.39M|            string::size_type n, n2;
   72|  4.39M|            n = s.find_first_not_of(" \t\r\n");
   73|  4.39M|            if (n == string::npos)
  ------------------
  |  Branch (73:17): [True: 2.80M, False: 1.59M]
  ------------------
   74|  2.80M|                return string();
   75|  1.59M|            else {
   76|  1.59M|                n2 = s.find_last_not_of(" \t\r\n");
   77|  1.59M|                return s.substr(n, n2-n+1);
   78|  1.59M|            }
   79|  4.39M|        }

_ZN5boost15program_options11to_internalERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  151|  1.51M|        {
  152|  1.51M|            return s;
  153|  1.51M|        }

_ZN5boost15program_options18option_descriptionC2EPKcPKNS0_14value_semanticE:
   55|  65.5k|    : m_value_semantic(s)
   56|  65.5k|    {
   57|  65.5k|        this->set_names(names);
   58|  65.5k|    }
_ZN5boost15program_options18option_descriptionD2Ev:
   71|  65.5k|    {
   72|  65.5k|    }
_ZNK5boost15program_options18option_description5matchERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEbbb:
   79|  83.0k|    {
   80|  83.0k|        match_result result = no_match;        
   81|  83.0k|        std::string local_option = (long_ignore_case ? tolower_(option) : option);
  ------------------
  |  Branch (81:37): [True: 0, False: 83.0k]
  ------------------
   82|       |        
   83|   163k|        for(std::vector<std::string>::const_iterator it(m_long_names.begin()); it != m_long_names.end(); it++)
  ------------------
  |  Branch (83:80): [True: 83.0k, False: 80.4k]
  ------------------
   84|  83.0k|        {
   85|  83.0k|            std::string local_long_name((long_ignore_case ? tolower_(*it) : *it));
  ------------------
  |  Branch (85:42): [True: 0, False: 83.0k]
  ------------------
   86|       |
   87|  83.0k|            if (!local_long_name.empty()) {
  ------------------
  |  Branch (87:17): [True: 83.0k, False: 0]
  ------------------
   88|       |
   89|       |
   90|  83.0k|                if ((result == no_match) && (*local_long_name.rbegin() == '*'))
  ------------------
  |  Branch (90:21): [True: 83.0k, False: 0]
  |  Branch (90:21): [True: 0, False: 83.0k]
  |  Branch (90:45): [True: 0, False: 83.0k]
  ------------------
   91|      0|                {
   92|       |                    // The name ends with '*'. Any specified name with the given
   93|       |                    // prefix is OK.
   94|      0|                    if (local_option.find(local_long_name.substr(0, local_long_name.length()-1))
  ------------------
  |  Branch (94:25): [True: 0, False: 0]
  ------------------
   95|      0|                        == 0)
   96|      0|                        result = approximate_match;
   97|      0|                }
   98|       |
   99|  83.0k|                if (local_long_name == local_option)
  ------------------
  |  Branch (99:21): [True: 2.68k, False: 80.4k]
  ------------------
  100|  2.68k|                {
  101|  2.68k|                    result = full_match;
  102|  2.68k|                    break;
  103|  2.68k|                }
  104|  80.4k|                else if (approx)
  ------------------
  |  Branch (104:26): [True: 0, False: 80.4k]
  ------------------
  105|      0|                {
  106|      0|                    if (local_long_name.find(local_option) == 0)
  ------------------
  |  Branch (106:25): [True: 0, False: 0]
  ------------------
  107|      0|                    {
  108|      0|                        result = approximate_match;
  109|      0|                    }
  110|      0|                }
  111|  83.0k|            }
  112|       |
  113|  83.0k|        }
  114|       |
  115|  83.0k|        if (result != full_match)
  ------------------
  |  Branch (115:13): [True: 80.4k, False: 2.68k]
  ------------------
  116|  80.4k|        {
  117|  80.4k|            std::string local_short_name(short_ignore_case ? tolower_(m_short_name) : m_short_name);
  ------------------
  |  Branch (117:42): [True: 0, False: 80.4k]
  ------------------
  118|       |
  119|  80.4k|            if (local_short_name == local_option)
  ------------------
  |  Branch (119:17): [True: 0, False: 80.4k]
  ------------------
  120|      0|            {
  121|      0|                result = full_match;
  122|      0|            }
  123|  80.4k|        }
  124|       |
  125|  83.0k|        return result;        
  126|  83.0k|    }
_ZNK5boost15program_options18option_description3keyERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
  130|  38.4k|    {
  131|       |        // We make the arbitrary choise of using the first long
  132|       |        // name as the key, regardless of anything else
  133|  38.4k|        if (!m_long_names.empty()) {
  ------------------
  |  Branch (133:13): [True: 38.4k, False: 0]
  ------------------
  134|  38.4k|            const std::string& first_long_name = *m_long_names.begin();
  135|  38.4k|            if (first_long_name.find('*') != string::npos)
  ------------------
  |  Branch (135:17): [True: 0, False: 38.4k]
  ------------------
  136|       |                // The '*' character means we're long_name
  137|       |                // matches only part of the input. So, returning
  138|       |                // long name will remove some of the information,
  139|       |                // and we have to return the option as specified
  140|       |                // in the source.
  141|      0|                return option;
  142|  38.4k|            else
  143|  38.4k|                return first_long_name;
  144|  38.4k|        }
  145|      0|        else
  146|      0|            return m_short_name;
  147|  38.4k|    }
_ZNK5boost15program_options18option_description9long_nameEv:
  177|   131k|    {
  178|   131k|        static std::string empty_string("");
  179|   131k|        return m_long_names.empty() ? empty_string : *m_long_names.begin();
  ------------------
  |  Branch (179:16): [True: 0, False: 131k]
  ------------------
  180|   131k|    }
_ZN5boost15program_options18option_description9set_namesEPKc:
  193|  65.5k|    {
  194|  65.5k|        m_long_names.clear();
  195|  65.5k|        std::istringstream iss(_names);
  196|  65.5k|        std::string name;
  197|       |
  198|   131k|        while(std::getline(iss, name, ',')) {
  ------------------
  |  Branch (198:15): [True: 65.5k, False: 65.5k]
  ------------------
  199|  65.5k|            m_long_names.push_back(name);
  200|  65.5k|        }
  201|  65.5k|        assert(!m_long_names.empty() && "No option names were specified");
  202|       |
  203|  65.5k|        bool try_interpreting_last_name_as_a_switch = m_long_names.size() > 1;
  204|  65.5k|        if (try_interpreting_last_name_as_a_switch) {
  ------------------
  |  Branch (204:13): [True: 0, False: 65.5k]
  ------------------
  205|      0|            const std::string& last_name = *m_long_names.rbegin();
  206|      0|            if (last_name.length() == 1) {
  ------------------
  |  Branch (206:17): [True: 0, False: 0]
  ------------------
  207|      0|                m_short_name = '-' + last_name;
  208|      0|                m_long_names.pop_back();
  209|       |                // The following caters to the (valid) input of ",c" for some
  210|       |                // character c, where the caller only wants this option to have
  211|       |                // a short name.
  212|      0|                if (m_long_names.size() == 1 && (*m_long_names.begin()).empty()) {
  ------------------
  |  Branch (212:21): [True: 0, False: 0]
  |  Branch (212:21): [True: 0, False: 0]
  |  Branch (212:49): [True: 0, False: 0]
  ------------------
  213|      0|                    m_long_names.clear();
  214|      0|                }
  215|      0|            }
  216|      0|        }
  217|       |        // We could theoretically also ensure no remaining long names
  218|       |        // are empty, or that none of them have length 1
  219|  65.5k|        return *this;
  220|  65.5k|    }
_ZNK5boost15program_options18option_description8semanticEv:
  230|  87.8k|    {
  231|  87.8k|        return m_value_semantic;
  232|  87.8k|    }
_ZN5boost15program_options29options_description_easy_initC2EPNS0_19options_descriptionE:
  258|  2.11k|    : owner(owner)
  259|  2.11k|    {}
_ZN5boost15program_options29options_description_easy_initclEPKcPKNS0_14value_semanticE:
  280|  65.5k|    {
  281|  65.5k|        shared_ptr<option_description> d(new option_description(name, s));
  282|  65.5k|        owner->add(d);
  283|  65.5k|        return *this;
  284|  65.5k|    }
_ZN5boost15program_options19options_descriptionC2Ejj:
  302|  2.11k|    : m_line_length(line_length)
  303|  2.11k|    , m_min_description_length(min_description_length)
  304|  2.11k|    {
  305|       |        // we require a space between the option and description parts, so add 1.
  306|  2.11k|        assert(m_min_description_length < m_line_length - 1);    
  307|  2.11k|    }
_ZN5boost15program_options19options_description3addENS_10shared_ptrINS0_18option_descriptionEEE:
  322|  65.5k|    {
  323|  65.5k|        m_options.push_back(desc);
  324|  65.5k|        belong_to_group.push_back(false);
  325|  65.5k|    }
_ZN5boost15program_options19options_description11add_optionsEv:
  343|  2.11k|    {       
  344|  2.11k|        return options_description_easy_init(this);
  345|  2.11k|    }
_ZNK5boost15program_options19options_description4findERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEbbb:
  352|  2.68k|    {
  353|  2.68k|        const option_description* d = find_nothrow(name, approx, 
  354|  2.68k|                                       long_ignore_case, short_ignore_case);
  355|  2.68k|        if (!d)
  ------------------
  |  Branch (355:13): [True: 0, False: 2.68k]
  ------------------
  356|      0|            boost::throw_exception(unknown_option());
  357|  2.68k|        return *d;
  358|  2.68k|    }
_ZNK5boost15program_options19options_description7optionsEv:
  362|  3.27k|    {
  363|  3.27k|        return m_options;
  364|  3.27k|    }
_ZNK5boost15program_options19options_description12find_nothrowERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEbbb:
  371|  2.68k|    {
  372|  2.68k|        shared_ptr<option_description> found;
  373|  2.68k|        bool had_full_match = false;
  374|  2.68k|        vector<string> approximate_matches;
  375|  2.68k|        vector<string> full_matches;
  376|       |        
  377|       |        // We use linear search because matching specified option
  378|       |        // name with the declared option name need to take care about
  379|       |        // case sensitivity and trailing '*' and so we can't use simple map.
  380|  85.7k|        for(unsigned i = 0; i < m_options.size(); ++i)
  ------------------
  |  Branch (380:29): [True: 83.0k, False: 2.68k]
  ------------------
  381|  83.0k|        {
  382|  83.0k|            option_description::match_result r = 
  383|  83.0k|                m_options[i]->match(name, approx, long_ignore_case, short_ignore_case);
  384|       |
  385|  83.0k|            if (r == option_description::no_match)
  ------------------
  |  Branch (385:17): [True: 80.4k, False: 2.68k]
  ------------------
  386|  80.4k|                continue;
  387|       |
  388|  2.68k|            if (r == option_description::full_match)
  ------------------
  |  Branch (388:17): [True: 2.68k, False: 0]
  ------------------
  389|  2.68k|            {                
  390|  2.68k|                full_matches.push_back(m_options[i]->key(name));
  391|  2.68k|                found = m_options[i];
  392|  2.68k|                had_full_match = true;
  393|  2.68k|            } 
  394|      0|            else 
  395|      0|            {                        
  396|       |                // FIXME: the use of 'key' here might not
  397|       |                // be the best approach.
  398|      0|                approximate_matches.push_back(m_options[i]->key(name));
  399|      0|                if (!had_full_match)
  ------------------
  |  Branch (399:21): [True: 0, False: 0]
  ------------------
  400|      0|                    found = m_options[i];
  401|      0|            }
  402|  2.68k|        }
  403|  2.68k|        if (full_matches.size() > 1) 
  ------------------
  |  Branch (403:13): [True: 0, False: 2.68k]
  ------------------
  404|      0|            boost::throw_exception(ambiguous_option(full_matches));
  405|       |        
  406|       |        // If we have a full match, and an approximate match,
  407|       |        // ignore approximate match instead of reporting error.
  408|       |        // Say, if we have options "all" and "all-chroots", then
  409|       |        // "--all" on the command line should select the first one,
  410|       |        // without ambiguity.
  411|  2.68k|        if (full_matches.empty() && approximate_matches.size() > 1)
  ------------------
  |  Branch (411:13): [True: 0, False: 2.68k]
  |  Branch (411:37): [True: 0, False: 0]
  ------------------
  412|      0|            boost::throw_exception(ambiguous_option(approximate_matches));
  413|       |
  414|  2.68k|        return found.get();
  415|  2.68k|    }

_ZN5boost15program_options17parse_config_fileIcEENS0_20basic_parsed_optionsIT_EERNSt3__113basic_istreamIS3_NS5_11char_traitsIS3_EEEERKNS0_19options_descriptionEb:
  107|  2.11k|    {    
  108|  2.11k|        set<string> allowed_options;
  109|       |
  110|  2.11k|        const vector<shared_ptr<option_description> >& options = desc.options();
  111|  67.6k|        for (unsigned i = 0; i < options.size(); ++i)
  ------------------
  |  Branch (111:30): [True: 65.5k, False: 2.11k]
  ------------------
  112|  65.5k|        {
  113|  65.5k|            const option_description& d = *options[i];
  114|       |
  115|  65.5k|            if (d.long_name().empty())
  ------------------
  |  Branch (115:17): [True: 0, False: 65.5k]
  ------------------
  116|      0|                boost::throw_exception(
  117|      0|                    error("abbreviated option names are not permitted in options configuration files"));
  118|       |
  119|  65.5k|            allowed_options.insert(d.long_name());
  120|  65.5k|        }
  121|       |
  122|       |        // Parser return char strings
  123|  2.11k|        parsed_options result(&desc);        
  124|  2.11k|        copy(detail::basic_config_file_iterator<charT>(
  125|  2.11k|                 is, allowed_options, allow_unregistered), 
  126|  2.11k|             detail::basic_config_file_iterator<charT>(), 
  127|  2.11k|             back_inserter(result.options));
  128|       |        // Convert char strings into desired type.
  129|  2.11k|        return basic_parsed_options<charT>(result);
  130|  2.11k|    }

_ZNK5boost15program_options29value_semantic_codecvt_helperIcE5parseERNS_3anyERKNSt3__16vectorINS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEENSA_ISC_EEEEb:
   42|  2.68k|    {
   43|  2.68k|        if (utf8) {
  ------------------
  |  Branch (43:13): [True: 0, False: 2.68k]
  ------------------
   44|      0|#ifndef BOOST_NO_STD_WSTRING
   45|       |            // Need to convert to local encoding.
   46|      0|            std::vector<string> local_tokens;
   47|      0|            for (unsigned i = 0; i < new_tokens.size(); ++i) {
  ------------------
  |  Branch (47:34): [True: 0, False: 0]
  ------------------
   48|      0|                std::wstring w = from_utf8(new_tokens[i]);
   49|      0|                local_tokens.push_back(to_local_8_bit(w));
   50|      0|            }
   51|      0|            xparse(value_store, local_tokens);
   52|       |#else
   53|       |            boost::throw_exception(
   54|       |                std::runtime_error("UTF-8 conversion not supported."));
   55|       |#endif
   56|  2.68k|        } else {
   57|       |            // Already in local encoding, pass unmodified
   58|  2.68k|            xparse(value_store, new_tokens);
   59|  2.68k|        }        
   60|  2.68k|    }
_ZN5boost15program_options11bool_switchEv:
  128|  21.1k|    {
  129|  21.1k|        return bool_switch(0);
  130|  21.1k|    }
_ZN5boost15program_options11bool_switchEPb:
  134|  21.1k|    {
  135|  21.1k|        typed_value<bool>* r = new typed_value<bool>(v);
  136|  21.1k|        r->default_value(0);
  137|  21.1k|        r->zero_tokens();
  138|       |
  139|  21.1k|        return r;
  140|  21.1k|    }
_ZN5boost15program_options8validateERNS_3anyERKNSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEEPbi:
  150|    715|    {
  151|    715|        check_first_occurrence(v);
  152|    715|        string s(get_single_string(xs, true));
  153|       |
  154|  8.73M|        for (size_t i = 0; i < s.size(); ++i)
  ------------------
  |  Branch (154:28): [True: 8.73M, False: 715]
  ------------------
  155|  8.73M|            s[i] = char(tolower(s[i]));
  156|       |
  157|    715|        if (s.empty() || s == "on" || s == "yes" || s == "1" || s == "true")
  ------------------
  |  Branch (157:13): [True: 330, False: 385]
  |  Branch (157:26): [True: 6, False: 379]
  |  Branch (157:39): [True: 9, False: 370]
  |  Branch (157:53): [True: 28, False: 342]
  |  Branch (157:65): [True: 9, False: 333]
  ------------------
  158|    369|            v = any(true);
  159|    346|        else if (s == "off" || s == "no" || s == "0" || s == "false")
  ------------------
  |  Branch (159:18): [True: 31, False: 315]
  |  Branch (159:32): [True: 14, False: 301]
  |  Branch (159:45): [True: 36, False: 265]
  |  Branch (159:57): [True: 21, False: 244]
  ------------------
  160|     89|            v = any(false);
  161|    257|        else
  162|    257|            boost::throw_exception(invalid_bool_value(s));
  163|    715|    }
_ZN5boost15program_options8validateERNS_3anyERKNSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEEPSA_i:
  189|    298|    {
  190|    298|        check_first_occurrence(v);
  191|    298|        v = any(get_single_string(xs));
  192|    298|    }
_ZN5boost15program_options10validators22check_first_occurrenceERKNS_3anyE:
  207|  2.68k|        {
  208|  2.68k|            if (!value.empty())
  ------------------
  |  Branch (208:17): [True: 52, False: 2.62k]
  ------------------
  209|     52|                boost::throw_exception(
  210|     52|                    multiple_occurrences());
  211|  2.68k|        }
_ZN5boost15program_options20invalid_option_valueC2ERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
  217|    483|    : validation_error(validation_error::invalid_option_value)
  218|    483|    {
  219|    483|        set_substitute("value", bad_value);
  220|    483|    }
_ZN5boost15program_options18invalid_bool_valueC2ERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
  235|    244|    : validation_error(validation_error::invalid_bool_value)
  236|    244|    {
  237|    244|        set_substitute("value", bad_value);
  238|    244|    }
_ZN5boost15program_options22error_with_option_nameC2ERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEESA_SA_i:
  249|    960|                                        error(template_),
  250|    960|                                        m_option_style(option_style),
  251|    960|                                        m_error_template(template_)
  252|    960|    {
  253|       |        //                     parameter            |     placeholder               |   value
  254|       |        //                     ---------            |     -----------               |   -----
  255|    960|        set_substitute_default("canonical_option",  "option '%canonical_option%'",  "option");
  256|    960|        set_substitute_default("value",             "argument ('%value%')",         "argument");
  257|    960|        set_substitute_default("prefix",            "%prefix%",                     "");
  258|    960|        m_substitutions["option"] = option_name;
  259|    960|        m_substitutions["original_token"] = original_token;
  260|    960|    }
_ZN5boost15program_options16validation_error12get_templateENS1_6kind_tE:
  402|    727|    {
  403|       |        // Initially, store the message in 'const char*' variable,
  404|       |        // to avoid conversion to std::string in all cases.
  405|    727|        const char* msg;
  406|    727|        switch(kind)
  407|    727|        {
  408|    244|        case invalid_bool_value:
  ------------------
  |  Branch (408:9): [True: 244, False: 483]
  ------------------
  409|    244|            msg = "the argument ('%value%') for option '%canonical_option%' is invalid. Valid choices are 'on|off', 'yes|no', '1|0' and 'true|false'";
  410|    244|            break;
  411|    483|        case invalid_option_value:
  ------------------
  |  Branch (411:9): [True: 483, False: 244]
  ------------------
  412|    483|            msg = "the argument ('%value%') for option '%canonical_option%' is invalid";
  413|    483|            break;
  414|      0|        case multiple_values_not_allowed:
  ------------------
  |  Branch (414:9): [True: 0, False: 727]
  ------------------
  415|      0|            msg = "option '%canonical_option%' only takes a single argument";
  416|      0|            break;
  417|      0|        case at_least_one_value_required:
  ------------------
  |  Branch (417:9): [True: 0, False: 727]
  ------------------
  418|      0|            msg = "option '%canonical_option%' requires at least one argument";
  419|      0|            break;
  420|       |        // currently unused
  421|      0|        case invalid_option:
  ------------------
  |  Branch (421:9): [True: 0, False: 727]
  ------------------
  422|      0|            msg = "option '%canonical_option%' is not valid";
  423|      0|            break;
  424|      0|        default:
  ------------------
  |  Branch (424:9): [True: 0, False: 727]
  ------------------
  425|      0|            msg = "unknown error";
  426|    727|        }
  427|    727|        return msg;
  428|    727|    }

_ZN5boost15program_options5storeERKNS0_20basic_parsed_optionsIcEERNS0_13variables_mapEb:
   26|  1.93k|    {
   27|       |        // TODO: what if we have different definition
   28|       |        // for the same option name during different calls
   29|       |        // 'store'.
   30|  1.93k|        assert(options.description);
   31|  1.93k|        const options_description& desc = *options.description;
   32|       |
   33|       |        // We need to access map's operator[], not the overriden version
   34|       |        // variables_map. Ehmm.. messy.
   35|  1.93k|        std::map<std::string, variable_value>& m = xm;
   36|       |
   37|  1.93k|        std::set<std::string> new_final;
   38|       |
   39|       |        // Declared once, to please Intel in VC++ mode;
   40|  1.93k|        unsigned i;
   41|       |
   42|       |        // Declared here so can be used to provide context for exceptions
   43|  1.93k|        string option_name;
   44|  1.93k|        string original_token;
   45|       |
   46|  1.93k|#ifndef BOOST_NO_EXCEPTIONS
   47|  1.93k|        try
   48|  1.93k|#endif
   49|  1.93k|        {
   50|       |
   51|       |            // First, convert/store all given options
   52|  1.41M|            for (i = 0; i < options.options.size(); ++i) {
  ------------------
  |  Branch (52:25): [True: 1.40M, False: 1.93k]
  ------------------
   53|       |
   54|  1.40M|                option_name = options.options[i].string_key;
   55|       |                // Skip positional options without name
   56|  1.40M|                if (option_name.empty())
  ------------------
  |  Branch (56:21): [True: 853k, False: 555k]
  ------------------
   57|   853k|                    continue;
   58|       |
   59|       |                // Ignore unregistered option. The 'unregistered'
   60|       |                // field can be true only if user has explicitly asked
   61|       |                // to allow unregistered options. We can't store them
   62|       |                // to variables map (lacking any information about paring),
   63|       |                // so just ignore them.
   64|   555k|                if (options.options[i].unregistered)
  ------------------
  |  Branch (64:21): [True: 553k, False: 2.68k]
  ------------------
   65|   553k|                    continue;
   66|       |
   67|       |                // If option has final value, skip this assignment
   68|  2.68k|                if (xm.m_final.count(option_name))
  ------------------
  |  Branch (68:21): [True: 0, False: 2.68k]
  ------------------
   69|      0|                    continue;
   70|       |
   71|  2.68k|                original_token = options.options[i].original_tokens.size() ?
  ------------------
  |  Branch (71:34): [True: 2.68k, False: 0]
  ------------------
   72|  2.68k|                                        options.options[i].original_tokens[0]     : "";
   73|  2.68k|                const option_description& d = desc.find(option_name, false,
   74|  2.68k|                                                        false, false);
   75|       |
   76|  2.68k|                variable_value& v = m[option_name];
   77|  2.68k|                if (v.defaulted()) {
  ------------------
  |  Branch (77:21): [True: 0, False: 2.68k]
  ------------------
   78|       |                    // Explicit assignment here erases defaulted value
   79|      0|                    v = variable_value();
   80|      0|                }
   81|       |
   82|  2.68k|                d.semantic()->parse(v.value(), options.options[i].value, utf8);
   83|       |
   84|  2.68k|                v.m_value_semantic = d.semantic();
   85|       |
   86|       |                // The option is not composing, and the value is explicitly
   87|       |                // provided. Ignore values of this option for subsequent
   88|       |                // calls to 'store'. We store this to a temporary set,
   89|       |                // so that several assignment inside *this* 'store' call
   90|       |                // are allowed.
   91|  2.68k|                if (!d.semantic()->is_composing())
  ------------------
  |  Branch (91:21): [True: 1.90k, False: 779]
  ------------------
   92|  1.90k|                    new_final.insert(option_name);
   93|  2.68k|            }
   94|  1.93k|        }
   95|  1.93k|#ifndef BOOST_NO_EXCEPTIONS
   96|  1.93k|        catch(error_with_option_name& e)
   97|  1.93k|        {
   98|       |            // add context and rethrow
   99|    779|            e.add_context(option_name, original_token, options.m_options_prefix);
  100|    779|            throw;
  101|    779|        }
  102|      0|#endif
  103|  1.15k|        xm.m_final.insert(new_final.begin(), new_final.end());
  104|       |
  105|       |
  106|       |
  107|       |        // Second, apply default values and store required options.
  108|  1.15k|        const vector<shared_ptr<option_description> >& all = desc.options();
  109|  36.9k|        for(i = 0; i < all.size(); ++i)
  ------------------
  |  Branch (109:20): [True: 35.8k, False: 1.15k]
  ------------------
  110|  35.8k|        {
  111|  35.8k|            const option_description& d = *all[i];
  112|  35.8k|            string key = d.key("");
  113|       |            // FIXME: this logic relies on knowledge of option_description
  114|       |            // internals.
  115|       |            // The 'key' is empty if options description contains '*'.
  116|       |            // In that
  117|       |            // case, default value makes no sense at all.
  118|  35.8k|            if (key.empty())
  ------------------
  |  Branch (118:17): [True: 0, False: 35.8k]
  ------------------
  119|      0|            {
  120|      0|                continue;
  121|      0|            }
  122|  35.8k|            if (m.count(key) == 0) {
  ------------------
  |  Branch (122:17): [True: 34.3k, False: 1.48k]
  ------------------
  123|       |
  124|  34.3k|                boost::any def;
  125|  34.3k|                if (d.semantic()->apply_default(def)) {
  ------------------
  |  Branch (125:21): [True: 11.2k, False: 23.1k]
  ------------------
  126|  11.2k|                    m[key] = variable_value(def, true);
  127|  11.2k|                    m[key].m_value_semantic = d.semantic();
  128|  11.2k|                }
  129|  34.3k|            }
  130|       |
  131|       |            // add empty value if this is an required option
  132|  35.8k|            if (d.semantic()->is_required()) {
  ------------------
  |  Branch (132:17): [True: 0, False: 35.8k]
  ------------------
  133|       |
  134|       |                // For option names specified in multiple ways, e.g. on the command line,
  135|       |                // config file etc, the following precedence rules apply:
  136|       |                //  "--"  >  ("-" or "/")  >  ""
  137|       |                //  Precedence is set conveniently by a single call to length()
  138|      0|                string canonical_name = d.canonical_display_name(options.m_options_prefix);
  139|      0|                if (canonical_name.length() > xm.m_required[key].length())
  ------------------
  |  Branch (139:21): [True: 0, False: 0]
  ------------------
  140|      0|                    xm.m_required[key] = canonical_name;
  141|      0|            }
  142|  35.8k|        }
  143|  1.15k|    }
_ZN5boost15program_options6notifyERNS0_13variables_mapE:
  153|  1.15k|    {
  154|  1.15k|        vm.notify();
  155|  1.15k|    }
_ZN5boost15program_options22abstract_variables_mapC2Ev:
  158|  2.11k|    : m_next(0)
  159|  2.11k|    {}
_ZN5boost15program_options13variables_mapC2Ev:
  189|  2.11k|    {}
_ZN5boost15program_options13variables_map6notifyEv:
  215|  1.15k|    {
  216|       |        // This checks if all required options occur
  217|  1.15k|        for (map<string, string>::const_iterator r = m_required.begin();
  218|  1.15k|             r != m_required.end();
  ------------------
  |  Branch (218:14): [True: 0, False: 1.15k]
  ------------------
  219|  1.15k|             ++r)
  220|      0|        {
  221|      0|            const string& opt = r->first;
  222|      0|            const string& display_opt = r->second;
  223|      0|            map<string, variable_value>::const_iterator iter = find(opt);
  224|      0|            if (iter == end() || iter->second.empty())
  ------------------
  |  Branch (224:17): [True: 0, False: 0]
  |  Branch (224:17): [True: 0, False: 0]
  |  Branch (224:34): [True: 0, False: 0]
  ------------------
  225|      0|            {
  226|      0|                boost::throw_exception(required_option(display_opt));
  227|       |
  228|      0|            }
  229|      0|        }
  230|       |
  231|       |        // Lastly, run notify actions.
  232|  1.15k|        for (map<string, variable_value>::iterator k = begin();
  233|  13.8k|             k != end();
  ------------------
  |  Branch (233:14): [True: 12.6k, False: 1.15k]
  ------------------
  234|  12.6k|             ++k)
  235|  12.6k|        {
  236|       |            /* Users might wish to use variables_map to store their own values
  237|       |               that are not parsed, and therefore will not have value_semantics
  238|       |               defined. Do not crash on such values. In multi-module programs,
  239|       |               one module might add custom values, and the 'notify' function
  240|       |               will be called after that, so we check that value_sematics is
  241|       |               not NULL. See:
  242|       |                   https://svn.boost.org/trac/boost/ticket/2782
  243|       |            */
  244|  12.6k|            if (k->second.m_value_semantic)
  ------------------
  |  Branch (244:17): [True: 12.6k, False: 0]
  ------------------
  245|  12.6k|                k->second.m_value_semantic->notify(k->second.value());
  246|  12.6k|        }
  247|  1.15k|    }

_Z11set_optionsv:
   22|  2.11k|{
   23|  2.11k|    po::options_description opts;
   24|  2.11k|    opts.add_options()
   25|  2.11k|        ("global_string", po::value<string>())
   26|       |
   27|  2.11k|        ("strings.word", po::value<string>())
   28|  2.11k|        ("strings.phrase", po::value<string>())
   29|  2.11k|        ("strings.quoted", po::value<string>())
   30|       |
   31|  2.11k|        ("ints.positive", po::value<int>())
   32|  2.11k|        ("ints.negative", po::value<int>())
   33|  2.11k|        ("ints.hex", po::value<int>())
   34|  2.11k|        ("ints.oct", po::value<int>())
   35|  2.11k|        ("ints.bin", po::value<int>())
   36|       |
   37|  2.11k|        ("floats.positive", po::value<float>())
   38|  2.11k|        ("floats.negative", po::value<float>())
   39|  2.11k|        ("floats.double", po::value<double>())
   40|  2.11k|        ("floats.int", po::value<float>())
   41|  2.11k|        ("floats.int_dot", po::value<float>())
   42|  2.11k|        ("floats.dot", po::value<float>())
   43|  2.11k|        ("floats.exp_lower", po::value<float>())
   44|  2.11k|        ("floats.exp_upper", po::value<float>())
   45|  2.11k|        ("floats.exp_decimal", po::value<float>())
   46|  2.11k|        ("floats.exp_negative", po::value<float>())
   47|  2.11k|        ("floats.exp_negative_val", po::value<float>())
   48|  2.11k|        ("floats.exp_negative_negative_val", po::value<float>())
   49|       |
   50|  2.11k|        ("booleans.number_true", po::bool_switch())
   51|  2.11k|        ("booleans.number_false", po::bool_switch())
   52|  2.11k|        ("booleans.yn_true", po::bool_switch())
   53|  2.11k|        ("booleans.yn_false", po::bool_switch())
   54|  2.11k|        ("booleans.tf_true", po::bool_switch())
   55|  2.11k|        ("booleans.tf_false", po::bool_switch())
   56|  2.11k|        ("booleans.onoff_true", po::bool_switch())
   57|  2.11k|        ("booleans.onoff_false", po::bool_switch())
   58|  2.11k|        ("booleans.present_equal_true", po::bool_switch())
   59|  2.11k|       ("booleans.present_no_equal_true", po::bool_switch())
   60|  2.11k|       ;
   61|  2.11k|    return opts;
   62|  2.11k|}
LLVMFuzzerTestOneInput:
   65|  2.11k|{
   66|  2.11k|    try {
   67|  2.11k|        FuzzedDataProvider fdp(data, size);
   68|  2.11k|        auto opts = set_options();
   69|  2.11k|        po::variables_map vars;
   70|  2.11k|        stringstream st(fdp.ConsumeRemainingBytesAsString());
   71|       |
   72|  2.11k|        const bool ALLOW_UNREGISTERED = true;
   73|       |
   74|  2.11k|        po::parsed_options parsed = parse_config_file(st, opts, ALLOW_UNREGISTERED);
   75|  2.11k|        store(parsed, vars);
   76|  2.11k|        vector<string> unregistered = po::collect_unrecognized(parsed.options, po::exclude_positional);
   77|  2.11k|        notify(vars);
   78|  2.11k|    } catch(...) {
   79|    960|    }
   80|  2.11k|    return 0;
   81|  2.11k|}