LLVMFuzzerTestOneInput:
   78|  1.00k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
   79|  1.00k|    FuzzedDataProvider fdp(data, size);
   80|       |    // Ensure that settings are reset between each fuzzing iteration.
   81|  1.00k|    SavedSettings saved_settings;
   82|       |
   83|  1.00k|    constexpr size_t kMaxValues = 1024;
   84|  1.00k|    auto length = fdp.ConsumeIntegralInRange<size_t>(0, kMaxValues);
   85|  1.00k|    std::vector<AmericanOptionData> values;
   86|  1.00k|    values.reserve(length);
   87|   519k|    for (size_t i = 0; i < length; i++) {
  ------------------
  |  Branch (87:24): [True: 518k, False: 1.00k]
  ------------------
   88|   518k|        values.push_back(fuzzedAmericanOptionData(fdp));
   89|   518k|    }
   90|       |
   91|  1.00k|    Date today(2, March, 2020);
   92|  1.00k|    DayCounter dc = Actual360();
   93|  1.00k|    ext::shared_ptr<SimpleQuote> spot(new SimpleQuote(0.0));
   94|  1.00k|    ext::shared_ptr<SimpleQuote> qRate(new SimpleQuote(0.0));
   95|       |
   96|  1.00k|    ext::shared_ptr<YieldTermStructure> qTS =
   97|  1.00k|        ext::shared_ptr<YieldTermStructure>(new FlatForward(today, Handle<Quote>(qRate), dc));
   98|  1.00k|    ext::shared_ptr<SimpleQuote> rRate(new SimpleQuote(0.0));
   99|  1.00k|    ext::shared_ptr<YieldTermStructure> rTS =
  100|  1.00k|        ext::shared_ptr<YieldTermStructure>(new FlatForward(today, Handle<Quote>(rRate), dc));
  101|  1.00k|    ext::shared_ptr<SimpleQuote> vol(new SimpleQuote(0.0));
  102|  1.00k|    ext::shared_ptr<BlackVolTermStructure> volTS = ext::shared_ptr<BlackVolTermStructure>(
  103|  1.00k|        new BlackConstantVol(today, NullCalendar(), Handle<Quote>(vol), dc));
  104|       |
  105|  1.00k|    ext::shared_ptr<BlackScholesMertonProcess> stochProcess(new BlackScholesMertonProcess(
  106|  1.00k|            Handle<Quote>(spot), Handle<YieldTermStructure>(qTS), Handle<YieldTermStructure>(rTS),
  107|  1.00k|            Handle<BlackVolTermStructure>(volTS)));
  108|       |
  109|  1.00k|    ext::shared_ptr<PricingEngine> engine(
  110|  1.00k|        new BaroneAdesiWhaleyApproximationEngine(stochProcess));
  111|       |
  112|   518k|    for (auto& value : values) {
  ------------------
  |  Branch (112:22): [True: 518k, False: 1.00k]
  ------------------
  113|       |
  114|   518k|        ext::shared_ptr<StrikedTypePayoff> payoff(new PlainVanillaPayoff(value.type, value.strike));
  115|   518k|        Date exDate = today + Integer(std::lround(365*value.t));
  116|   518k|        ext::shared_ptr<Exercise> exercise(new AmericanExercise(today, exDate));
  117|       |
  118|   518k|        spot->setValue(value.s);
  119|   518k|        qRate->setValue(value.q);
  120|   518k|        rRate->setValue(value.r);
  121|   518k|        vol->setValue(value.v);
  122|       |
  123|   518k|        VanillaOption option(payoff, exercise);
  124|   518k|        option.setPricingEngine(engine);
  125|       |
  126|   518k|        (void)option.NPV();
  127|       |
  128|   518k|    }
  129|       |
  130|  1.00k|    return 0;
  131|  1.00k|}
fuzzamericanoption.cpp:_Z24fuzzedAmericanOptionDataR18FuzzedDataProvider:
   66|   518k|AmericanOptionData fuzzedAmericanOptionData(FuzzedDataProvider& fdp) {
   67|   518k|    return AmericanOptionData{
   68|   518k|        .type = fdp.PickValueInArray({Option::Type::Put, Option::Type::Call}),
   69|   518k|        .strike = fdp.ConsumeFloatingPoint<Real>(),
   70|   518k|        .s = fdp.ConsumeFloatingPointInRange<Real>(0.0, std::numeric_limits<Real>::max()),
   71|   518k|        .q = fdp.ConsumeProbability<Rate>(),
   72|   518k|        .r = fdp.ConsumeProbability<Rate>(),
   73|   518k|        .t = fdp.ConsumeFloatingPointInRange<Time>(0.0, std::numeric_limits<Real>::max()),
   74|   518k|        .v = fdp.ConsumeFloatingPointInRange<Volatility>(0.0, 10.0),
   75|   518k|    };
   76|   518k|}

_ZNK8QuantLib5Event11hasOccurredERKNS_4DateENSt3__18optionalIbEE:
   29|   518k|                            ext::optional<bool> includeRefDate) const {
   30|   518k|        Date refDate =
   31|   518k|            d != Date() ? d : Settings::instance().evaluationDate();
  ------------------
  |  Branch (31:13): [True: 0, False: 518k]
  ------------------
   32|   518k|        bool includeRefDateEvent = includeRefDate ? // NOLINT(readability-implicit-bool-conversion)
  ------------------
  |  Branch (32:36): [True: 0, False: 518k]
  ------------------
   33|      0|                                       *includeRefDate :
   34|   518k|                                       Settings::instance().includeReferenceDateEvents();
   35|   518k|        if (includeRefDateEvent)
  ------------------
  |  Branch (35:13): [True: 0, False: 518k]
  ------------------
   36|      0|            return date() < refDate;
   37|   518k|        else
   38|   518k|            return date() <= refDate;
   39|   518k|    }

_ZNK8QuantLib6detail12simple_event4dateEv:
   72|   518k|            Date date() const override { return date_; }
_ZN8QuantLib5EventD2Ev:
   42|   518k|        ~Event() override = default;
_ZN8QuantLib6detail12simple_eventC1ERKNS_4DateE:
   71|   518k|            explicit simple_event(const Date& date) : date_(date) {}

_ZNK8QuantLib8Exercise8lastDateEv:
   28|   518k|    Date Exercise::lastDate() const {
   29|   518k|        QL_REQUIRE(!dates_.empty(), "no exercise date given");
  ------------------
  |  |  117|   518k|#define QL_REQUIRE(condition,message) \
  |  |  ------------------
  |  |  |  |   73|   518k|#define QL_MULTILINE_ASSERTION_BEGIN do {
  |  |  ------------------
  |  |  118|   518k|QL_MULTILINE_ASSERTION_BEGIN \
  |  |  119|   518k|if (!(condition)) { \
  |  |  ------------------
  |  |  |  Branch (119:5): [True: 0, False: 518k]
  |  |  ------------------
  |  |  120|      0|    std::ostringstream _ql_msg_stream; \
  |  |  121|      0|    _ql_msg_stream << message; \
  |  |  122|      0|    throw QuantLib::Error(__FILE__,__LINE__, \
  |  |  123|      0|                          BOOST_CURRENT_FUNCTION,_ql_msg_stream.str()); \
  |  |  124|   518k|} \
  |  |  ------------------
  |  |  |  |   85|   518k|    #define QL_MULTILINE_ASSERTION_END } while(false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (85:48): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  125|   518k|QL_MULTILINE_ASSERTION_END
  ------------------
   30|   518k|        return dates_.back();
   31|   518k|    }
_ZN8QuantLib16AmericanExerciseC2ERKNS_4DateES3_b:
   36|   518k|    : EarlyExercise(American, payoffAtExpiry) {
   37|   518k|        QL_REQUIRE(earliest<=latest,
  ------------------
  |  |  117|   518k|#define QL_REQUIRE(condition,message) \
  |  |  ------------------
  |  |  |  |   73|   518k|#define QL_MULTILINE_ASSERTION_BEGIN do {
  |  |  ------------------
  |  |  118|   518k|QL_MULTILINE_ASSERTION_BEGIN \
  |  |  119|   518k|if (!(condition)) { \
  |  |  ------------------
  |  |  |  Branch (119:5): [True: 0, False: 518k]
  |  |  ------------------
  |  |  120|      0|    std::ostringstream _ql_msg_stream; \
  |  |  121|      0|    _ql_msg_stream << message; \
  |  |  122|      0|    throw QuantLib::Error(__FILE__,__LINE__, \
  |  |  123|      0|                          BOOST_CURRENT_FUNCTION,_ql_msg_stream.str()); \
  |  |  124|   518k|} \
  |  |  ------------------
  |  |  |  |   85|   518k|    #define QL_MULTILINE_ASSERTION_END } while(false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (85:48): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  125|   518k|QL_MULTILINE_ASSERTION_END
  ------------------
   38|   518k|                   "earliest > latest exercise date");
   39|   518k|        dates_ = std::vector<Date>(2);
   40|   518k|        dates_[0] = earliest;
   41|   518k|        dates_[1] = latest;
   42|   518k|    }

_ZN8QuantLib8ExerciseC2ENS0_4TypeE:
   41|   518k|        explicit Exercise(Type type) : type_(type) {}
_ZN8QuantLib13EarlyExerciseC2ENS_8Exercise4TypeEb:
   61|   518k|        : Exercise(type), payoffAtExpiry_(payoffAtExpiry) {}
_ZN8QuantLib8ExerciseD2Ev:
   42|   518k|        virtual ~Exercise() = default;

_ZNK8QuantLib6HandleINS_5QuoteEEcvN5boost10shared_ptrINS_10ObservableEEEEv:
  186|  4.03k|    inline Handle<T>::operator ext::shared_ptr<Observable>() const {
  187|  4.03k|        return link_;
  188|  4.03k|    }
_ZN8QuantLib6HandleINS_5QuoteEEC2EON5boost10shared_ptrIS1_EEb:
   85|  4.03k|        : link_(new Link(std::move(p), registerAsObserver)) {}
_ZN8QuantLib6HandleINS_5QuoteEE4LinkC2EON5boost10shared_ptrIS1_EEb:
  143|  4.03k|    inline Handle<T>::Link::Link(ext::shared_ptr<T>&& h, bool registerAsObserver) {
  144|  4.03k|        linkTo(std::move(h), registerAsObserver);
  145|  4.03k|    }
_ZN8QuantLib6HandleINS_5QuoteEE4Link6linkToEN5boost10shared_ptrIS1_EEb:
  149|  4.03k|                                        bool registerAsObserver) {
  150|  4.03k|        if ((h != h_) || (isObserver_ != registerAsObserver)) {
  ------------------
  |  Branch (150:13): [True: 4.03k, False: 0]
  |  Branch (150:26): [True: 0, False: 0]
  ------------------
  151|  4.03k|            if (h_ && isObserver_)
  ------------------
  |  Branch (151:17): [True: 0, False: 4.03k]
  |  Branch (151:23): [True: 0, False: 0]
  ------------------
  152|      0|                unregisterWith(h_);
  153|  4.03k|            h_ = std::move(h);
  154|  4.03k|            isObserver_ = registerAsObserver;
  155|  4.03k|            if (h_ && isObserver_)
  ------------------
  |  Branch (155:17): [True: 4.03k, False: 0]
  |  Branch (155:23): [True: 4.03k, False: 0]
  ------------------
  156|  4.03k|                registerWith(h_);
  157|  4.03k|            notifyObservers();
  158|  4.03k|        }
  159|  4.03k|    }
_ZN8QuantLib6HandleINS_5QuoteEE4Link6updateEv:
   53|   824k|            void update() override { notifyObservers(); }
_ZN8QuantLib6HandleINS_18YieldTermStructureEEC2ERKN5boost10shared_ptrIS1_EEb:
   82|  2.01k|        : link_(new Link(p, registerAsObserver)) {}
_ZN8QuantLib6HandleINS_18YieldTermStructureEE4LinkC2ERKN5boost10shared_ptrIS1_EEb:
  138|  2.01k|    inline Handle<T>::Link::Link(const ext::shared_ptr<T>& h, bool registerAsObserver) {
  139|  2.01k|        linkTo(h, registerAsObserver);
  140|  2.01k|    }
_ZN8QuantLib6HandleINS_18YieldTermStructureEE4Link6linkToEN5boost10shared_ptrIS1_EEb:
  149|  2.01k|                                        bool registerAsObserver) {
  150|  2.01k|        if ((h != h_) || (isObserver_ != registerAsObserver)) {
  ------------------
  |  Branch (150:13): [True: 2.01k, False: 0]
  |  Branch (150:26): [True: 0, False: 0]
  ------------------
  151|  2.01k|            if (h_ && isObserver_)
  ------------------
  |  Branch (151:17): [True: 0, False: 2.01k]
  |  Branch (151:23): [True: 0, False: 0]
  ------------------
  152|      0|                unregisterWith(h_);
  153|  2.01k|            h_ = std::move(h);
  154|  2.01k|            isObserver_ = registerAsObserver;
  155|  2.01k|            if (h_ && isObserver_)
  ------------------
  |  Branch (155:17): [True: 2.01k, False: 0]
  |  Branch (155:23): [True: 2.01k, False: 0]
  ------------------
  156|  2.01k|                registerWith(h_);
  157|  2.01k|            notifyObservers();
  158|  2.01k|        }
  159|  2.01k|    }
_ZN8QuantLib6HandleINS_18YieldTermStructureEE4Link6updateEv:
   53|   412k|            void update() override { notifyObservers(); }
_ZN8QuantLib6HandleINS_21BlackVolTermStructureEEC2ERKN5boost10shared_ptrIS1_EEb:
   82|  1.00k|        : link_(new Link(p, registerAsObserver)) {}
_ZN8QuantLib6HandleINS_21BlackVolTermStructureEE4LinkC2ERKN5boost10shared_ptrIS1_EEb:
  138|  1.00k|    inline Handle<T>::Link::Link(const ext::shared_ptr<T>& h, bool registerAsObserver) {
  139|  1.00k|        linkTo(h, registerAsObserver);
  140|  1.00k|    }
_ZN8QuantLib6HandleINS_21BlackVolTermStructureEE4Link6linkToEN5boost10shared_ptrIS1_EEb:
  149|  1.00k|                                        bool registerAsObserver) {
  150|  1.00k|        if ((h != h_) || (isObserver_ != registerAsObserver)) {
  ------------------
  |  Branch (150:13): [True: 1.00k, False: 0]
  |  Branch (150:26): [True: 0, False: 0]
  ------------------
  151|  1.00k|            if (h_ && isObserver_)
  ------------------
  |  Branch (151:17): [True: 0, False: 1.00k]
  |  Branch (151:23): [True: 0, False: 0]
  ------------------
  152|      0|                unregisterWith(h_);
  153|  1.00k|            h_ = std::move(h);
  154|  1.00k|            isObserver_ = registerAsObserver;
  155|  1.00k|            if (h_ && isObserver_)
  ------------------
  |  Branch (155:17): [True: 1.00k, False: 0]
  |  Branch (155:23): [True: 1.00k, False: 0]
  ------------------
  156|  1.00k|                registerWith(h_);
  157|  1.00k|            notifyObservers();
  158|  1.00k|        }
  159|  1.00k|    }
_ZN8QuantLib6HandleINS_21BlackVolTermStructureEE4Link6updateEv:
   53|   206k|            void update() override { notifyObservers(); }
_ZNK8QuantLib6HandleINS_18YieldTermStructureEEcvN5boost10shared_ptrINS_10ObservableEEEEv:
  186|  2.01k|    inline Handle<T>::operator ext::shared_ptr<Observable>() const {
  187|  2.01k|        return link_;
  188|  2.01k|    }
_ZNK8QuantLib6HandleINS_21BlackVolTermStructureEEcvN5boost10shared_ptrINS_10ObservableEEEEv:
  186|  1.00k|    inline Handle<T>::operator ext::shared_ptr<Observable>() const {
  187|  1.00k|        return link_;
  188|  1.00k|    }
_ZN8QuantLib16RelinkableHandleINS_21LocalVolTermStructureEEC2Ev:
  120|  1.00k|        : RelinkableHandle(ext::shared_ptr<T>()) {}
_ZN8QuantLib16RelinkableHandleINS_21LocalVolTermStructureEEC2EON5boost10shared_ptrIS1_EEb:
  199|  1.00k|    : Handle<T>(std::move(p), registerAsObserver) {}
_ZN8QuantLib6HandleINS_21LocalVolTermStructureEEC2EON5boost10shared_ptrIS1_EEb:
   85|  2.01k|        : link_(new Link(std::move(p), registerAsObserver)) {}
_ZN8QuantLib6HandleINS_21LocalVolTermStructureEE4LinkC2EON5boost10shared_ptrIS1_EEb:
  143|  2.01k|    inline Handle<T>::Link::Link(ext::shared_ptr<T>&& h, bool registerAsObserver) {
  144|  2.01k|        linkTo(std::move(h), registerAsObserver);
  145|  2.01k|    }
_ZN8QuantLib6HandleINS_21LocalVolTermStructureEE4Link6linkToEN5boost10shared_ptrIS1_EEb:
  149|  2.01k|                                        bool registerAsObserver) {
  150|  2.01k|        if ((h != h_) || (isObserver_ != registerAsObserver)) {
  ------------------
  |  Branch (150:13): [True: 0, False: 2.01k]
  |  Branch (150:26): [True: 2.01k, False: 0]
  ------------------
  151|  2.01k|            if (h_ && isObserver_)
  ------------------
  |  Branch (151:17): [True: 0, False: 2.01k]
  |  Branch (151:23): [True: 0, False: 0]
  ------------------
  152|      0|                unregisterWith(h_);
  153|  2.01k|            h_ = std::move(h);
  154|  2.01k|            isObserver_ = registerAsObserver;
  155|  2.01k|            if (h_ && isObserver_)
  ------------------
  |  Branch (155:17): [True: 0, False: 2.01k]
  |  Branch (155:23): [True: 0, False: 0]
  ------------------
  156|      0|                registerWith(h_);
  157|  2.01k|            notifyObservers();
  158|  2.01k|        }
  159|  2.01k|    }
_ZN8QuantLib6HandleINS_21LocalVolTermStructureEEC2Ev:
   79|  1.00k|        : Handle(ext::shared_ptr<T>()) {}

_ZN8QuantLib10InstrumentC2Ev:
   27|   518k|    : NPV_(Null<Real>()), errorEstimate_(Null<Real>()) {
   28|       |        // this makes sense in general (if the evaluation date
   29|       |        // changes, you probably want to recalculate) and can also
   30|       |        // help avoid some edge cases when lazy objects only forward
   31|       |        // their first notification.
   32|   518k|        registerWith(Settings::instance().evaluationDate());
   33|   518k|    }
_ZN8QuantLib10Instrument16setPricingEngineERKN5boost10shared_ptrINS_13PricingEngineEEE:
   35|   518k|    void Instrument::setPricingEngine(const ext::shared_ptr<PricingEngine>& e) {
   36|   518k|        if (engine_ != nullptr)
  ------------------
  |  Branch (36:13): [True: 0, False: 518k]
  ------------------
   37|      0|            unregisterWith(engine_);
   38|   518k|        engine_ = e;
   39|   518k|        if (engine_ != nullptr)
  ------------------
  |  Branch (39:13): [True: 518k, False: 0]
  ------------------
   40|   518k|            registerWith(engine_);
   41|       |        // trigger (lazy) recalculation and notify observers
   42|   518k|        update();
   43|   518k|    }

_ZNK8QuantLib10Instrument3NPVEv:
  167|   518k|    inline Real Instrument::NPV() const {
  168|   518k|        calculate();
  169|   518k|        QL_REQUIRE(NPV_ != Null<Real>(), "NPV not provided");
  ------------------
  |  |  117|   518k|#define QL_REQUIRE(condition,message) \
  |  |  ------------------
  |  |  |  |   73|   518k|#define QL_MULTILINE_ASSERTION_BEGIN do {
  |  |  ------------------
  |  |  118|   518k|QL_MULTILINE_ASSERTION_BEGIN \
  |  |  119|   518k|if (!(condition)) { \
  |  |  ------------------
  |  |  |  Branch (119:5): [True: 0, False: 518k]
  |  |  ------------------
  |  |  120|      0|    std::ostringstream _ql_msg_stream; \
  |  |  121|      0|    _ql_msg_stream << message; \
  |  |  122|      0|    throw QuantLib::Error(__FILE__,__LINE__, \
  |  |  123|      0|                          BOOST_CURRENT_FUNCTION,_ql_msg_stream.str()); \
  |  |  124|   518k|} \
  |  |  ------------------
  |  |  |  |   85|   518k|    #define QL_MULTILINE_ASSERTION_END } while(false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (85:48): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  125|   518k|QL_MULTILINE_ASSERTION_END
  ------------------
  170|   518k|        return NPV_;
  171|   518k|    }
_ZNK8QuantLib10Instrument9calculateEv:
  129|   518k|    inline void Instrument::calculate() const {
  130|   518k|        if (!calculated_) {
  ------------------
  |  Branch (130:13): [True: 518k, False: 0]
  ------------------
  131|   518k|            if (isExpired()) {
  ------------------
  |  Branch (131:17): [True: 518k, False: 0]
  ------------------
  132|   518k|                setupExpired();
  133|   518k|                calculated_ = true;
  134|   518k|            } else {
  135|      0|                LazyObject::calculate();
  136|      0|            }
  137|   518k|        }
  138|   518k|    }
_ZNK8QuantLib10Instrument12setupExpiredEv:
  140|   518k|    inline void Instrument::setupExpired() const {
  141|   518k|        NPV_ = errorEstimate_ = 0.0;
  142|   518k|        valuationDate_ = Date();
  143|   518k|        additionalResults_.clear();
  144|   518k|    }

_ZN8QuantLib14OneAssetOptionC2ERKN5boost10shared_ptrINS_6PayoffEEERKNS2_INS_8ExerciseEEE:
   31|   518k|    : Option(payoff, exercise) {}
_ZNK8QuantLib14OneAssetOption9isExpiredEv:
   33|   518k|    bool OneAssetOption::isExpired() const {
   34|   518k|        return detail::simple_event(exercise_->lastDate()).hasOccurred();
   35|   518k|    }
_ZNK8QuantLib14OneAssetOption12setupExpiredEv:
  106|   518k|    void OneAssetOption::setupExpired() const {
  107|   518k|        Option::setupExpired();
  108|   518k|        delta_ = deltaForward_ = elasticity_ = gamma_ = theta_ =
  109|   518k|            thetaPerDay_ = vega_ = rho_ = dividendRho_ =
  110|   518k|            strikeSensitivity_ = itmCashProbability_ = 0.0;
  111|   518k|    }

_ZN8QuantLib18PlainVanillaPayoffC2ENS_6Option4TypeEd:
  109|   518k|        : StrikedTypePayoff(type, strike) {}
_ZN8QuantLib17StrikedTypePayoffC2ENS_6Option4TypeEd:
  100|   518k|        : TypePayoff(type), strike_(strike) {}
_ZN8QuantLib10TypePayoffC2ENS_6Option4TypeE:
   57|   518k|        explicit TypePayoff(Option::Type type) : type_(type) {}

_ZN8QuantLib13VanillaOptionC1ERKN5boost10shared_ptrINS_17StrikedTypePayoffEEERKNS2_INS_8ExerciseEEE:
   35|   518k|    : OneAssetOption(payoff, exercise) {}

_ZN8QuantLib12InterestRateC2Ev:
   31|  2.01k|    : r_(Null<Real>()) {}

_ZN8QuantLib28CumulativeNormalDistributionC2Edd:
  289|      8|    : average_(average), sigma_(sigma) {
  290|       |
  291|      8|        QL_REQUIRE(sigma_>0.0,
  ------------------
  |  |  117|      8|#define QL_REQUIRE(condition,message) \
  |  |  ------------------
  |  |  |  |   73|      8|#define QL_MULTILINE_ASSERTION_BEGIN do {
  |  |  ------------------
  |  |  118|      8|QL_MULTILINE_ASSERTION_BEGIN \
  |  |  119|      8|if (!(condition)) { \
  |  |  ------------------
  |  |  |  Branch (119:5): [True: 0, False: 8]
  |  |  ------------------
  |  |  120|      0|    std::ostringstream _ql_msg_stream; \
  |  |  121|      0|    _ql_msg_stream << message; \
  |  |  122|      0|    throw QuantLib::Error(__FILE__,__LINE__, \
  |  |  123|      0|                          BOOST_CURRENT_FUNCTION,_ql_msg_stream.str()); \
  |  |  124|      8|} \
  |  |  ------------------
  |  |  |  |   85|      8|    #define QL_MULTILINE_ASSERTION_END } while(false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (85:48): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  125|      8|QL_MULTILINE_ASSERTION_END
  ------------------
  292|      8|                   "sigma must be greater than 0.0 ("
  293|      8|                   << sigma_ << " not allowed)");
  294|      8|    }
_ZN8QuantLib18NormalDistributionC2Edd:
  264|     10|    : average_(average), sigma_(sigma) {
  265|       |
  266|     10|        QL_REQUIRE(sigma_>0.0,
  ------------------
  |  |  117|     10|#define QL_REQUIRE(condition,message) \
  |  |  ------------------
  |  |  |  |   73|     10|#define QL_MULTILINE_ASSERTION_BEGIN do {
  |  |  ------------------
  |  |  118|     10|QL_MULTILINE_ASSERTION_BEGIN \
  |  |  119|     10|if (!(condition)) { \
  |  |  ------------------
  |  |  |  Branch (119:5): [True: 0, False: 10]
  |  |  ------------------
  |  |  120|      0|    std::ostringstream _ql_msg_stream; \
  |  |  121|      0|    _ql_msg_stream << message; \
  |  |  122|      0|    throw QuantLib::Error(__FILE__,__LINE__, \
  |  |  123|      0|                          BOOST_CURRENT_FUNCTION,_ql_msg_stream.str()); \
  |  |  124|     10|} \
  |  |  ------------------
  |  |  |  |   85|     10|    #define QL_MULTILINE_ASSERTION_END } while(false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (85:48): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  125|     10|QL_MULTILINE_ASSERTION_END
  ------------------
  267|     10|                   "sigma must be greater than 0.0 ("
  268|     10|                   << sigma_ << " not allowed)");
  269|       |
  270|     10|        normalizationFactor_ = M_SQRT_2*M_1_SQRTPI/sigma_;
  ------------------
  |  |   98|     10|    #define M_SQRT_2    0.7071067811865475244008443621048490392848359376887
  ------------------
                      normalizationFactor_ = M_SQRT_2*M_1_SQRTPI/sigma_;
  ------------------
  |  |   86|     10|    #define M_1_SQRTPI  0.564189583547756286948
  ------------------
  271|     10|        derNormalizationFactor_ = sigma_*sigma_;
  272|     10|        denominator_ = 2.0*derNormalizationFactor_;
  273|     10|    }

_ZN8QuantLib12ExtrapolatorD2Ev:
   35|  3.02k|        virtual ~Extrapolator() = default;
_ZN8QuantLib12ExtrapolatorC2Ev:
   34|  3.02k|        Extrapolator() = default;

_ZN8QuantLib6OptionC2EN5boost10shared_ptrINS_6PayoffEEENS2_INS_8ExerciseEEE:
   43|   518k|        : payoff_(std::move(payoff)), exercise_(std::move(exercise)) {}
_ZN8QuantLib6Option9argumentsC1Ev:
   59|  1.00k|        arguments() = default;

_ZN8QuantLib10LazyObject6updateEv:
  188|   931k|    inline void LazyObject::update() {
  189|   931k|        if (updating_) {
  ------------------
  |  Branch (189:13): [True: 0, False: 931k]
  ------------------
  190|       |            #ifdef QL_THROW_IN_CYCLES
  191|       |            QL_FAIL("recursive notification loop detected; you probably created an object cycle");
  192|       |            #else
  193|      0|            return;
  194|      0|            #endif
  195|      0|        }
  196|       |
  197|       |        // This sets updating to true (so the above check breaks the
  198|       |        // infinite loop if we enter this method recursively) and will
  199|       |        // set it back to false when we exit this scope, either
  200|       |        // successfully or because of an exception.
  201|   931k|        UpdateChecker checker(this);
  202|       |
  203|       |        // forwards notifications only the first time
  204|   931k|        if (calculated_ || alwaysForward_) {
  ------------------
  |  Branch (204:13): [True: 0, False: 931k]
  |  Branch (204:28): [True: 0, False: 931k]
  ------------------
  205|       |            // set to false early
  206|       |            // 1) to prevent infinite recursion
  207|       |            // 2) otherways non-lazy observers would be served obsolete
  208|       |            //    data because of calculated_ being still true
  209|      0|            calculated_ = false;
  210|       |            // observers don't expect notifications from frozen objects
  211|      0|            if (!frozen_)
  ------------------
  |  Branch (211:17): [True: 0, False: 0]
  ------------------
  212|      0|                notifyObservers();
  213|       |                // exiting notifyObservers() calculated_ could be
  214|       |                // already true because of non-lazy observers
  215|      0|        }
  216|   931k|    }
_ZN8QuantLib10LazyObject13UpdateCheckerC2EPS0_:
  135|   931k|            explicit UpdateChecker(LazyObject* subject) : subject_(subject) {
  136|   931k|                subject_->updating_ = true;
  137|   931k|            }
_ZN8QuantLib10LazyObject13UpdateCheckerD2Ev:
  138|   931k|            ~UpdateChecker() {
  139|   931k|                subject_->updating_ = false;
  140|   931k|            }
_ZN8QuantLib10LazyObjectD2Ev:
   38|   520k|        ~LazyObject() override = default;
_ZNK8QuantLib10LazyObject8Defaults24forwardsAllNotificationsEv:
  171|   520k|        bool forwardsAllNotifications() const {
  172|   520k|            return forwardsAllNotifications_;
  173|   520k|        }
_ZN8QuantLib10LazyObjectC2Ev:
  186|   520k|    : alwaysForward_(LazyObject::Defaults::instance().forwardsAllNotifications()) {}

_ZN8QuantLib10Observable15notifyObserversEv:
   56|  4.54M|    void Observable::notifyObservers() {
   57|  4.54M|        if (!ObservableSettings::instance().updatesEnabled()) {
  ------------------
  |  Branch (57:13): [True: 0, False: 4.54M]
  ------------------
   58|       |            // if updates are only deferred, flag this for later notification
   59|       |            // these are held centrally by the settings singleton
   60|      0|            ObservableSettings::instance().registerDeferredObservers(observers_);
   61|  4.54M|        } else if (!observers_.empty()) {
  ------------------
  |  Branch (61:20): [True: 3.71M, False: 833k]
  ------------------
   62|  3.71M|            bool successful = true;
   63|  3.71M|            std::string errMsg;
   64|  3.71M|            for (auto* observer : observers_) {
  ------------------
  |  Branch (64:33): [True: 3.71M, False: 3.71M]
  ------------------
   65|  3.71M|                try {
   66|  3.71M|                    observer->update();
   67|  3.71M|                } catch (std::exception& e) {
   68|       |                    // quite a dilemma. If we don't catch the exception,
   69|       |                    // other observers will not receive the notification
   70|       |                    // and might be left in an incorrect state. If we do
   71|       |                    // catch it and continue the loop (as we do here) we
   72|       |                    // lose the exception. The least evil might be to try
   73|       |                    // and notify all observers, while raising an
   74|       |                    // exception if something bad happened.
   75|      0|                    successful = false;
   76|      0|                    errMsg = e.what();
   77|      0|                } catch (...) {
   78|      0|                    successful = false;
   79|      0|                }
   80|  3.71M|            }
   81|  3.71M|            QL_ENSURE(successful,
  ------------------
  |  |  130|  3.71M|#define QL_ENSURE(condition,message) \
  |  |  ------------------
  |  |  |  |   73|  3.71M|#define QL_MULTILINE_ASSERTION_BEGIN do {
  |  |  ------------------
  |  |  131|  7.42M|QL_MULTILINE_ASSERTION_BEGIN \
  |  |  132|  7.42M|if (!(condition)) { \
  |  |  ------------------
  |  |  |  Branch (132:5): [True: 0, False: 3.71M]
  |  |  ------------------
  |  |  133|      0|    std::ostringstream _ql_msg_stream; \
  |  |  134|      0|    _ql_msg_stream << message; \
  |  |  135|      0|    throw QuantLib::Error(__FILE__,__LINE__, \
  |  |  136|      0|                          BOOST_CURRENT_FUNCTION,_ql_msg_stream.str()); \
  |  |  137|  3.71M|} \
  |  |  ------------------
  |  |  |  |   85|  3.71M|    #define QL_MULTILINE_ASSERTION_END } while(false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (85:48): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  138|  3.71M|QL_MULTILINE_ASSERTION_END
  ------------------
   82|  3.71M|                  "could not notify one or more observers: " << errMsg);
   83|  3.71M|        }
   84|  4.54M|    }

_ZN8QuantLib8ObserverD2Ev:
  220|   532k|    inline Observer::~Observer() {
  221|   532k|        for (const auto& observable : observables_)
  ------------------
  |  Branch (221:37): [True: 1.05M, False: 532k]
  ------------------
  222|  1.05M|            observable->unregisterObserver(this);
  223|   532k|    }
_ZN8QuantLib10Observable18unregisterObserverEPNS_8ObserverE:
  197|  1.05M|    inline Size Observable::unregisterObserver(Observer* o) {
  198|  1.05M|        if (ObservableSettings::instance().updatesDeferred())
  ------------------
  |  Branch (198:13): [True: 0, False: 1.05M]
  ------------------
  199|      0|            ObservableSettings::instance().unregisterDeferredObserver(o);
  200|       |
  201|  1.05M|        return observers_.erase(o);
  202|  1.05M|    }
_ZN8QuantLib18ObservableSettingsC2Ev:
  101|      1|        ObservableSettings() = default;
_ZNK8QuantLib18ObservableSettings15updatesDeferredEv:
   98|  1.05M|        bool updatesDeferred() const { return updatesDeferred_; }
_ZN8QuantLib10ObservableC2Ev:
   67|  1.05M|        Observable() = default;
_ZN8QuantLib10ObservableD2Ev:
   73|  1.05M|        virtual ~Observable() = default;
_ZN8QuantLib8ObserverC2Ev:
  123|   532k|        Observer() = default;
_ZN8QuantLib8Observer12registerWithERKN5boost10shared_ptrINS_10ObservableEEE:
  226|  1.05M|    Observer::registerWith(const ext::shared_ptr<Observable>& h) {
  227|  1.05M|        if (h != nullptr) {
  ------------------
  |  Branch (227:13): [True: 1.05M, False: 0]
  ------------------
  228|  1.05M|            h->registerObserver(this);
  229|  1.05M|            return observables_.insert(h);
  230|  1.05M|        }
  231|      0|        return std::make_pair(observables_.end(), false);
  232|  1.05M|    }
_ZN8QuantLib10Observable16registerObserverEPNS_8ObserverE:
  193|  1.05M|    Observable::registerObserver(Observer* o) {
  194|  1.05M|        return observers_.insert(o);
  195|  1.05M|    }
_ZNK8QuantLib18ObservableSettings14updatesEnabledEv:
   97|  4.54M|        bool updatesEnabled() const { return updatesEnabled_; }

_ZN8QuantLib9SingletonINS_18ObservableSettingsENSt3__117integral_constantIbLb0EEEE8instanceEv:
  104|  5.59M|    T& Singleton<T, Global>::instance() {
  105|  5.59M|        static T instance;
  106|  5.59M|        return instance;
  107|  5.59M|    }
_ZN8QuantLib9SingletonINS_8SettingsENSt3__117integral_constantIbLb0EEEE8instanceEv:
  104|  1.56M|    T& Singleton<T, Global>::instance() {
  105|  1.56M|        static T instance;
  106|  1.56M|        return instance;
  107|  1.56M|    }
_ZN8QuantLib9SingletonINS_10LazyObject8DefaultsENSt3__117integral_constantIbLb0EEEE8instanceEv:
  104|   520k|    T& Singleton<T, Global>::instance() {
  105|   520k|        static T instance;
  106|   520k|        return instance;
  107|   520k|    }

_ZN8QuantLib6PayoffD2Ev:
   38|   518k|        virtual ~Payoff() = default;

_ZN8QuantLib13PricingEngine9argumentsD2Ev:
   47|  1.00k|        virtual ~arguments() = default;
_ZN8QuantLib13PricingEngine7resultsD2Ev:
   53|  1.00k|        virtual ~results() = default;
_ZN8QuantLib13GenericEngineINS_6Option9argumentsENS_14OneAssetOption7resultsEE6updateEv:
   69|   824k|        void update() override { notifyObservers(); }

_ZN8QuantLib36BaroneAdesiWhaleyApproximationEngineC2EN5boost10shared_ptrINS_30GeneralizedBlackScholesProcessEEE:
   33|  1.00k|    : process_(std::move(process)) {
   34|  1.00k|        registerWith(process_);
   35|  1.00k|    }

_ZN8QuantLib30GeneralizedBlackScholesProcessC2ENS_6HandleINS_5QuoteEEENS1_INS_18YieldTermStructureEEES5_NS1_INS_21BlackVolTermStructureEEERKN5boost10shared_ptrINS_19StochasticProcess1D14discretizationEEEb:
   60|  1.00k|    : StochasticProcess1D(disc), x0_(std::move(x0)), riskFreeRate_(std::move(riskFreeTS)),
   61|  1.00k|      dividendYield_(std::move(dividendTS)), blackVolatility_(std::move(blackVolTS)),
   62|  1.00k|      forceDiscretization_(forceDiscretization), hasExternalLocalVol_(false), updated_(false),
   63|  1.00k|      isStrikeIndependent_(false) {
   64|  1.00k|        registerWith(x0_);
   65|  1.00k|        registerWith(riskFreeRate_);
   66|  1.00k|        registerWith(dividendYield_);
   67|  1.00k|        registerWith(blackVolatility_);
   68|  1.00k|    }
_ZN8QuantLib30GeneralizedBlackScholesProcess6updateEv:
  154|   824k|    void GeneralizedBlackScholesProcess::update() {
  155|   824k|        updated_ = false;
  156|   824k|        StochasticProcess1D::update();
  157|   824k|    }
_ZN8QuantLib25BlackScholesMertonProcessC2ERKNS_6HandleINS_5QuoteEEERKNS1_INS_18YieldTermStructureEEES9_RKNS1_INS_21BlackVolTermStructureEEERKN5boost10shared_ptrINS_19StochasticProcess1D14discretizationEEEb:
  252|  1.00k|    : GeneralizedBlackScholesProcess(x0,dividendTS,riskFreeTS,blackVolTS,d,
  253|  1.00k|                                     forceDiscretization) {}

_ZN8QuantLib5QuoteD2Ev:
   40|  4.03k|        ~Quote() override = default;

_ZN8QuantLib11SimpleQuoteC1Ed:
   61|  4.03k|    : value_(value) {}
_ZN8QuantLib11SimpleQuote8setValueEd:
   72|  2.07M|    inline Real SimpleQuote::setValue(Real value) {
   73|  2.07M|        Real diff = value-value_;
   74|  2.07M|        if (diff != 0.0) {
  ------------------
  |  Branch (74:13): [True: 824k, False: 1.25M]
  ------------------
   75|   824k|            value_ = value;
   76|   824k|            notifyObservers();
   77|   824k|        }
   78|  2.07M|        return diff;
   79|  2.07M|    }

_ZN8QuantLib8Settings9DateProxyC2Ev:
   27|      1|    : ObservableValue<Date>(Date()) {}
_ZN8QuantLib8SettingsC2Ev:
   34|      1|    Settings::Settings()
_ZN8QuantLib13SavedSettingsC2Ev:
   50|  1.00k|    : evaluationDate_(Settings::instance().evaluationDate()),
   51|  1.00k|      includeReferenceDateEvents_(Settings::instance().includeReferenceDateEvents()),
   52|  1.00k|      includeTodaysCashFlows_(Settings::instance().includeTodaysCashFlows()),
   53|  1.00k|      enforcesTodaysHistoricFixings_(Settings::instance().enforcesTodaysHistoricFixings()) {}
_ZN8QuantLib13SavedSettingsD2Ev:
   55|  1.00k|    SavedSettings::~SavedSettings() {
   56|  1.00k|        try {
   57|  1.00k|            if (Settings::instance().evaluationDate() != evaluationDate_)
  ------------------
  |  Branch (57:17): [True: 0, False: 1.00k]
  ------------------
   58|      0|                Settings::instance().evaluationDate() = evaluationDate_;
   59|  1.00k|            Settings::instance().includeReferenceDateEvents() =
   60|  1.00k|                includeReferenceDateEvents_;
   61|  1.00k|            Settings::instance().includeTodaysCashFlows() =
   62|  1.00k|                includeTodaysCashFlows_;
   63|  1.00k|            Settings::instance().enforcesTodaysHistoricFixings() =
   64|  1.00k|                enforcesTodaysHistoricFixings_;
   65|  1.00k|        } catch (...) {
   66|       |            // nothing we can do except bailing out.
   67|      0|        }
   68|  1.00k|    }

_ZN8QuantLib8Settings14evaluationDateEv:
  147|  1.03M|    inline Settings::DateProxy& Settings::evaluationDate() {
  148|  1.03M|        return evaluationDate_;
  149|  1.03M|    }
_ZNK8QuantLib8Settings9DateProxycvNS_4DateEEv:
  134|   520k|    inline Settings::DateProxy::operator Date() const {
  135|   520k|        if (value() == Date())
  ------------------
  |  Branch (135:13): [True: 520k, False: 0]
  ------------------
  136|   520k|            return Date::todaysDate();
  137|      0|        else
  138|      0|            return value();
  139|   520k|    }
_ZN8QuantLib8Settings22includeTodaysCashFlowsEv:
  163|  2.01k|    inline ext::optional<bool>& Settings::includeTodaysCashFlows() {
  164|  2.01k|        return includeTodaysCashFlows_;
  165|  2.01k|    }
_ZN8QuantLib8Settings26includeReferenceDateEventsEv:
  155|   520k|    inline bool& Settings::includeReferenceDateEvents() {
  156|   520k|        return includeReferenceDateEvents_;
  157|   520k|    }
_ZN8QuantLib8Settings29enforcesTodaysHistoricFixingsEv:
  171|  2.01k|    inline bool& Settings::enforcesTodaysHistoricFixings() {
  172|  2.01k|        return enforcesTodaysHistoricFixings_;
  173|  2.01k|    }

_ZN8QuantLib17StochasticProcess6updateEv:
   68|   824k|    void StochasticProcess::update() {
   69|   824k|        notifyObservers();
   70|   824k|    }
_ZN8QuantLib19StochasticProcess1DC2EN5boost10shared_ptrINS0_14discretizationEEE:
   76|  1.00k|    : discretization_(std::move(disc)) {}

_ZN8QuantLib17StochasticProcess14discretizationD2Ev:
   47|  1.00k|            virtual ~discretization() = default;
_ZN8QuantLib19StochasticProcess1D14discretizationD2Ev:
  168|  1.00k|            virtual ~discretization() = default;
_ZN8QuantLib17StochasticProcessD2Ev:
   61|  1.00k|        ~StochasticProcess() override = default;
_ZN8QuantLib17StochasticProcessC2Ev:
  151|  1.00k|        StochasticProcess() = default;

_ZN8QuantLib13TermStructureC2ERKNS_4DateENS_8CalendarENS_10DayCounterE:
   30|  3.02k|    : calendar_(std::move(cal)), referenceDate_(referenceDate), settlementDays_(Null<Natural>()),
   31|  3.02k|      dayCounter_(std::move(dc)) {}
_ZNK8QuantLib13TermStructure13referenceDateEv:
   39|   414k|    const Date& TermStructure::referenceDate() const {
   40|   414k|        if (!updated_) {
  ------------------
  |  Branch (40:13): [True: 0, False: 414k]
  ------------------
   41|      0|            Date today = Settings::instance().evaluationDate();
   42|      0|            referenceDate_ = calendar().advance(today, settlementDays(), Days);
   43|      0|            updated_ = true;
   44|      0|        }
   45|   414k|        return referenceDate_;
   46|   414k|    }
_ZN8QuantLib13TermStructure6updateEv:
   48|   618k|    void TermStructure::update() {
   49|   618k|        if (moving_)
  ------------------
  |  Branch (49:13): [True: 0, False: 618k]
  ------------------
   50|      0|            updated_ = false;
   51|   618k|        notifyObservers();
   52|   618k|    }

_ZN8QuantLib13TermStructureD2Ev:
   75|  3.02k|        ~TermStructure() override = default;

_ZN8QuantLib16BlackConstantVolC1ERKNS_4DateERKNS_8CalendarENS_6HandleINS_5QuoteEEERKNS_10DayCounterE:
   92|  1.00k|    : BlackVolatilityTermStructure(referenceDate, cal, Following, dc),
   93|  1.00k|      volatility_(std::move(volatility)) {
   94|  1.00k|        registerWith(volatility_);
   95|  1.00k|    }

_ZN8QuantLib21BlackVolTermStructureC2ERKNS_4DateERKNS_8CalendarENS_21BusinessDayConventionERKNS_10DayCounterE:
   32|  1.00k|    : VolatilityTermStructure(refDate, cal, bdc, dc) {}
_ZN8QuantLib28BlackVolatilityTermStructureC2ERKNS_4DateERKNS_8CalendarENS_21BusinessDayConventionERKNS_10DayCounterE:
  126|  1.00k|    : BlackVolTermStructure(refDate, cal, bdc, dc) {}

_ZN8QuantLib21BlackVolTermStructureD2Ev:
   65|  1.00k|        ~BlackVolTermStructure() override = default;

_ZN8QuantLib23VolatilityTermStructureC2ERKNS_4DateERKNS_8CalendarENS_21BusinessDayConventionERKNS_10DayCounterE:
   32|  1.00k|    : TermStructure(referenceDate, cal, dc), bdc_(bdc) {}

_ZN8QuantLib11FlatForwardC1ERKNS_4DateENS_6HandleINS_5QuoteEEERKNS_10DayCounterENS_11CompoundingENS_9FrequencyE:
   32|  2.01k|    : YieldTermStructure(referenceDate, Calendar(), dayCounter), forward_(std::move(forward)),
   33|  2.01k|      compounding_(compounding), frequency_(frequency) {
   34|  2.01k|        registerWith(forward_);
   35|  2.01k|    }

_ZN8QuantLib11FlatForward6updateEv:
   97|   412k|    inline void FlatForward::update() {
   98|   412k|        LazyObject::update();
   99|   412k|        YieldTermStructure::update();
  100|   412k|    }

_ZN8QuantLib18YieldTermStructureC2ERKNS_4DateERKNS_8CalendarERKNS_10DayCounterENSt3__16vectorINS_6HandleINS_5QuoteEEENSA_9allocatorISE_EEEERKNSB_IS1_NSF_IS1_EEEE:
   40|  2.01k|    : TermStructure(referenceDate, cal, dc), jumps_(std::move(jumps)), jumpDates_(jumpDates),
   41|  2.01k|      jumpTimes_(jumpDates.size()), nJumps_(jumps_.size()) {
   42|  2.01k|        setJumps(YieldTermStructure::referenceDate());
   43|  2.01k|        for (Size i=0; i<nJumps_; ++i)
  ------------------
  |  Branch (43:24): [True: 0, False: 2.01k]
  ------------------
   44|      0|            registerWith(jumps_[i]);
   45|  2.01k|    }
_ZN8QuantLib18YieldTermStructure8setJumpsERKNS_4DateE:
   59|  2.01k|    void YieldTermStructure::setJumps(const Date& referenceDate) {
   60|  2.01k|        if (jumpDates_.empty() && !jumps_.empty()) { // turn of year dates
  ------------------
  |  Branch (60:13): [True: 2.01k, False: 0]
  |  Branch (60:35): [True: 0, False: 2.01k]
  ------------------
   61|      0|            jumpDates_.resize(nJumps_);
   62|      0|            jumpTimes_.resize(nJumps_);
   63|      0|            Year y = referenceDate.year();
   64|      0|            for (Size i=0; i<nJumps_; ++i)
  ------------------
  |  Branch (64:28): [True: 0, False: 0]
  ------------------
   65|      0|                jumpDates_[i] = Date(31, December, y+i);
   66|  2.01k|        } else { // fixed dates
   67|  2.01k|            QL_REQUIRE(jumpDates_.size()==nJumps_,
  ------------------
  |  |  117|  2.01k|#define QL_REQUIRE(condition,message) \
  |  |  ------------------
  |  |  |  |   73|  2.01k|#define QL_MULTILINE_ASSERTION_BEGIN do {
  |  |  ------------------
  |  |  118|  2.01k|QL_MULTILINE_ASSERTION_BEGIN \
  |  |  119|  2.01k|if (!(condition)) { \
  |  |  ------------------
  |  |  |  Branch (119:5): [True: 0, False: 2.01k]
  |  |  ------------------
  |  |  120|      0|    std::ostringstream _ql_msg_stream; \
  |  |  121|      0|    _ql_msg_stream << message; \
  |  |  122|      0|    throw QuantLib::Error(__FILE__,__LINE__, \
  |  |  123|      0|                          BOOST_CURRENT_FUNCTION,_ql_msg_stream.str()); \
  |  |  124|  2.01k|} \
  |  |  ------------------
  |  |  |  |   85|  2.01k|    #define QL_MULTILINE_ASSERTION_END } while(false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (85:48): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  125|  2.01k|QL_MULTILINE_ASSERTION_END
  ------------------
   68|  2.01k|                       "mismatch between number of jumps (" << nJumps_ <<
   69|  2.01k|                       ") and jump dates (" << jumpDates_.size() << ")");
   70|  2.01k|        }
   71|  2.01k|        for (Size i=0; i<nJumps_; ++i)
  ------------------
  |  Branch (71:24): [True: 0, False: 2.01k]
  ------------------
   72|      0|            jumpTimes_[i] = timeFromReference(jumpDates_[i]);
   73|  2.01k|        latestReference_ = referenceDate;
   74|  2.01k|    }
_ZN8QuantLib18YieldTermStructure6updateEv:
  174|   412k|    void YieldTermStructure::update() {
  175|   412k|        TermStructure::update();
  176|   412k|        Date newReference = Date();
  177|   412k|        try {
  178|   412k|            newReference = referenceDate();
  179|   412k|            if (newReference != latestReference_)
  ------------------
  |  Branch (179:17): [True: 0, False: 412k]
  ------------------
  180|      0|                setJumps(newReference);
  181|   412k|        } catch (Error&) {
  182|      0|            if (newReference == Date()) {
  ------------------
  |  Branch (182:17): [True: 0, False: 0]
  ------------------
  183|       |                // the curve couldn't calculate the reference
  184|       |                // date. Most of the times, this is because some
  185|       |                // underlying handle wasn't set, so we can just absorb
  186|       |                // the exception and continue; the jumps will be set
  187|       |                // correctly when a valid underlying is set.
  188|      0|                return;
  189|      0|            } else {
  190|       |                // something else happened during the call to
  191|       |                // setJumps(), so we let the exception bubble up.
  192|      0|                throw;
  193|      0|            }
  194|      0|        }
  195|   412k|    }

_ZN8QuantLib8CalendarC2Ev:
   78|  3.02k|        Calendar() = default;
_ZN8QuantLib8Calendar4ImplD2Ev:
   66|  1.00k|            virtual ~Impl() = default;

_ZN8QuantLib12NullCalendarC2Ev:
   47|  1.00k|        NullCalendar() {
   48|  1.00k|            impl_ = ext::shared_ptr<Calendar::Impl>(new NullCalendar::Impl);
   49|  1.00k|        }

_ZN8QuantLib4DateC2Ev:
   59|  4.04M|    : serialNumber_(Date::serial_type(0)) {}
_ZN8QuantLib4DateC2El:
   62|   519k|    : serialNumber_(serialNumber) {
   63|   519k|        checkSerialNumber(serialNumber);
   64|   519k|    }
_ZN8QuantLib4DateC2EiNS_5MonthEi:
   66|   521k|    Date::Date(Day d, Month m, Year y) {
   67|   521k|        QL_REQUIRE(y > 1900 && y < 2200,
  ------------------
  |  |  117|   521k|#define QL_REQUIRE(condition,message) \
  |  |  ------------------
  |  |  |  |   73|   521k|#define QL_MULTILINE_ASSERTION_BEGIN do {
  |  |  ------------------
  |  |  118|   521k|QL_MULTILINE_ASSERTION_BEGIN \
  |  |  119|  1.04M|if (!(condition)) { \
  |  |  ------------------
  |  |  |  Branch (119:7): [True: 521k, False: 0]
  |  |  |  Branch (119:7): [True: 521k, False: 0]
  |  |  ------------------
  |  |  120|      0|    std::ostringstream _ql_msg_stream; \
  |  |  121|      0|    _ql_msg_stream << message; \
  |  |  122|      0|    throw QuantLib::Error(__FILE__,__LINE__, \
  |  |  123|      0|                          BOOST_CURRENT_FUNCTION,_ql_msg_stream.str()); \
  |  |  124|   521k|} \
  |  |  ------------------
  |  |  |  |   85|   521k|    #define QL_MULTILINE_ASSERTION_END } while(false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (85:48): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  125|   521k|QL_MULTILINE_ASSERTION_END
  ------------------
   68|   521k|                   "year " << y << " out of bound. It must be in [1901,2199]");
   69|   521k|        QL_REQUIRE(Integer(m) > 0 && Integer(m) < 13,
  ------------------
  |  |  117|   521k|#define QL_REQUIRE(condition,message) \
  |  |  ------------------
  |  |  |  |   73|   521k|#define QL_MULTILINE_ASSERTION_BEGIN do {
  |  |  ------------------
  |  |  118|  1.04M|QL_MULTILINE_ASSERTION_BEGIN \
  |  |  119|  1.04M|if (!(condition)) { \
  |  |  ------------------
  |  |  |  Branch (119:7): [True: 521k, False: 0]
  |  |  |  Branch (119:7): [True: 521k, False: 0]
  |  |  ------------------
  |  |  120|      0|    std::ostringstream _ql_msg_stream; \
  |  |  121|      0|    _ql_msg_stream << message; \
  |  |  122|      0|    throw QuantLib::Error(__FILE__,__LINE__, \
  |  |  123|      0|                          BOOST_CURRENT_FUNCTION,_ql_msg_stream.str()); \
  |  |  124|   521k|} \
  |  |  ------------------
  |  |  |  |   85|   521k|    #define QL_MULTILINE_ASSERTION_END } while(false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (85:48): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  125|   521k|QL_MULTILINE_ASSERTION_END
  ------------------
   70|   521k|                   "month " << Integer(m)
   71|   521k|                   << " outside January-December range [1,12]");
   72|       |
   73|   521k|        bool leap = isLeap(y);
   74|   521k|        Day len = monthLength(m,leap), offset = monthOffset(m,leap);
   75|   521k|        QL_REQUIRE(d <= len && d > 0,
  ------------------
  |  |  117|   521k|#define QL_REQUIRE(condition,message) \
  |  |  ------------------
  |  |  |  |   73|   521k|#define QL_MULTILINE_ASSERTION_BEGIN do {
  |  |  ------------------
  |  |  118|   521k|QL_MULTILINE_ASSERTION_BEGIN \
  |  |  119|  1.04M|if (!(condition)) { \
  |  |  ------------------
  |  |  |  Branch (119:7): [True: 521k, False: 0]
  |  |  |  Branch (119:7): [True: 521k, False: 0]
  |  |  ------------------
  |  |  120|      0|    std::ostringstream _ql_msg_stream; \
  |  |  121|      0|    _ql_msg_stream << message; \
  |  |  122|      0|    throw QuantLib::Error(__FILE__,__LINE__, \
  |  |  123|      0|                          BOOST_CURRENT_FUNCTION,_ql_msg_stream.str()); \
  |  |  124|   521k|} \
  |  |  ------------------
  |  |  |  |   85|   521k|    #define QL_MULTILINE_ASSERTION_END } while(false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (85:48): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  125|   521k|QL_MULTILINE_ASSERTION_END
  ------------------
   76|   521k|                   "day outside month (" << Integer(m) << ") day-range "
   77|   521k|                   << "[1," << len << "]");
   78|       |
   79|   521k|        serialNumber_ = d + offset + yearOffset(y);
   80|   521k|    }
_ZN8QuantLib4Date6isLeapEi:
  187|   521k|    bool Date::isLeap(Year y) {
  188|   521k|        static const bool YearIsLeap[] = {
  189|       |            // 1900 is leap in agreement with Excel's bug
  190|       |            // 1900 is out of valid date range anyway
  191|       |            // 1900-1909
  192|   521k|             true,false,false,false, true,false,false,false, true,false,
  193|       |            // 1910-1919
  194|   521k|            false,false, true,false,false,false, true,false,false,false,
  195|       |            // 1920-1929
  196|   521k|             true,false,false,false, true,false,false,false, true,false,
  197|       |            // 1930-1939
  198|   521k|            false,false, true,false,false,false, true,false,false,false,
  199|       |            // 1940-1949
  200|   521k|             true,false,false,false, true,false,false,false, true,false,
  201|       |            // 1950-1959
  202|   521k|            false,false, true,false,false,false, true,false,false,false,
  203|       |            // 1960-1969
  204|   521k|             true,false,false,false, true,false,false,false, true,false,
  205|       |            // 1970-1979
  206|   521k|            false,false, true,false,false,false, true,false,false,false,
  207|       |            // 1980-1989
  208|   521k|             true,false,false,false, true,false,false,false, true,false,
  209|       |            // 1990-1999
  210|   521k|            false,false, true,false,false,false, true,false,false,false,
  211|       |            // 2000-2009
  212|   521k|             true,false,false,false, true,false,false,false, true,false,
  213|       |            // 2010-2019
  214|   521k|            false,false, true,false,false,false, true,false,false,false,
  215|       |            // 2020-2029
  216|   521k|             true,false,false,false, true,false,false,false, true,false,
  217|       |            // 2030-2039
  218|   521k|            false,false, true,false,false,false, true,false,false,false,
  219|       |            // 2040-2049
  220|   521k|             true,false,false,false, true,false,false,false, true,false,
  221|       |            // 2050-2059
  222|   521k|            false,false, true,false,false,false, true,false,false,false,
  223|       |            // 2060-2069
  224|   521k|             true,false,false,false, true,false,false,false, true,false,
  225|       |            // 2070-2079
  226|   521k|            false,false, true,false,false,false, true,false,false,false,
  227|       |            // 2080-2089
  228|   521k|             true,false,false,false, true,false,false,false, true,false,
  229|       |            // 2090-2099
  230|   521k|            false,false, true,false,false,false, true,false,false,false,
  231|       |            // 2100-2109
  232|   521k|            false,false,false,false, true,false,false,false, true,false,
  233|       |            // 2110-2119
  234|   521k|            false,false, true,false,false,false, true,false,false,false,
  235|       |            // 2120-2129
  236|   521k|             true,false,false,false, true,false,false,false, true,false,
  237|       |            // 2130-2139
  238|   521k|            false,false, true,false,false,false, true,false,false,false,
  239|       |            // 2140-2149
  240|   521k|             true,false,false,false, true,false,false,false, true,false,
  241|       |            // 2150-2159
  242|   521k|            false,false, true,false,false,false, true,false,false,false,
  243|       |            // 2160-2169
  244|   521k|             true,false,false,false, true,false,false,false, true,false,
  245|       |            // 2170-2179
  246|   521k|            false,false, true,false,false,false, true,false,false,false,
  247|       |            // 2180-2189
  248|   521k|             true,false,false,false, true,false,false,false, true,false,
  249|       |            // 2190-2199
  250|   521k|            false,false, true,false,false,false, true,false,false,false,
  251|       |            // 2200
  252|   521k|            false
  253|   521k|        };
  254|   521k|        QL_REQUIRE(y>=1900 && y<=2200, "year outside valid range");
  ------------------
  |  |  117|   521k|#define QL_REQUIRE(condition,message) \
  |  |  ------------------
  |  |  |  |   73|   521k|#define QL_MULTILINE_ASSERTION_BEGIN do {
  |  |  ------------------
  |  |  118|   521k|QL_MULTILINE_ASSERTION_BEGIN \
  |  |  119|  1.04M|if (!(condition)) { \
  |  |  ------------------
  |  |  |  Branch (119:7): [True: 521k, False: 0]
  |  |  |  Branch (119:7): [True: 521k, False: 0]
  |  |  ------------------
  |  |  120|      0|    std::ostringstream _ql_msg_stream; \
  |  |  121|      0|    _ql_msg_stream << message; \
  |  |  122|      0|    throw QuantLib::Error(__FILE__,__LINE__, \
  |  |  123|      0|                          BOOST_CURRENT_FUNCTION,_ql_msg_stream.str()); \
  |  |  124|   521k|} \
  |  |  ------------------
  |  |  |  |   85|   521k|    #define QL_MULTILINE_ASSERTION_END } while(false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (85:48): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  125|   521k|QL_MULTILINE_ASSERTION_END
  ------------------
  255|   521k|        return YearIsLeap[y-1900];
  256|   521k|    }
_ZN8QuantLib4Date11monthLengthENS_5MonthEb:
  259|   521k|    Integer Date::monthLength(Month m, bool leapYear) {
  260|   521k|        static const Integer MonthLength[] = {
  261|   521k|            31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
  262|   521k|        };
  263|   521k|        static const Integer MonthLeapLength[] = {
  264|   521k|            31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
  265|   521k|        };
  266|   521k|        return (leapYear? MonthLeapLength[m-1] : MonthLength[m-1]);
  ------------------
  |  Branch (266:17): [True: 1.00k, False: 520k]
  ------------------
  267|   521k|    }
_ZN8QuantLib4Date11monthOffsetENS_5MonthEb:
  269|   521k|    Integer Date::monthOffset(Month m, bool leapYear) {
  270|   521k|        static const Integer MonthOffset[] = {
  271|   521k|              0,  31,  59,  90, 120, 151,   // Jan - Jun
  272|   521k|            181, 212, 243, 273, 304, 334,   // Jun - Dec
  273|   521k|            365     // used in dayOfMonth to bracket day
  274|   521k|        };
  275|   521k|        static const Integer MonthLeapOffset[] = {
  276|   521k|              0,  31,  60,  91, 121, 152,   // Jan - Jun
  277|   521k|            182, 213, 244, 274, 305, 335,   // Jun - Dec
  278|   521k|            366     // used in dayOfMonth to bracket day
  279|   521k|        };
  280|   521k|        return (leapYear? MonthLeapOffset[m-1] : MonthOffset[m-1]);
  ------------------
  |  Branch (280:17): [True: 1.00k, False: 520k]
  ------------------
  281|   521k|    }
_ZN8QuantLib4Date10yearOffsetEi:
  283|   521k|    Date::serial_type Date::yearOffset(Year y) {
  284|       |        // the list of all December 31st in the preceding year
  285|       |        // e.g. for 1901 yearOffset[1] is 366, that is, December 31 1900
  286|   521k|        static const Date::serial_type YearOffset[] = {
  287|       |            // 1900-1909
  288|   521k|                0,  366,  731, 1096, 1461, 1827, 2192, 2557, 2922, 3288,
  289|       |            // 1910-1919
  290|   521k|             3653, 4018, 4383, 4749, 5114, 5479, 5844, 6210, 6575, 6940,
  291|       |            // 1920-1929
  292|   521k|             7305, 7671, 8036, 8401, 8766, 9132, 9497, 9862,10227,10593,
  293|       |            // 1930-1939
  294|   521k|            10958,11323,11688,12054,12419,12784,13149,13515,13880,14245,
  295|       |            // 1940-1949
  296|   521k|            14610,14976,15341,15706,16071,16437,16802,17167,17532,17898,
  297|       |            // 1950-1959
  298|   521k|            18263,18628,18993,19359,19724,20089,20454,20820,21185,21550,
  299|       |            // 1960-1969
  300|   521k|            21915,22281,22646,23011,23376,23742,24107,24472,24837,25203,
  301|       |            // 1970-1979
  302|   521k|            25568,25933,26298,26664,27029,27394,27759,28125,28490,28855,
  303|       |            // 1980-1989
  304|   521k|            29220,29586,29951,30316,30681,31047,31412,31777,32142,32508,
  305|       |            // 1990-1999
  306|   521k|            32873,33238,33603,33969,34334,34699,35064,35430,35795,36160,
  307|       |            // 2000-2009
  308|   521k|            36525,36891,37256,37621,37986,38352,38717,39082,39447,39813,
  309|       |            // 2010-2019
  310|   521k|            40178,40543,40908,41274,41639,42004,42369,42735,43100,43465,
  311|       |            // 2020-2029
  312|   521k|            43830,44196,44561,44926,45291,45657,46022,46387,46752,47118,
  313|       |            // 2030-2039
  314|   521k|            47483,47848,48213,48579,48944,49309,49674,50040,50405,50770,
  315|       |            // 2040-2049
  316|   521k|            51135,51501,51866,52231,52596,52962,53327,53692,54057,54423,
  317|       |            // 2050-2059
  318|   521k|            54788,55153,55518,55884,56249,56614,56979,57345,57710,58075,
  319|       |            // 2060-2069
  320|   521k|            58440,58806,59171,59536,59901,60267,60632,60997,61362,61728,
  321|       |            // 2070-2079
  322|   521k|            62093,62458,62823,63189,63554,63919,64284,64650,65015,65380,
  323|       |            // 2080-2089
  324|   521k|            65745,66111,66476,66841,67206,67572,67937,68302,68667,69033,
  325|       |            // 2090-2099
  326|   521k|            69398,69763,70128,70494,70859,71224,71589,71955,72320,72685,
  327|       |            // 2100-2109
  328|   521k|            73050,73415,73780,74145,74510,74876,75241,75606,75971,76337,
  329|       |            // 2110-2119
  330|   521k|            76702,77067,77432,77798,78163,78528,78893,79259,79624,79989,
  331|       |            // 2120-2129
  332|   521k|            80354,80720,81085,81450,81815,82181,82546,82911,83276,83642,
  333|       |            // 2130-2139
  334|   521k|            84007,84372,84737,85103,85468,85833,86198,86564,86929,87294,
  335|       |            // 2140-2149
  336|   521k|            87659,88025,88390,88755,89120,89486,89851,90216,90581,90947,
  337|       |            // 2150-2159
  338|   521k|            91312,91677,92042,92408,92773,93138,93503,93869,94234,94599,
  339|       |            // 2160-2169
  340|   521k|            94964,95330,95695,96060,96425,96791,97156,97521,97886,98252,
  341|       |            // 2170-2179
  342|   521k|            98617,98982,99347,99713,100078,100443,100808,101174,101539,101904,
  343|       |            // 2180-2189
  344|   521k|            102269,102635,103000,103365,103730,104096,104461,104826,105191,105557,
  345|       |            // 2190-2199
  346|   521k|            105922,106287,106652,107018,107383,107748,108113,108479,108844,109209,
  347|       |            // 2200
  348|   521k|            109574
  349|   521k|        };
  350|   521k|        return YearOffset[y-1900];
  351|   521k|    }
_ZN8QuantLib4Date19minimumSerialNumberEv:
  749|   519k|    Date::serial_type Date::minimumSerialNumber() {
  750|   519k|        return 367;       // Jan 1st, 1901
  751|   519k|    }
_ZN8QuantLib4Date19maximumSerialNumberEv:
  753|   519k|    Date::serial_type Date::maximumSerialNumber() {
  754|   519k|        return 109574;    // Dec 31st, 2199
  755|   519k|    }
_ZN8QuantLib4Date17checkSerialNumberEl:
  757|   519k|    void Date::checkSerialNumber(Date::serial_type serialNumber) {
  758|   519k|        QL_REQUIRE(serialNumber >= minimumSerialNumber() &&
  ------------------
  |  |  117|   519k|#define QL_REQUIRE(condition,message) \
  |  |  ------------------
  |  |  |  |   73|   519k|#define QL_MULTILINE_ASSERTION_BEGIN do {
  |  |  ------------------
  |  |  118|   519k|QL_MULTILINE_ASSERTION_BEGIN \
  |  |  119|  1.03M|if (!(condition)) { \
  |  |  ------------------
  |  |  |  Branch (119:7): [True: 519k, False: 0]
  |  |  |  Branch (119:7): [True: 519k, False: 0]
  |  |  ------------------
  |  |  120|      0|    std::ostringstream _ql_msg_stream; \
  |  |  121|      0|    _ql_msg_stream << message; \
  |  |  122|      0|    throw QuantLib::Error(__FILE__,__LINE__, \
  |  |  123|      0|                          BOOST_CURRENT_FUNCTION,_ql_msg_stream.str()); \
  |  |  124|   519k|} \
  |  |  ------------------
  |  |  |  |   85|   519k|    #define QL_MULTILINE_ASSERTION_END } while(false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (85:48): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  125|   519k|QL_MULTILINE_ASSERTION_END
  ------------------
  759|   519k|                   serialNumber <= maximumSerialNumber(),
  760|   519k|                   "Date's serial number (" << serialNumber << ") outside "
  761|   519k|                   "allowed range [" << minimumSerialNumber() <<
  762|   519k|                   "-" << maximumSerialNumber() << "], i.e. [" <<
  763|   519k|                   minDate() << "-" << maxDate() << "]");
  764|   519k|    }
_ZN8QuantLib4Date10todaysDateEv:
  788|   520k|    Date Date::todaysDate() {
  789|   520k|        std::time_t t;
  790|       |
  791|   520k|        if (std::time(&t) == std::time_t(-1)) // -1 means time() didn't work
  ------------------
  |  Branch (791:13): [True: 0, False: 520k]
  ------------------
  792|      0|            return {};
  793|   520k|        std::tm *lt = std::localtime(&t);
  794|   520k|        return {Day(lt->tm_mday), Month(lt->tm_mon + 1), Year(lt->tm_year + 1900)};
  795|   520k|    }

_ZNK8QuantLib4Date12serialNumberEv:
  404|  4.98M|    inline Date::serial_type Date::serialNumber() const {
  405|  4.98M|        return serialNumber_;
  406|  4.98M|    }
_ZNK8QuantLib4DateplEl:
  408|   518k|    inline Date Date::operator+(Date::serial_type days) const {
  409|   518k|        return Date(serialNumber_+days);
  410|   518k|    }
_ZN8QuantLibneERKNS_4DateES2_:
  446|   932k|    inline bool operator!=(const Date& d1, const Date& d2) {
  447|   932k|        return (d1.serialNumber() != d2.serialNumber());
  448|   932k|    }
_ZN8QuantLibltERKNS_4DateES2_:
  450|    398|    inline bool operator<(const Date& d1, const Date& d2) {
  451|    398|        return (d1.serialNumber() < d2.serialNumber());
  452|    398|    }
_ZN8QuantLibeqERKNS_4DateES2_:
  442|   520k|    inline bool operator==(const Date& d1, const Date& d2) {
  443|   520k|        return (d1.serialNumber() == d2.serialNumber());
  444|   520k|    }
_ZN8QuantLibleERKNS_4DateES2_:
  454|  1.03M|    inline bool operator<=(const Date& d1, const Date& d2) {
  455|  1.03M|        return (d1.serialNumber() <= d2.serialNumber());
  456|  1.03M|    }

_ZN8QuantLib10DayCounter4ImplD2Ev:
   49|  1.00k|            virtual ~Impl() = default;
_ZN8QuantLib10DayCounterC2EN5boost10shared_ptrINS0_4ImplEEE:
   65|  1.01k|        explicit DayCounter(ext::shared_ptr<Impl> impl) : impl_(std::move(impl)) {}
_ZN8QuantLib10DayCounterC2Ev:
   72|  2.01k|        DayCounter() = default;

_ZN8QuantLib9Actual360C2Eb:
   61|  1.00k|        : DayCounter(ext::shared_ptr<DayCounter::Impl>(
   62|  1.00k|            new Actual360::Impl(includeLastDay))) {}
_ZN8QuantLib9Actual3604ImplC2Eb:
   44|  1.00k|            : includeLastDay_(includeLastDay) {}

_ZN8QuantLib9Thirty36014implementationENS0_10ConventionERKNS_4DateE:
   35|      2|    Thirty360::implementation(Thirty360::Convention c, const Date& terminationDate) {
   36|      2|        switch (c) {
   37|      0|          case USA:
  ------------------
  |  Branch (37:11): [True: 0, False: 2]
  ------------------
   38|      0|            return ext::shared_ptr<DayCounter::Impl>(new US_Impl);
   39|      0|          case European:
  ------------------
  |  Branch (39:11): [True: 0, False: 2]
  ------------------
   40|      0|          case EurobondBasis:
  ------------------
  |  Branch (40:11): [True: 0, False: 2]
  ------------------
   41|      0|            return ext::shared_ptr<DayCounter::Impl>(new EU_Impl);
   42|      0|          case Italian:
  ------------------
  |  Branch (42:11): [True: 0, False: 2]
  ------------------
   43|      0|            return ext::shared_ptr<DayCounter::Impl>(new IT_Impl);
   44|      0|          case ISMA:
  ------------------
  |  Branch (44:11): [True: 0, False: 2]
  ------------------
   45|      2|          case BondBasis:
  ------------------
  |  Branch (45:11): [True: 2, False: 0]
  ------------------
   46|      2|            return ext::shared_ptr<DayCounter::Impl>(new ISMA_Impl);
   47|      0|          case ISDA:
  ------------------
  |  Branch (47:11): [True: 0, False: 2]
  ------------------
   48|      0|          case German:
  ------------------
  |  Branch (48:11): [True: 0, False: 2]
  ------------------
   49|      0|            return ext::shared_ptr<DayCounter::Impl>(new ISDA_Impl(terminationDate));
   50|      0|          case NASD:
  ------------------
  |  Branch (50:11): [True: 0, False: 2]
  ------------------
   51|      0|            return ext::shared_ptr<DayCounter::Impl>(new NASD_Impl);
   52|      0|          default:
  ------------------
  |  Branch (52:11): [True: 0, False: 2]
  ------------------
   53|      0|            QL_FAIL("unknown 30/360 convention");
  ------------------
  |  |   92|      0|#define QL_FAIL(message) \
  |  |  ------------------
  |  |  |  |   57|      0|#define QL_MULTILINE_FAILURE_BEGIN do {
  |  |  ------------------
  |  |   93|      0|QL_MULTILINE_FAILURE_BEGIN \
  |  |   94|      0|    std::ostringstream _ql_msg_stream; \
  |  |   95|      0|    _ql_msg_stream << message; \
  |  |   96|      0|    throw QuantLib::Error(__FILE__,__LINE__, \
  |  |   97|      0|                          BOOST_CURRENT_FUNCTION,_ql_msg_stream.str()); \
  |  |  ------------------
  |  |  |  |   69|      0|    #define QL_MULTILINE_FAILURE_END } while(false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (69:46): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   98|      0|QL_MULTILINE_FAILURE_END
  ------------------
   54|      2|        }
   55|      2|    }

_ZN8QuantLib9Thirty360C2ENS0_10ConventionERKNS_4DateE:
  135|      2|        : DayCounter(implementation(c, terminationDate)) {}

ecb.cpp:_ZNK8QuantLib12_GLOBAL__N_13$_0clEv:
   56|      2|        const MonthBimap_t MONTHS = []() {
   57|      2|          MonthBimap_t months;
   58|      2|          months.insert({"JAN", January});
   59|      2|          months.insert({"FEB", February});
   60|      2|          months.insert({"MAR", March});
   61|      2|          months.insert({"APR", April});
   62|      2|          months.insert({"MAY", May});
   63|      2|          months.insert({"JUN", June});
   64|      2|          months.insert({"JUL", July});
   65|      2|          months.insert({"AUG", August});
   66|      2|          months.insert({"SEP", September});
   67|      2|          months.insert({"OCT", October});
   68|      2|          months.insert({"NOV", November});
   69|      2|          months.insert({"DEC", December});
   70|      2|          return months;
   71|      2|        }();
ecb.cpp:_ZNK8QuantLib12_GLOBAL__N_18is_ilessclEN5boost17basic_string_viewIcNSt3__111char_traitsIcEEEES7_:
   40|     76|                          const boost::string_view rhs) const {
   41|     76|            char lhsUpper[3];
   42|     76|            char rhsUpper[3];
   43|    304|            for (int i = 0; i < 3; ++i) {
  ------------------
  |  Branch (43:29): [True: 228, False: 76]
  ------------------
   44|    228|              lhsUpper[i] = std::toupper(lhs[i]);
   45|    228|              rhsUpper[i] = std::toupper(rhs[i]);
   46|    228|            }
   47|     76|            return boost::string_view(lhsUpper, 3) <
   48|     76|                   boost::string_view(rhsUpper, 3);
   49|     76|          }

_ZNK8QuantLib4NullIdEcvdEv:
   62|  1.55M|        constexpr operator T() const {
   63|  1.55M|            if constexpr (std::is_floating_point_v<T>) {
   64|       |                // a specific, unlikely value that should fit into any Real
   65|  1.55M|                return (std::numeric_limits<float>::max)();
   66|       |            } else if constexpr (std::is_integral_v<T>) {
   67|       |                // this should fit into any Integer
   68|       |                return (std::numeric_limits<int>::max)();
   69|       |            } else {
   70|       |                return T();
   71|       |            }
   72|  1.55M|        }
_ZNK8QuantLib4NullIjEcvjEv:
   62|  3.02k|        constexpr operator T() const {
   63|       |            if constexpr (std::is_floating_point_v<T>) {
   64|       |                // a specific, unlikely value that should fit into any Real
   65|       |                return (std::numeric_limits<float>::max)();
   66|  3.02k|            } else if constexpr (std::is_integral_v<T>) {
   67|       |                // this should fit into any Integer
   68|  3.02k|                return (std::numeric_limits<int>::max)();
   69|       |            } else {
   70|       |                return T();
   71|       |            }
   72|  3.02k|        }

_ZNK8QuantLib15ObservableValueINS_4DateEE5valueEv:
  117|   520k|    const T& ObservableValue<T>::value() const {
  118|   520k|        return value_;
  119|   520k|    }
_ZN8QuantLib15ObservableValueINS_4DateEED2Ev:
   48|      1|        ~ObservableValue() = default;
_ZNK8QuantLib15ObservableValueINS_4DateEEcvN5boost10shared_ptrINS_10ObservableEEEEv:
  112|   518k|    ObservableValue<T>::operator ext::shared_ptr<Observable>() const {
  113|   518k|        return observable_;
  114|   518k|    }
_ZN8QuantLib15ObservableValueINS_4DateEEC2EOS1_:
   74|      1|    : value_(std::move(t)), observable_(new Observable) {}