_ZN2mu10ParserBase9DefineFunIPFddEEEvRKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEET_b:
  145|  85.4k|		{
  146|  85.4k|			AddCallback(a_strName, ParserCallback(a_pFun, a_bAllowOpt), m_FunDef, ValidNameChars());
  147|  85.4k|		}
_ZN2mu10ParserBase9DefineFunIPFdddEEEvRKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEET_b:
  145|  3.71k|		{
  146|  3.71k|			AddCallback(a_strName, ParserCallback(a_pFun, a_bAllowOpt), m_FunDef, ValidNameChars());
  147|  3.71k|		}
_ZN2mu10ParserBase9DefineFunIPFdPKdiEEEvRKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEET_b:
  145|  14.8k|		{
  146|  14.8k|			AddCallback(a_strName, ParserCallback(a_pFun, a_bAllowOpt), m_FunDef, ValidNameChars());
  147|  14.8k|		}
_ZN2mu10ParserBase9DefineFunIPFdvEEEvRKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEET_b:
  145|  3.71k|		{
  146|  3.71k|			AddCallback(a_strName, ParserCallback(a_pFun, a_bAllowOpt), m_FunDef, ValidNameChars());
  147|  3.71k|		}
_ZN2mu10ParserBase14change_dec_sepIcEC2Ecci:
  234|      2|				:std::numpunct<TChar>()
  235|      2|				,m_nGroup(nGroup)
  236|      2|				,m_cDecPoint(cDecSep)
  237|      2|				,m_cThousandsSep(cThousandsSep)
  238|      2|			{}
_ZNK2mu10ParserBase14change_dec_sepIcE16do_decimal_pointEv:
  243|   816k|			{
  244|   816k|				return m_cDecPoint;
  245|   816k|			}
_ZNK2mu10ParserBase14change_dec_sepIcE16do_thousands_sepEv:
  248|   812k|			{
  249|   812k|				return m_cThousandsSep;
  250|   812k|			}
_ZNK2mu10ParserBase14change_dec_sepIcE11do_groupingEv:
  253|   812k|			{
  254|       |				// fix for issue 4: https://code.google.com/p/muparser/issues/detail?id=4
  255|       |				// courtesy of Jens Bartsch
  256|       |				// original code:
  257|       |				//        return std::string(1, (char)m_nGroup); 
  258|       |				// new code:
  259|   812k|				return std::string(1, (char)(m_cThousandsSep > 0 ? m_nGroup : CHAR_MAX));
  ------------------
  |  Branch (259:34): [True: 0, False: 812k]
  ------------------
  260|   812k|			}

_ZNK2mu14ParserByteCode7GetSizeEv:
  143|  1.61k|		{
  144|  1.61k|			return m_vRPN.size();
  145|  1.61k|		}
_ZNK2mu14ParserByteCode7GetBaseEv:
  148|  1.61k|		{
  149|  1.61k|			if (m_vRPN.size() == 0)
  ------------------
  |  Branch (149:8): [True: 0, False: 1.61k]
  ------------------
  150|      0|				throw ParserError(ecINTERNAL_ERROR);
  151|  1.61k|			else
  152|  1.61k|				return &m_vRPN[0];
  153|  1.61k|		}
_ZN2mu14ParserByteCode16StoreEnvironmentENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKNS1_6vectorIS7_NS5_IS7_EEEE:
  156|  1.61k|		{
  157|  1.61k|			m_stringBuffer = strBuf;
  158|  1.61k|			m_expr = expr;
  159|  1.61k|		}

_ZN2mu14ParserErrorMsgD2Ev:
   64|      1|		~ParserErrorMsg() = default;

_ZN2mu8TypeInfoIdE9IsIntegerEv:
   52|  3.71k|		static bool IsInteger() { return false; }
_ZN2mu8MathImplIdE3SinEd:
  118|    194|		static T Sin(T v) { return sin(v); }
_ZN2mu8MathImplIdE3CosEd:
  119|    197|		static T Cos(T v) { return cos(v); }
_ZN2mu8MathImplIdE3TanEd:
  120|    202|		static T Tan(T v) { return tan(v); }
_ZN2mu8MathImplIdE3CotEd:
  121|    198|		static T Cot(T v) { return 1.0 / tan(v); }
_ZN2mu8MathImplIdE4ASinEd:
  122|    195|		static T ASin(T v) { return asin(v); }
_ZN2mu8MathImplIdE4ACosEd:
  123|    197|		static T ACos(T v) { return acos(v); }
_ZN2mu8MathImplIdE4ATanEd:
  124|    195|		static T ATan(T v) { return atan(v); }
_ZN2mu8MathImplIdE5ATan2Edd:
  125|    465|		static T ATan2(T v1, T v2) { return atan2(v1, v2); }
_ZN2mu8MathImplIdE4SinhEd:
  126|    195|		static T Sinh(T v) { return sinh(v); }
_ZN2mu8MathImplIdE4CoshEd:
  127|    195|		static T Cosh(T v) { return cosh(v); }
_ZN2mu8MathImplIdE4TanhEd:
  128|    195|		static T Tanh(T v) { return tanh(v); }
_ZN2mu8MathImplIdE4CothEd:
  129|    198|		static T Coth(T v) { return 1.0 / tanh(v); }
_ZN2mu8MathImplIdE5ASinhEd:
  130|    220|		static T ASinh(T v) { return log(v + sqrt(v * v + 1)); }
_ZN2mu8MathImplIdE5ACoshEd:
  131|    195|		static T ACosh(T v) { return log(v + sqrt(v * v - 1)); }
_ZN2mu8MathImplIdE5ATanhEd:
  132|    195|		static T ATanh(T v) { return ((T)0.5 * log((1 + v) / (1 - v))); }
_ZN2mu8MathImplIdE4Log2Ed:
  134|    194|		static T Log2(T v) { return log(v) / log((T)2); } // Logarithm base 2
_ZN2mu8MathImplIdE5Log10Ed:
  135|    279|		static T Log10(T v) { return log10(v); }         // Logarithm base 10
_ZN2mu8MathImplIdE3LogEd:
  133|    523|		static T Log(T v) { return log(v); }
_ZN2mu8MathImplIdE3ExpEd:
  136|    195|		static T Exp(T v) { return exp(v); }
_ZN2mu8MathImplIdE4SqrtEd:
  138|    195|		static T Sqrt(T v) { return sqrt(v); }
_ZN2mu8MathImplIdE4SignEd:
  140|    389|		static T Sign(T v) { return (T)((v < 0) ? -1 : (v > 0) ? 1 : 0); }
  ------------------
  |  Branch (140:35): [True: 194, False: 195]
  |  Branch (140:50): [True: 62, False: 133]
  ------------------
_ZN2mu8MathImplIdE4RintEd:
  139|    233|		static T Rint(T v) { return floor(v + (T)0.5); }
_ZN2mu8MathImplIdE3AbsEd:
  137|    389|		static T Abs(T v) { return (v >= 0) ? v : -v; }
  ------------------
  |  Branch (137:30): [True: 194, False: 195]
  ------------------
_ZN2mu8MathImplIdE3SumEPKdi:
  155|    567|		{
  156|    567|			if (!a_iArgc)
  ------------------
  |  Branch (156:8): [True: 0, False: 567]
  ------------------
  157|      0|				throw ParserError(_T("too few arguments for function sum."));
  ------------------
  |  |   69|      0|		#define _T(x) x
  ------------------
  158|       |
  159|    567|			T fRes = 0;
  160|  80.9k|			for (int i = 0; i < a_iArgc; ++i) fRes += a_afArg[i];
  ------------------
  |  Branch (160:20): [True: 80.3k, False: 567]
  ------------------
  161|    567|			return fRes;
  162|    567|		}
_ZN2mu8MathImplIdE3AvgEPKdi:
  165|    646|		{
  166|    646|			if (!a_iArgc)
  ------------------
  |  Branch (166:8): [True: 0, False: 646]
  ------------------
  167|      0|				throw ParserError(_T("too few arguments for function avg."));
  ------------------
  |  |   69|      0|		#define _T(x) x
  ------------------
  168|       |
  169|    646|			T fRes = 0;
  170|  59.0k|			for (int i = 0; i < a_iArgc; ++i) fRes += a_afArg[i];
  ------------------
  |  Branch (170:20): [True: 58.3k, False: 646]
  ------------------
  171|    646|			return fRes / (T)a_iArgc;
  172|    646|		}
_ZN2mu8MathImplIdE3MinEPKdi:
  175|  1.21k|		{
  176|  1.21k|			if (!a_iArgc)
  ------------------
  |  Branch (176:8): [True: 0, False: 1.21k]
  ------------------
  177|      0|				throw ParserError(_T("too few arguments for function min."));
  ------------------
  |  |   69|      0|		#define _T(x) x
  ------------------
  178|       |
  179|  1.21k|			T fRes = a_afArg[0];
  180|  79.8k|			for (int i = 0; i < a_iArgc; ++i)
  ------------------
  |  Branch (180:20): [True: 78.6k, False: 1.21k]
  ------------------
  181|  78.6k|				fRes = std::min(fRes, a_afArg[i]);
  182|       |
  183|  1.21k|			return fRes;
  184|  1.21k|		}
_ZN2mu8MathImplIdE3MaxEPKdi:
  187|  1.26k|		{
  188|  1.26k|			if (!a_iArgc)
  ------------------
  |  Branch (188:8): [True: 0, False: 1.26k]
  ------------------
  189|      0|				throw ParserError(_T("too few arguments for function max."));
  ------------------
  |  |   69|      0|		#define _T(x) x
  ------------------
  190|       |
  191|  1.26k|			T fRes = a_afArg[0];
  192|  62.1k|			for (int i = 0; i < a_iArgc; ++i) fRes = std::max(fRes, a_afArg[i]);
  ------------------
  |  Branch (192:20): [True: 60.8k, False: 1.26k]
  ------------------
  193|       |
  194|  1.26k|			return fRes;
  195|  1.26k|		}
_ZN2mu8MathImplIdE3RndEv:
  143|    642|		{
  144|    642|			static std::random_device rd;  
  145|    642|			static std::mt19937 gen(rd()); 
  146|    642|			static std::uniform_real_distribution<T> dis(0.0, 1.0); // Range [0, 1)
  147|       |
  148|    642|			return dis(gen);
  149|    642|		}
_ZN2mu8MathImplIdE10UnaryMinusEd:
  151|  5.32k|		static T UnaryMinus(T v) { return -v; }
_ZN2mu8MathImplIdE3PowEdd:
  141|  92.6k|		static T Pow(T v1, T v2) { return std::pow(v1, v2); }

_ZNK2mu21generic_callable_type12call_multfunEPKdi:
  104|  3.69k|		{
  105|  3.69k|			if (_pUserData == nullptr) {
  ------------------
  |  Branch (105:8): [True: 3.69k, False: 0]
  ------------------
  106|  3.69k|				auto multfun_typed_ptr = reinterpret_cast<multfun_type>(_pRawFun);
  107|  3.69k|				return (*multfun_typed_ptr)(a_afArg, a_iArgc);
  108|  3.69k|			} else {
  109|      0|				auto multfun_userdata_typed_ptr = reinterpret_cast<multfun_userdata_type>(_pRawFun);
  110|      0|				return (*multfun_userdata_typed_ptr)(_pUserData, a_afArg, a_iArgc);
  111|      0|			}
  112|  3.69k|		}
_ZNK2mu21generic_callable_typeeqES0_:
  137|  34.8k|		{
  138|  34.8k|			return _pRawFun == other._pRawFun && _pUserData == other._pUserData; 
  ------------------
  |  Branch (138:11): [True: 2.42k, False: 32.3k]
  |  Branch (138:41): [True: 2.42k, False: 0]
  ------------------
  139|  34.8k|		}
_ZNK2mu21generic_callable_typeeqEDn:
  147|  24.6k|		{
  148|  24.6k|			return _pRawFun == nullptr; 
  149|  24.6k|		}
_ZNK2mu21generic_callable_typeneEDn:
  152|  41.6k|		{
  153|  41.6k|			return _pRawFun != nullptr; 
  154|  41.6k|		}
_ZNK2mu11ParserTokenIdNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE7GetCodeEv:
  389|  9.68M|		{
  390|  9.68M|			if (m_pCallback.get())
  ------------------
  |  Branch (390:8): [True: 667k, False: 9.02M]
  ------------------
  391|   667k|			{
  392|   667k|				return m_pCallback->GetCode();
  393|   667k|			}
  394|  9.02M|			else
  395|  9.02M|			{
  396|  9.02M|				return m_iCode;
  397|  9.02M|			}
  398|  9.68M|		}
_ZNK2mu11ParserTokenIdNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE6GetPriEv:
  415|  54.4k|		{
  416|  54.4k|			if (!m_pCallback.get())
  ------------------
  |  Branch (416:8): [True: 0, False: 54.4k]
  ------------------
  417|      0|				throw ParserError(ecINTERNAL_ERROR);
  418|       |
  419|  54.4k|			if (m_pCallback->GetCode() != cmOPRT_BIN && m_pCallback->GetCode() != cmOPRT_INFIX)
  ------------------
  |  Branch (419:8): [True: 54.4k, False: 0]
  |  Branch (419:48): [True: 0, False: 54.4k]
  ------------------
  420|      0|				throw ParserError(ecINTERNAL_ERROR);
  421|       |
  422|  54.4k|			return m_pCallback->GetPri();
  423|  54.4k|		}
_ZNK2mu11ParserTokenIdNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE11GetAsStringEv:
  520|    184|		{
  521|    184|			return m_strTok;
  522|    184|		}
_ZN2mu11ParserTokenIdNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEC2Ev:
  198|  2.47M|			:m_iCode(cmUNKNOWN)
  199|  2.47M|			, m_iType(tpVOID)
  200|  2.47M|			, m_pTok(0)
  201|  2.47M|			, m_iIdx(-1)
  202|  2.47M|			, m_strTok()
  203|  2.47M|			, m_strVal()
  204|  2.47M|			, m_fVal(0)
  205|  2.47M|			, m_pCallback()
  206|  2.47M|		{}
_ZNK2mu11ParserTokenIdNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE11GetFuncAddrEv:
  450|   105k|		{
  451|   105k|			return (m_pCallback.get())
  ------------------
  |  Branch (451:11): [True: 91.1k, False: 14.6k]
  ------------------
  452|   105k|				? generic_callable_type{(erased_fun_type)m_pCallback->GetAddr(),
  453|  91.1k|				                        m_pCallback->GetUserData()}
  454|   105k|				: generic_callable_type{};
  455|   105k|		}
_ZNK2mu11ParserTokenIdNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE11GetArgCountEv:
  493|  98.5k|		{
  494|  98.5k|			MUP_ASSERT(m_pCallback.get());
  ------------------
  |  |   78|  98.5k|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 98.5k]
  |  |  ------------------
  |  |   79|  98.5k|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  495|       |
  496|  98.5k|			if (!m_pCallback->IsValid())
  ------------------
  |  Branch (496:8): [True: 0, False: 98.5k]
  ------------------
  497|      0|				throw ParserError(ecINTERNAL_ERROR);
  498|       |
  499|  98.5k|			return m_pCallback->GetArgc();
  500|  98.5k|		}
_ZN2mu11ParserTokenIdNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE6SetValEdRKS7_:
  303|   958k|		{
  304|   958k|			m_iCode = cmVAL;
  305|   958k|			m_iType = tpDBL;
  306|   958k|			m_fVal = a_fVal;
  307|   958k|			m_strTok = a_strTok;
  308|   958k|			m_iIdx = -1;
  309|       |
  310|   958k|			m_pTok = 0;
  311|   958k|			m_pCallback.reset(0);
  312|       |
  313|   958k|			return *this;
  314|   958k|		}
_ZNK2mu11ParserTokenIdNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE6GetValEv:
  464|   856k|		{
  465|   856k|			switch (m_iCode)
  466|   856k|			{
  467|   856k|			case cmVAL:  return m_fVal;
  ------------------
  |  Branch (467:4): [True: 856k, False: 3]
  ------------------
  468|      0|			case cmVAR:  return *((TBase*)m_pTok);
  ------------------
  |  Branch (468:4): [True: 0, False: 856k]
  ------------------
  469|      3|			default:     throw ParserError(ecVAL_EXPECTED);
  ------------------
  |  Branch (469:4): [True: 3, False: 856k]
  ------------------
  470|   856k|			}
  471|   856k|		}
_ZN2mu11ParserTokenIdNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEC2ERKS8_:
  217|  5.22M|		{
  218|  5.22M|			Assign(a_Tok);
  219|  5.22M|		}
_ZN2mu11ParserTokenIdNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE6AssignERKS8_:
  240|  11.8M|		{
  241|  11.8M|			m_iCode = a_Tok.m_iCode;
  242|  11.8M|			m_pTok = a_Tok.m_pTok;
  243|  11.8M|			m_strTok = a_Tok.m_strTok;
  244|  11.8M|			m_iIdx = a_Tok.m_iIdx;
  245|  11.8M|			m_strVal = a_Tok.m_strVal;
  246|  11.8M|			m_iType = a_Tok.m_iType;
  247|  11.8M|			m_fVal = a_Tok.m_fVal;
  248|       |			// create new callback object if a_Tok has one 
  249|  11.8M|			m_pCallback.reset(a_Tok.m_pCallback.get() ? a_Tok.m_pCallback->Clone() : 0);
  ------------------
  |  Branch (249:22): [True: 476k, False: 11.3M]
  ------------------
  250|  11.8M|		}
_ZNK2mu11ParserTokenIdNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE7GetTypeEv:
  402|   908k|		{
  403|   908k|			if (m_pCallback.get())
  ------------------
  |  Branch (403:8): [True: 49.3k, False: 858k]
  ------------------
  404|  49.3k|			{
  405|  49.3k|				return m_pCallback->GetType();
  406|  49.3k|			}
  407|   858k|			else
  408|   858k|			{
  409|   858k|				return m_iType;
  410|   858k|			}
  411|   908k|		}
_ZNK2mu11ParserTokenIdNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE13IsOptimizableEv:
  506|  24.6k|		{
  507|  24.6k|			return m_pCallback->IsValid() && m_pCallback->IsOptimizable();
  ------------------
  |  Branch (507:11): [True: 24.6k, False: 0]
  |  Branch (507:37): [True: 23.8k, False: 734]
  ------------------
  508|  24.6k|		}
_ZNK2mu21generic_callable_type8call_funILm0EJEEEdDpOT0_:
   76|    642|		{
   77|    642|			static_assert(NbParams == sizeof...(Args), "mismatch between NbParams and Args");
   78|    642|			if (_pUserData == nullptr) 
  ------------------
  |  Branch (78:8): [True: 642, False: 0]
  ------------------
   79|    642|			{
   80|    642|				auto fun_typed_ptr = reinterpret_cast<typename TplCallType<NbParams>::fun_type>(_pRawFun);
   81|    642|				return (*fun_typed_ptr)(std::forward<Args>(args)...);
   82|    642|			} 
   83|      0|			else 
   84|      0|			{
   85|      0|				auto fun_userdata_typed_ptr = reinterpret_cast<typename TplCallType<NbParams>::fun_userdata_type>(_pRawFun);
   86|      0|				return (*fun_userdata_typed_ptr)(_pUserData, std::forward<Args>(args)...);
   87|      0|			}
   88|    642|		}
_ZNK2mu21generic_callable_type8call_funILm1EJRdEEEdDpOT0_:
   76|  10.4k|		{
   77|  10.4k|			static_assert(NbParams == sizeof...(Args), "mismatch between NbParams and Args");
   78|  10.4k|			if (_pUserData == nullptr) 
  ------------------
  |  Branch (78:8): [True: 10.4k, False: 0]
  ------------------
   79|  10.4k|			{
   80|  10.4k|				auto fun_typed_ptr = reinterpret_cast<typename TplCallType<NbParams>::fun_type>(_pRawFun);
   81|  10.4k|				return (*fun_typed_ptr)(std::forward<Args>(args)...);
   82|  10.4k|			} 
   83|      0|			else 
   84|      0|			{
   85|      0|				auto fun_userdata_typed_ptr = reinterpret_cast<typename TplCallType<NbParams>::fun_userdata_type>(_pRawFun);
   86|      0|				return (*fun_userdata_typed_ptr)(_pUserData, std::forward<Args>(args)...);
   87|      0|			}
   88|  10.4k|		}
_ZNK2mu21generic_callable_type8call_funILm2EJRdS2_EEEdDpOT0_:
   76|    465|		{
   77|    465|			static_assert(NbParams == sizeof...(Args), "mismatch between NbParams and Args");
   78|    465|			if (_pUserData == nullptr) 
  ------------------
  |  Branch (78:8): [True: 465, False: 0]
  ------------------
   79|    465|			{
   80|    465|				auto fun_typed_ptr = reinterpret_cast<typename TplCallType<NbParams>::fun_type>(_pRawFun);
   81|    465|				return (*fun_typed_ptr)(std::forward<Args>(args)...);
   82|    465|			} 
   83|      0|			else 
   84|      0|			{
   85|      0|				auto fun_userdata_typed_ptr = reinterpret_cast<typename TplCallType<NbParams>::fun_userdata_type>(_pRawFun);
   86|      0|				return (*fun_userdata_typed_ptr)(_pUserData, std::forward<Args>(args)...);
   87|      0|			}
   88|    465|		}
_ZN2mu11ParserTokenIdNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEaSERKS8_:
  229|  6.64M|		{
  230|  6.64M|			Assign(a_Tok);
  231|  6.64M|			return *this;
  232|  6.64M|		}
_ZN2mu11ParserTokenIdNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE3SetENS_8ECmdCodeERKS7_:
  264|  1.26M|		{
  265|       |			// The following types can't be set this way, they have special Set functions
  266|  1.26M|			MUP_ASSERT(a_iType != cmVAR);
  ------------------
  |  |   78|  1.26M|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 1.26M]
  |  |  ------------------
  |  |   79|  1.26M|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  267|  1.26M|			MUP_ASSERT(a_iType != cmVAL);
  ------------------
  |  |   78|  1.26M|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 1.26M]
  |  |  ------------------
  |  |   79|  1.26M|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  268|  1.26M|			MUP_ASSERT(a_iType != cmFUNC);
  ------------------
  |  |   78|  1.26M|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 1.26M]
  |  |  ------------------
  |  |   79|  1.26M|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  269|       |
  270|  1.26M|			m_iCode = a_iType;
  271|  1.26M|			m_iType = tpVOID;
  272|  1.26M|			m_pTok = 0;
  273|  1.26M|			m_strTok = a_strTok;
  274|  1.26M|			m_iIdx = -1;
  275|       |
  276|  1.26M|			return *this;
  277|  1.26M|		}
_ZN2mu11ParserTokenIdNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE3SetERKNS_14ParserCallbackERKS7_:
  282|  89.0k|		{
  283|  89.0k|			MUP_ASSERT(a_pCallback.IsValid());
  ------------------
  |  |   78|  89.0k|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 89.0k]
  |  |  ------------------
  |  |   79|  89.0k|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  284|       |
  285|  89.0k|			m_iCode = a_pCallback.GetCode();
  286|  89.0k|			m_iType = tpVOID;
  287|  89.0k|			m_strTok = a_sTok;
  288|  89.0k|			m_pCallback.reset(new ParserCallback(a_pCallback));
  289|       |
  290|  89.0k|			m_pTok = 0;
  291|  89.0k|			m_iIdx = -1;
  292|       |
  293|  89.0k|			return *this;
  294|  89.0k|		}
_ZN2mu11ParserTokenIdNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE9SetStringERKS7_m:
  340|  4.26k|		{
  341|  4.26k|			m_iCode = cmSTRING;
  342|  4.26k|			m_iType = tpSTR;
  343|  4.26k|			m_strTok = a_strTok;
  344|  4.26k|			m_iIdx = static_cast<int>(a_iSize);
  345|       |
  346|  4.26k|			m_pTok = 0;
  347|  4.26k|			m_pCallback.reset(0);
  348|  4.26k|			return *this;
  349|  4.26k|		}

_ZN2mu6Parser5IsValEPKcPiPd:
   58|   812k|	{
   59|       |		// There is an issue with libc++ where it creates an error if a double value is followed by a character which
   60|       |		// is the case when using postfix operators.
   61|       |		//
   62|       |		// http://cplusplus.github.io/LWG/lwg-defects.html#2381
   63|       |		//
   64|       |		// This happens only with libc++, not with libstdc++ (Gnu C++ standard library)
   65|       |		// It seems that Macs are using libc++. This is causing #123. The fix below will fix #123
   66|       |		// but is will break localization support and cause #136.
   67|       |
   68|       |		// I'm disabling this fix. For systems using libc++ you must put a space between floating point numbers and postfix operators.
   69|       |#if defined(__APPLE__) && defined(NEVERTRUE)
   70|       |		try
   71|       |		{
   72|       |			std::size_t charsProcessed;
   73|       |			value_type fVal = static_cast<value_type>(std::stod(string_type(a_szExpr), &charsProcessed));
   74|       |			if (charsProcessed == 0)
   75|       |				return 0;
   76|       |
   77|       |			*a_iPos += (int)charsProcessed;
   78|       |			*a_fVal = fVal;
   79|       |			return 1;
   80|       |		}
   81|       |		catch (...)
   82|       |		{
   83|       |			return 0;
   84|       |		}
   85|       |#else
   86|   812k|		value_type fVal(0);
   87|       |
   88|   812k|		stringstream_type stream(a_szExpr);
   89|   812k|		stream.imbue(Parser::s_locale);
   90|   812k|		stream >> fVal;
   91|   812k|		stringstream_type::pos_type iEnd = stream.tellg(); // Position after reading
   92|       |
   93|   812k|		if (iEnd == (stringstream_type::pos_type) - 1)
  ------------------
  |  Branch (93:7): [True: 4.97k, False: 807k]
  ------------------
   94|  4.97k|			return 0;
   95|       |
   96|   807k|		*a_iPos += (int)iEnd;
   97|   807k|		*a_fVal = fVal;
   98|   807k|		return 1;
   99|   812k|#endif		
  100|   812k|	}
_ZN2mu6ParserC2Ev:
  109|  3.71k|		:ParserBase()
  110|  3.71k|	{
  111|  3.71k|		AddValIdent(IsVal);
  112|       |
  113|  3.71k|		InitCharSets();
  114|  3.71k|		InitFun();
  115|  3.71k|		InitConst();
  116|  3.71k|		InitOprt();
  117|  3.71k|	}
_ZN2mu6Parser12InitCharSetsEv:
  127|  3.71k|	{
  128|  3.71k|		DefineNameChars(_T("0123456789_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"));
  ------------------
  |  |   69|  3.71k|		#define _T(x) x
  ------------------
  129|  3.71k|		DefineOprtChars(_T("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ+-*^/?<>=#!$%&|~'_{}"));
  ------------------
  |  |   69|  3.71k|		#define _T(x) x
  ------------------
  130|  3.71k|		DefineInfixOprtChars(_T("/+-*^?<>=#!$%&|~'_"));
  ------------------
  |  |   69|  3.71k|		#define _T(x) x
  ------------------
  131|  3.71k|	}
_ZN2mu6Parser7InitFunEv:
  136|  3.71k|	{
  137|  3.71k|		if (mu::TypeInfo<mu::value_type>::IsInteger())
  ------------------
  |  Branch (137:7): [True: 0, False: 3.71k]
  ------------------
  138|      0|		{
  139|       |			// When setting MUP_BASETYPE to an integer type
  140|       |			// Place functions for dealing with integer values here
  141|       |			// ...
  142|       |			// ...
  143|       |			// ...
  144|      0|		}
  145|  3.71k|		else
  146|  3.71k|		{
  147|       |			// trigonometric functions
  148|  3.71k|			DefineFun(_T("sin"), MathImpl<value_type>::Sin);
  ------------------
  |  |   69|  3.71k|		#define _T(x) x
  ------------------
  149|  3.71k|			DefineFun(_T("cos"), MathImpl<value_type>::Cos);
  ------------------
  |  |   69|  3.71k|		#define _T(x) x
  ------------------
  150|  3.71k|			DefineFun(_T("tan"), MathImpl<value_type>::Tan);
  ------------------
  |  |   69|  3.71k|		#define _T(x) x
  ------------------
  151|  3.71k|			DefineFun(_T("cot"), MathImpl<value_type>::Cot);
  ------------------
  |  |   69|  3.71k|		#define _T(x) x
  ------------------
  152|       |			// arcus functions
  153|  3.71k|			DefineFun(_T("asin"), MathImpl<value_type>::ASin);
  ------------------
  |  |   69|  3.71k|		#define _T(x) x
  ------------------
  154|  3.71k|			DefineFun(_T("acos"), MathImpl<value_type>::ACos);
  ------------------
  |  |   69|  3.71k|		#define _T(x) x
  ------------------
  155|  3.71k|			DefineFun(_T("atan"), MathImpl<value_type>::ATan);
  ------------------
  |  |   69|  3.71k|		#define _T(x) x
  ------------------
  156|  3.71k|			DefineFun(_T("atan2"), MathImpl<value_type>::ATan2);
  ------------------
  |  |   69|  3.71k|		#define _T(x) x
  ------------------
  157|       |			// hyperbolic functions
  158|  3.71k|			DefineFun(_T("sinh"), MathImpl<value_type>::Sinh);
  ------------------
  |  |   69|  3.71k|		#define _T(x) x
  ------------------
  159|  3.71k|			DefineFun(_T("cosh"), MathImpl<value_type>::Cosh);
  ------------------
  |  |   69|  3.71k|		#define _T(x) x
  ------------------
  160|  3.71k|			DefineFun(_T("tanh"), MathImpl<value_type>::Tanh);
  ------------------
  |  |   69|  3.71k|		#define _T(x) x
  ------------------
  161|  3.71k|			DefineFun(_T("coth"), MathImpl<value_type>::Coth);
  ------------------
  |  |   69|  3.71k|		#define _T(x) x
  ------------------
  162|       |			// arcus hyperbolic functions
  163|  3.71k|			DefineFun(_T("asinh"), MathImpl<value_type>::ASinh);
  ------------------
  |  |   69|  3.71k|		#define _T(x) x
  ------------------
  164|  3.71k|			DefineFun(_T("acosh"), MathImpl<value_type>::ACosh);
  ------------------
  |  |   69|  3.71k|		#define _T(x) x
  ------------------
  165|  3.71k|			DefineFun(_T("atanh"), MathImpl<value_type>::ATanh);
  ------------------
  |  |   69|  3.71k|		#define _T(x) x
  ------------------
  166|       |			// Logarithm functions
  167|  3.71k|			DefineFun(_T("log2"), MathImpl<value_type>::Log2);
  ------------------
  |  |   69|  3.71k|		#define _T(x) x
  ------------------
  168|  3.71k|			DefineFun(_T("log10"), MathImpl<value_type>::Log10);
  ------------------
  |  |   69|  3.71k|		#define _T(x) x
  ------------------
  169|  3.71k|			DefineFun(_T("log"), MathImpl<value_type>::Log);
  ------------------
  |  |   69|  3.71k|		#define _T(x) x
  ------------------
  170|  3.71k|			DefineFun(_T("ln"), MathImpl<value_type>::Log);
  ------------------
  |  |   69|  3.71k|		#define _T(x) x
  ------------------
  171|       |			// misc
  172|  3.71k|			DefineFun(_T("exp"), MathImpl<value_type>::Exp);
  ------------------
  |  |   69|  3.71k|		#define _T(x) x
  ------------------
  173|  3.71k|			DefineFun(_T("sqrt"), MathImpl<value_type>::Sqrt);
  ------------------
  |  |   69|  3.71k|		#define _T(x) x
  ------------------
  174|  3.71k|			DefineFun(_T("sign"), MathImpl<value_type>::Sign);
  ------------------
  |  |   69|  3.71k|		#define _T(x) x
  ------------------
  175|  3.71k|			DefineFun(_T("rint"), MathImpl<value_type>::Rint);
  ------------------
  |  |   69|  3.71k|		#define _T(x) x
  ------------------
  176|  3.71k|			DefineFun(_T("abs"), MathImpl<value_type>::Abs);
  ------------------
  |  |   69|  3.71k|		#define _T(x) x
  ------------------
  177|       |			// Functions with variable number of arguments
  178|  3.71k|			DefineFun(_T("sum"), MathImpl<value_type>::Sum);
  ------------------
  |  |   69|  3.71k|		#define _T(x) x
  ------------------
  179|  3.71k|			DefineFun(_T("avg"), MathImpl<value_type>::Avg);
  ------------------
  |  |   69|  3.71k|		#define _T(x) x
  ------------------
  180|  3.71k|			DefineFun(_T("min"), MathImpl<value_type>::Min);
  ------------------
  |  |   69|  3.71k|		#define _T(x) x
  ------------------
  181|  3.71k|			DefineFun(_T("max"), MathImpl<value_type>::Max);
  ------------------
  |  |   69|  3.71k|		#define _T(x) x
  ------------------
  182|       |			// Random number
  183|  3.71k|			DefineFun(_T("rnd"), MathImpl<value_type>::Rnd, false);
  ------------------
  |  |   69|  3.71k|		#define _T(x) x
  ------------------
  184|  3.71k|		}
  185|  3.71k|	}
_ZN2mu6Parser9InitConstEv:
  194|  3.71k|	{
  195|  3.71k|		DefineConst(_T("_pi"), MathImpl<value_type>::CONST_PI);
  ------------------
  |  |   69|  3.71k|		#define _T(x) x
  ------------------
  196|  3.71k|		DefineConst(_T("_e"), MathImpl<value_type>::CONST_E);
  ------------------
  |  |   69|  3.71k|		#define _T(x) x
  ------------------
  197|  3.71k|	}
_ZN2mu6Parser8InitOprtEv:
  205|  3.71k|	{
  206|  3.71k|		DefineInfixOprt(_T("-"), MathImpl<value_type>::UnaryMinus);
  ------------------
  |  |   69|  3.71k|		#define _T(x) x
  ------------------
  207|  3.71k|		DefineInfixOprt(_T("+"), MathImpl<value_type>::UnaryPlus);
  ------------------
  |  |   69|  3.71k|		#define _T(x) x
  ------------------
  208|  3.71k|	}

_ZN2mu10ParserBaseC2Ev:
   91|  3.71k|		: m_pParseFormula(&ParserBase::ParseString)
   92|  3.71k|		, m_vRPN()
   93|  3.71k|		, m_vStringBuf()
   94|  3.71k|		, m_pTokenReader()
   95|  3.71k|		, m_FunDef()
   96|  3.71k|		, m_PostOprtDef()
   97|  3.71k|		, m_InfixOprtDef()
   98|  3.71k|		, m_OprtDef()
   99|  3.71k|		, m_ConstDef()
  100|  3.71k|		, m_StrVarDef()
  101|  3.71k|		, m_VarDef()
  102|  3.71k|		, m_bBuiltInOp(true)
  103|  3.71k|		, m_sNameChars()
  104|  3.71k|		, m_sOprtChars()
  105|  3.71k|		, m_sInfixOprtChars()
  106|  3.71k|		, m_vStackBuffer()
  107|  3.71k|		, m_nFinalResultIdx(0)
  108|  3.71k|	{
  109|  3.71k|		InitTokenReader();
  110|  3.71k|	}
_ZN2mu10ParserBaseD2Ev:
  141|  3.71k|	{}
_ZN2mu10ParserBase15InitTokenReaderEv:
  246|  3.71k|	{
  247|  3.71k|		m_pTokenReader.reset(new token_reader_type(this));
  248|  3.71k|	}
_ZNK2mu10ParserBase6ReInitEv:
  257|   129k|	{
  258|   129k|		m_pParseFormula = &ParserBase::ParseString;
  259|   129k|		m_vStringBuf.clear();
  260|   129k|		m_vRPN.clear();
  261|   129k|		m_pTokenReader->ReInit();
  262|   129k|	}
_ZN2mu10ParserBase11AddValIdentEPFiPKcPiPdE:
  353|  3.71k|	{
  354|  3.71k|		m_pTokenReader->AddValIdent(a_pCallback);
  355|  3.71k|	}
_ZN2mu10ParserBase11AddCallbackERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKNS_14ParserCallbackERNS1_3mapIS7_SA_NS1_4lessIS7_EENS5_INS1_4pairIS8_SA_EEEEEEPKc:
  374|   115k|	{
  375|   115k|		if (!a_Callback.IsValid())
  ------------------
  |  Branch (375:7): [True: 0, False: 115k]
  ------------------
  376|      0|			Error(ecINVALID_FUN_PTR);
  377|       |
  378|   115k|		const funmap_type* pFunMap = &a_Storage;
  379|       |
  380|       |		// Check for conflicting operator or function names
  381|   115k|		if (pFunMap != &m_FunDef && m_FunDef.find(a_strName) != m_FunDef.end())
  ------------------
  |  Branch (381:7): [True: 7.43k, False: 107k]
  |  Branch (381:7): [True: 0, False: 115k]
  |  Branch (381:31): [True: 0, False: 7.43k]
  ------------------
  382|      0|			Error(ecNAME_CONFLICT, -1, a_strName);
  383|       |
  384|   115k|		if (pFunMap != &m_PostOprtDef && m_PostOprtDef.find(a_strName) != m_PostOprtDef.end())
  ------------------
  |  Branch (384:7): [True: 115k, False: 0]
  |  Branch (384:7): [True: 0, False: 115k]
  |  Branch (384:36): [True: 0, False: 115k]
  ------------------
  385|      0|			Error(ecNAME_CONFLICT, -1, a_strName);
  386|       |
  387|   115k|		if (pFunMap != &m_InfixOprtDef && pFunMap != &m_OprtDef && m_InfixOprtDef.find(a_strName) != m_InfixOprtDef.end())
  ------------------
  |  Branch (387:7): [True: 107k, False: 7.43k]
  |  Branch (387:7): [True: 0, False: 115k]
  |  Branch (387:37): [True: 107k, False: 0]
  |  Branch (387:62): [True: 0, False: 107k]
  ------------------
  388|      0|			Error(ecNAME_CONFLICT, -1, a_strName);
  389|       |
  390|   115k|		if (pFunMap != &m_InfixOprtDef && pFunMap != &m_OprtDef && m_OprtDef.find(a_strName) != m_OprtDef.end())
  ------------------
  |  Branch (390:7): [True: 107k, False: 7.43k]
  |  Branch (390:7): [True: 0, False: 115k]
  |  Branch (390:37): [True: 107k, False: 0]
  |  Branch (390:62): [True: 0, False: 107k]
  ------------------
  391|      0|			Error(ecNAME_CONFLICT, -1, a_strName);
  392|       |
  393|   115k|		CheckOprt(a_strName, a_Callback, a_szCharSet);
  394|   115k|		a_Storage[a_strName] = a_Callback;
  395|   115k|		ReInit();
  396|   115k|	}
_ZNK2mu10ParserBase9CheckOprtERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKNS_14ParserCallbackES9_:
  406|   115k|	{
  407|   115k|		if (!a_sName.length() ||
  ------------------
  |  Branch (407:7): [True: 0, False: 115k]
  ------------------
  408|   115k|			(a_sName.find_first_not_of(a_szCharSet) != string_type::npos) ||
  ------------------
  |  Branch (408:4): [True: 0, False: 115k]
  ------------------
  409|   115k|			(a_sName[0] >= '0' && a_sName[0] <= '9'))
  ------------------
  |  Branch (409:5): [True: 107k, False: 7.43k]
  |  Branch (409:26): [True: 0, False: 107k]
  ------------------
  410|      0|		{
  411|      0|			switch (a_Callback.GetCode())
  412|      0|			{
  413|      0|			case cmOPRT_POSTFIX: Error(ecINVALID_POSTFIX_IDENT, -1, a_sName); break;
  ------------------
  |  Branch (413:4): [True: 0, False: 0]
  ------------------
  414|      0|			case cmOPRT_INFIX:   Error(ecINVALID_INFIX_IDENT, -1, a_sName); break;
  ------------------
  |  Branch (414:4): [True: 0, False: 0]
  ------------------
  415|      0|			default:             Error(ecINVALID_NAME, -1, a_sName);
  ------------------
  |  Branch (415:4): [True: 0, False: 0]
  ------------------
  416|      0|			}
  417|      0|		}
  418|   115k|	}
_ZNK2mu10ParserBase9CheckNameERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_:
  425|  7.43k|	{
  426|  7.43k|		if (!a_sName.length() ||
  ------------------
  |  Branch (426:7): [True: 0, False: 7.43k]
  ------------------
  427|  7.43k|			(a_sName.find_first_not_of(a_szCharSet) != string_type::npos) ||
  ------------------
  |  Branch (427:4): [True: 0, False: 7.43k]
  ------------------
  428|  7.43k|			(a_sName[0] >= '0' && a_sName[0] <= '9'))
  ------------------
  |  Branch (428:5): [True: 7.43k, False: 0]
  |  Branch (428:26): [True: 0, False: 7.43k]
  ------------------
  429|      0|		{
  430|      0|			Error(ecINVALID_NAME);
  431|      0|		}
  432|  7.43k|	}
_ZN2mu10ParserBase7SetExprERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  442|  3.71k|	{
  443|       |		// Check locale compatibility
  444|  3.71k|		if (m_pTokenReader->GetArgSep() == std::use_facet<numpunct<char_type> >(s_locale).decimal_point())
  ------------------
  |  Branch (444:7): [True: 0, False: 3.71k]
  ------------------
  445|      0|			Error(ecLOCALE);
  446|       |
  447|       |		// Check maximum allowed expression length. An arbitrary value small enough so i can debug expressions sent to me
  448|  3.71k|		if (a_sExpr.length() >= MaxLenExpression)
  ------------------
  |  Branch (448:7): [True: 30, False: 3.68k]
  ------------------
  449|     30|			Error(ecEXPRESSION_TOO_LONG, 0, a_sExpr);
  450|       |
  451|  3.71k|		m_pTokenReader->SetFormula(a_sExpr + _T(" "));
  ------------------
  |  |   69|  3.71k|		#define _T(x) x
  ------------------
  452|  3.71k|		ReInit();
  453|  3.71k|	}
_ZNK2mu10ParserBase10GetOprtDefEv:
  460|  2.56M|	{
  461|  2.56M|		return (const char_type**)(&c_DefaultOprt[0]);
  462|  2.56M|	}
_ZN2mu10ParserBase15DefineNameCharsEPKc:
  469|  3.71k|	{
  470|  3.71k|		m_sNameChars = a_szCharset;
  471|  3.71k|	}
_ZN2mu10ParserBase15DefineOprtCharsEPKc:
  478|  3.71k|	{
  479|  3.71k|		m_sOprtChars = a_szCharset;
  480|  3.71k|	}
_ZN2mu10ParserBase20DefineInfixOprtCharsEPKc:
  487|  3.71k|	{
  488|  3.71k|		m_sInfixOprtChars = a_szCharset;
  489|  3.71k|	}
_ZNK2mu10ParserBase14ValidNameCharsEv:
  496|  3.10M|	{
  497|  3.10M|		MUP_ASSERT(m_sNameChars.size());
  ------------------
  |  |   78|  3.10M|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 3.10M]
  |  |  ------------------
  |  |   79|  3.10M|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  498|  3.10M|		return m_sNameChars.c_str();
  499|  3.10M|	}
_ZNK2mu10ParserBase14ValidOprtCharsEv:
  506|  2.16M|	{
  507|  2.16M|		MUP_ASSERT(m_sOprtChars.size());
  ------------------
  |  |   78|  2.16M|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 2.16M]
  |  |  ------------------
  |  |   79|  2.16M|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  508|  2.16M|		return m_sOprtChars.c_str();
  509|  2.16M|	}
_ZNK2mu10ParserBase19ValidInfixOprtCharsEv:
  516|  82.1k|	{
  517|  82.1k|		MUP_ASSERT(m_sInfixOprtChars.size());
  ------------------
  |  |   78|  82.1k|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 82.1k]
  |  |  ------------------
  |  |   79|  82.1k|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  518|  82.1k|		return m_sInfixOprtChars.c_str();
  519|  82.1k|	}
_ZN2mu10ParserBase15DefineInfixOprtERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPFddEib:
  556|  7.43k|	{
  557|  7.43k|		if (a_sName.length() > MaxLenIdentifier)
  ------------------
  |  Branch (557:7): [True: 0, False: 7.43k]
  ------------------
  558|      0|			Error(ecIDENTIFIER_TOO_LONG);
  559|       |
  560|  7.43k|		AddCallback(a_sName, ParserCallback(a_pFun, a_bAllowOpt, a_iPrec, cmOPRT_INFIX), m_InfixOprtDef, ValidInfixOprtChars());
  561|  7.43k|	}
_ZN2mu10ParserBase11DefineConstERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEd:
  648|  7.43k|	{
  649|  7.43k|		if (a_sName.length() > MaxLenIdentifier)
  ------------------
  |  Branch (649:7): [True: 0, False: 7.43k]
  ------------------
  650|      0|			Error(ecIDENTIFIER_TOO_LONG);
  651|       |
  652|  7.43k|		CheckName(a_sName, ValidNameChars());
  653|  7.43k|		m_ConstDef[a_sName] = a_fVal;
  654|  7.43k|		ReInit();
  655|  7.43k|	}
_ZNK2mu10ParserBase17GetOprtPrecedenceERKNS_11ParserTokenIdNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE:
  662|   535k|	{
  663|   535k|		switch (a_Tok.GetCode())
  664|   535k|		{
  665|       |			// built in operators
  666|      0|		case cmEND:      return -5;
  ------------------
  |  Branch (666:3): [True: 0, False: 535k]
  ------------------
  667|      0|		case cmARG_SEP:  return -4;
  ------------------
  |  Branch (667:3): [True: 0, False: 535k]
  ------------------
  668|      0|		case cmASSIGN:   return -1;
  ------------------
  |  Branch (668:3): [True: 0, False: 535k]
  ------------------
  669|      0|		case cmELSE:
  ------------------
  |  Branch (669:3): [True: 0, False: 535k]
  ------------------
  670|  2.38k|		case cmIF:       return  0;
  ------------------
  |  Branch (670:3): [True: 2.38k, False: 532k]
  ------------------
  671|  5.42k|		case cmLAND:     return  prLAND;
  ------------------
  |  Branch (671:3): [True: 5.42k, False: 529k]
  ------------------
  672|  3.85k|		case cmLOR:      return  prLOR;
  ------------------
  |  Branch (672:3): [True: 3.85k, False: 531k]
  ------------------
  673|  6.15k|		case cmLT:
  ------------------
  |  Branch (673:3): [True: 6.15k, False: 528k]
  ------------------
  674|  10.6k|		case cmGT:
  ------------------
  |  Branch (674:3): [True: 4.53k, False: 530k]
  ------------------
  675|  11.9k|		case cmLE:
  ------------------
  |  Branch (675:3): [True: 1.23k, False: 533k]
  ------------------
  676|  13.3k|		case cmGE:
  ------------------
  |  Branch (676:3): [True: 1.41k, False: 533k]
  ------------------
  677|  15.9k|		case cmNEQ:
  ------------------
  |  Branch (677:3): [True: 2.58k, False: 532k]
  ------------------
  678|  18.0k|		case cmEQ:       return  prCMP;
  ------------------
  |  Branch (678:3): [True: 2.08k, False: 532k]
  ------------------
  679|  15.8k|		case cmADD:
  ------------------
  |  Branch (679:3): [True: 15.8k, False: 519k]
  ------------------
  680|  95.8k|		case cmSUB:      return  prADD_SUB;
  ------------------
  |  Branch (680:3): [True: 79.9k, False: 455k]
  ------------------
  681|  6.08k|		case cmMUL:
  ------------------
  |  Branch (681:3): [True: 6.08k, False: 528k]
  ------------------
  682|  12.0k|		case cmDIV:      return  prMUL_DIV;
  ------------------
  |  Branch (682:3): [True: 5.96k, False: 529k]
  ------------------
  683|   343k|		case cmPOW:      return  prPOW;
  ------------------
  |  Branch (683:3): [True: 343k, False: 191k]
  ------------------
  684|       |
  685|       |		// user defined binary operators
  686|  54.4k|		case cmOPRT_INFIX:
  ------------------
  |  Branch (686:3): [True: 54.4k, False: 480k]
  ------------------
  687|  54.4k|		case cmOPRT_BIN: return a_Tok.GetPri();
  ------------------
  |  Branch (687:3): [True: 0, False: 535k]
  ------------------
  688|      0|		default:  
  ------------------
  |  Branch (688:3): [True: 0, False: 535k]
  ------------------
  689|      0|			throw exception_type(ecINTERNAL_ERROR, 5, _T(""));
  ------------------
  |  |   69|      0|		#define _T(x) x
  ------------------
  690|   535k|		}
  691|   535k|	}
_ZNK2mu10ParserBase20GetOprtAssociativityERKNS_11ParserTokenIdNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE:
  698|   130k|	{
  699|   130k|		switch (a_Tok.GetCode())
  700|   130k|		{
  701|      0|		case cmASSIGN:
  ------------------
  |  Branch (701:3): [True: 0, False: 130k]
  ------------------
  702|  1.53k|		case cmLAND:
  ------------------
  |  Branch (702:3): [True: 1.53k, False: 128k]
  ------------------
  703|  2.88k|		case cmLOR:
  ------------------
  |  Branch (703:3): [True: 1.34k, False: 129k]
  ------------------
  704|  4.87k|		case cmLT:
  ------------------
  |  Branch (704:3): [True: 1.99k, False: 128k]
  ------------------
  705|  6.55k|		case cmGT:
  ------------------
  |  Branch (705:3): [True: 1.68k, False: 128k]
  ------------------
  706|  7.09k|		case cmLE:
  ------------------
  |  Branch (706:3): [True: 539, False: 129k]
  ------------------
  707|  7.68k|		case cmGE:
  ------------------
  |  Branch (707:3): [True: 586, False: 129k]
  ------------------
  708|  8.79k|		case cmNEQ:
  ------------------
  |  Branch (708:3): [True: 1.11k, False: 129k]
  ------------------
  709|  9.37k|		case cmEQ:
  ------------------
  |  Branch (709:3): [True: 579, False: 129k]
  ------------------
  710|  15.8k|		case cmADD:
  ------------------
  |  Branch (710:3): [True: 6.50k, False: 123k]
  ------------------
  711|  17.8k|		case cmSUB:
  ------------------
  |  Branch (711:3): [True: 1.96k, False: 128k]
  ------------------
  712|  19.9k|		case cmMUL:
  ------------------
  |  Branch (712:3): [True: 2.10k, False: 128k]
  ------------------
  713|  21.7k|		case cmDIV:      return oaLEFT;
  ------------------
  |  Branch (713:3): [True: 1.84k, False: 128k]
  ------------------
  714|   108k|		case cmPOW:      return oaRIGHT;
  ------------------
  |  Branch (714:3): [True: 108k, False: 21.7k]
  ------------------
  715|      0|		case cmOPRT_BIN: return a_Tok.GetAssociativity();
  ------------------
  |  Branch (715:3): [True: 0, False: 130k]
  ------------------
  716|      0|		default:         return oaNONE;
  ------------------
  |  Branch (716:3): [True: 0, False: 130k]
  ------------------
  717|   130k|		}
  718|   130k|	}
_ZNK2mu10ParserBase9ApplyFuncERNSt3__15stackINS_11ParserTokenIdNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS1_5dequeISA_NS7_ISA_EEEEEESF_i:
  868|  24.6k|	{
  869|  24.6k|		MUP_ASSERT(m_pTokenReader.get());
  ------------------
  |  |   78|  24.6k|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 24.6k]
  |  |  ------------------
  |  |   79|  24.6k|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  870|       |
  871|       |		// Operator stack empty or does not contain tokens with callback functions
  872|  24.6k|		if (a_stOpt.empty() || a_stOpt.top().GetFuncAddr() == 0)
  ------------------
  |  Branch (872:7): [True: 0, False: 24.6k]
  |  Branch (872:7): [True: 0, False: 24.6k]
  |  Branch (872:26): [True: 0, False: 24.6k]
  ------------------
  873|      0|			return;
  874|       |
  875|  24.6k|		token_type funTok = a_stOpt.top();
  876|  24.6k|		a_stOpt.pop();
  877|  24.6k|		MUP_ASSERT(funTok.GetFuncAddr() != nullptr);
  ------------------
  |  |   78|  24.6k|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 24.6k]
  |  |  ------------------
  |  |   79|  24.6k|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  878|       |
  879|       |		// Binary operators must rely on their internal operator number
  880|       |		// since counting of operators relies on commas for function arguments
  881|       |		// binary operators do not have commas in their expression
  882|  24.6k|		int iArgCount = (funTok.GetCode() == cmOPRT_BIN) ? funTok.GetArgCount() : a_iArgCount;
  ------------------
  |  Branch (882:19): [True: 0, False: 24.6k]
  ------------------
  883|       |
  884|       |		// determine how many parameters the function needs. To remember iArgCount includes the 
  885|       |		// string parameter whilst GetArgCount() counts only numeric parameters.
  886|  24.6k|		int iArgRequired = funTok.GetArgCount() + ((funTok.GetType() == tpSTR) ? 1 : 0);
  ------------------
  |  Branch (886:46): [True: 0, False: 24.6k]
  ------------------
  887|       |
  888|       |		// That's the number of numerical parameters
  889|  24.6k|		int iArgNumerical = iArgCount - ((funTok.GetType() == tpSTR) ? 1 : 0);
  ------------------
  |  Branch (889:36): [True: 0, False: 24.6k]
  ------------------
  890|       |
  891|  24.6k|		if (funTok.GetCode() == cmFUNC_STR && iArgCount - iArgNumerical > 1)
  ------------------
  |  Branch (891:7): [True: 0, False: 24.6k]
  |  Branch (891:41): [True: 0, False: 0]
  ------------------
  892|      0|			Error(ecINTERNAL_ERROR);
  893|       |
  894|  24.6k|		if (funTok.GetArgCount() >= 0 && iArgCount > iArgRequired)
  ------------------
  |  Branch (894:7): [True: 20.6k, False: 4.01k]
  |  Branch (894:36): [True: 28, False: 20.6k]
  ------------------
  895|     28|			Error(ecTOO_MANY_PARAMS, m_pTokenReader->GetPos() - 1, funTok.GetAsString());
  896|       |
  897|  24.6k|		if (funTok.GetCode() != cmOPRT_BIN && iArgCount < iArgRequired)
  ------------------
  |  Branch (897:7): [True: 24.6k, False: 28]
  |  Branch (897:41): [True: 1, False: 24.6k]
  ------------------
  898|      1|			Error(ecTOO_FEW_PARAMS, m_pTokenReader->GetPos() - 1, funTok.GetAsString());
  899|       |
  900|  24.6k|		if (funTok.GetCode() == cmFUNC_STR && funTok.GetArgCount() >= 0 && iArgCount > iArgRequired)
  ------------------
  |  Branch (900:7): [True: 0, False: 24.6k]
  |  Branch (900:41): [True: 0, False: 0]
  |  Branch (900:70): [True: 0, False: 0]
  ------------------
  901|      0|			Error(ecTOO_MANY_PARAMS, m_pTokenReader->GetPos() - 1, funTok.GetAsString());
  902|       |
  903|       |		// Collect the numeric function arguments from the value stack and store them
  904|       |		// in a vector
  905|  24.6k|		std::vector<token_type> stArg;
  906|   324k|		for (int i = 0; i < iArgNumerical; ++i)
  ------------------
  |  Branch (906:19): [True: 299k, False: 24.6k]
  ------------------
  907|   299k|		{
  908|   299k|			if (a_stVal.empty())
  ------------------
  |  Branch (908:8): [True: 3, False: 299k]
  ------------------
  909|      3|				Error(ecINTERNAL_ERROR, m_pTokenReader->GetPos(), funTok.GetAsString());
  910|       |
  911|   299k|			stArg.push_back(a_stVal.top());
  912|   299k|			a_stVal.pop();
  913|       |
  914|   299k|			if (stArg.back().GetType() == tpSTR && funTok.GetType() != tpSTR)
  ------------------
  |  Branch (914:8): [True: 4, False: 299k]
  |  Branch (914:43): [True: 4, False: 0]
  ------------------
  915|      4|				Error(ecVAL_EXPECTED, m_pTokenReader->GetPos(), funTok.GetAsString());
  916|   299k|		}
  917|       |
  918|  24.6k|		switch (funTok.GetCode())
  919|  24.6k|		{
  920|      0|		case  cmFUNC_STR:
  ------------------
  |  Branch (920:3): [True: 0, False: 24.6k]
  ------------------
  921|      0|			if (a_stVal.empty())
  ------------------
  |  Branch (921:8): [True: 0, False: 0]
  ------------------
  922|      0|				Error(ecINTERNAL_ERROR, m_pTokenReader->GetPos(), funTok.GetAsString());
  923|       |
  924|      0|			stArg.push_back(a_stVal.top());
  925|      0|			a_stVal.pop();
  926|       |
  927|      0|			if (stArg.back().GetType() == tpSTR && funTok.GetType() != tpSTR)
  ------------------
  |  Branch (927:8): [True: 0, False: 0]
  |  Branch (927:43): [True: 0, False: 0]
  ------------------
  928|      0|				Error(ecVAL_EXPECTED, m_pTokenReader->GetPos(), funTok.GetAsString());
  929|       |
  930|      0|			if (funTok.GetArgCount() == -1)
  ------------------
  |  Branch (930:8): [True: 0, False: 0]
  ------------------
  931|      0|			{
  932|       |				// Like multfun_type (e.g. sum()), a vararg string function needs at least one
  933|       |				// numeric argument. Zero would be encoded as argc == -0 == 0 in the bytecode and
  934|       |				// be mistaken for a fixed-arg string function.
  935|      0|				if (iArgNumerical == 0)
  ------------------
  |  Branch (935:9): [True: 0, False: 0]
  ------------------
  936|      0|					Error(ecTOO_FEW_PARAMS, m_pTokenReader->GetPos(), funTok.GetAsString());
  937|       |
  938|      0|				ApplyMultStrFunc(funTok, stArg);
  939|      0|			}
  940|      0|			else
  941|      0|				ApplyStrFunc(funTok, stArg);
  942|      0|			break;
  943|       |
  944|      0|		case  cmFUNC_BULK:
  ------------------
  |  Branch (944:3): [True: 0, False: 24.6k]
  ------------------
  945|      0|			m_vRPN.AddBulkFun(funTok.GetFuncAddr(), (int)stArg.size());
  946|      0|			break;
  947|       |
  948|      0|		case  cmOPRT_BIN:
  ------------------
  |  Branch (948:3): [True: 0, False: 24.6k]
  ------------------
  949|      0|		case  cmOPRT_POSTFIX:
  ------------------
  |  Branch (949:3): [True: 0, False: 24.6k]
  ------------------
  950|  11.1k|		case  cmOPRT_INFIX:
  ------------------
  |  Branch (950:3): [True: 11.1k, False: 13.4k]
  ------------------
  951|  24.6k|		case  cmFUNC:
  ------------------
  |  Branch (951:3): [True: 13.4k, False: 11.1k]
  ------------------
  952|  24.6k|			if (funTok.GetArgCount() == -1 && iArgCount == 0)
  ------------------
  |  Branch (952:8): [True: 4.01k, False: 20.6k]
  |  Branch (952:38): [True: 1, False: 4.01k]
  ------------------
  953|      1|				Error(ecTOO_FEW_PARAMS, m_pTokenReader->GetPos(), funTok.GetAsString());
  954|       |
  955|  24.6k|			m_vRPN.AddFun(funTok.GetFuncAddr(), (funTok.GetArgCount() == -1) ? -iArgNumerical : iArgNumerical, funTok.IsOptimizable());
  ------------------
  |  Branch (955:40): [True: 4.01k, False: 20.6k]
  ------------------
  956|  24.6k|			break;
  957|      0|		default:
  ------------------
  |  Branch (957:3): [True: 0, False: 24.6k]
  ------------------
  958|      0|			break;
  959|  24.6k|		}
  960|       |
  961|       |		// Push dummy value representing the function result to the stack
  962|  24.6k|		token_type token;
  963|  24.6k|		token.SetVal(1);
  964|  24.6k|		a_stVal.push(token);
  965|  24.6k|	}
_ZNK2mu10ParserBase11ApplyIfElseERNSt3__15stackINS_11ParserTokenIdNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS1_5dequeISA_NS7_ISA_EEEEEESF_:
  969|  3.01k|	{
  970|       |		// Check if there is an if Else clause to be calculated
  971|  49.5k|		while (a_stOpt.size() && a_stOpt.top().GetCode() == cmELSE)
  ------------------
  |  Branch (971:10): [True: 49.0k, False: 512]
  |  Branch (971:28): [True: 46.5k, False: 2.49k]
  ------------------
  972|  46.5k|		{
  973|  46.5k|			MUP_ASSERT(!a_stOpt.empty())
  ------------------
  |  |   78|  46.5k|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 46.5k]
  |  |  ------------------
  |  |   79|  46.5k|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  974|  46.5k|			token_type opElse = a_stOpt.top();
  975|  46.5k|			a_stOpt.pop();
  976|       |
  977|       |			// Take the value associated with the else branch from the value stack
  978|  46.5k|			MUP_ASSERT(!a_stVal.empty());
  ------------------
  |  |   78|  46.5k|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 46.5k]
  |  |  ------------------
  |  |   79|  46.5k|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  979|  46.5k|			token_type vVal2 = a_stVal.top();
  980|  46.5k|			if (vVal2.GetType() != tpDBL)
  ------------------
  |  Branch (980:8): [True: 3, False: 46.5k]
  ------------------
  981|      3|				Error(ecUNEXPECTED_STR, m_pTokenReader->GetPos());
  982|       |			
  983|  46.5k|			a_stVal.pop();
  984|       |
  985|       |			// it then else is a ternary operator Pop all three values from the value s
  986|       |			// tack and just return the right value
  987|  46.5k|			MUP_ASSERT(!a_stVal.empty());
  ------------------
  |  |   78|  46.5k|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 1, False: 46.5k]
  |  |  ------------------
  |  |   79|  46.5k|            {														\
  |  |   80|      1|              stringstream_type ss;									\
  |  |   81|      1|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      1|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      1|		#define _T(x) x
  |  |  ------------------
  |  |   82|      1|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      1|		#define _T(x) x
  |  |  ------------------
  |  |   83|      1|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      1|		#define _T(x) x
  |  |  ------------------
  |  |   84|      1|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      1|            }
  ------------------
  988|  46.5k|			token_type vVal1 = a_stVal.top();
  989|  46.5k|			if (vVal1.GetType() != tpDBL)
  ------------------
  |  Branch (989:8): [True: 1, False: 46.5k]
  ------------------
  990|      1|				Error(ecUNEXPECTED_STR, m_pTokenReader->GetPos());
  991|       |
  992|  46.5k|			a_stVal.pop();
  993|       |
  994|  46.5k|			MUP_ASSERT(!a_stVal.empty());
  ------------------
  |  |   78|  46.5k|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 8, False: 46.5k]
  |  |  ------------------
  |  |   79|  46.5k|            {														\
  |  |   80|      8|              stringstream_type ss;									\
  |  |   81|      8|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      8|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      8|		#define _T(x) x
  |  |  ------------------
  |  |   82|      8|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      8|		#define _T(x) x
  |  |  ------------------
  |  |   83|      8|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      8|		#define _T(x) x
  |  |  ------------------
  |  |   84|      8|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      8|            }
  ------------------
  995|  46.5k|			token_type vExpr = a_stVal.top();
  996|  46.5k|			a_stVal.pop();
  997|       |
  998|  46.5k|			a_stVal.push((vExpr.GetVal() != 0) ? vVal1 : vVal2);
  ------------------
  |  Branch (998:17): [True: 3.09k, False: 43.4k]
  ------------------
  999|       |
 1000|  46.5k|			token_type opIf = a_stOpt.top();
 1001|  46.5k|			a_stOpt.pop();
 1002|       |
 1003|  46.5k|			MUP_ASSERT(opElse.GetCode() == cmELSE);
  ------------------
  |  |   78|  46.5k|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 46.5k]
  |  |  ------------------
  |  |   79|  46.5k|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
 1004|       |
 1005|  46.5k|			if (opIf.GetCode() != cmIF)
  ------------------
  |  Branch (1005:8): [True: 4, False: 46.5k]
  ------------------
 1006|      4|				Error(ecMISPLACED_COLON, m_pTokenReader->GetPos());
 1007|       |
 1008|  46.5k|			m_vRPN.AddIfElse(cmENDIF);
 1009|  46.5k|		} // while pending if-else-clause found
 1010|  3.01k|	}
_ZNK2mu10ParserBase12ApplyBinOprtERNSt3__15stackINS_11ParserTokenIdNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS1_5dequeISA_NS7_ISA_EEEEEESF_:
 1017|   124k|	{
 1018|       |		// is it a user defined binary operator?
 1019|   124k|		if (a_stOpt.top().GetCode() == cmOPRT_BIN)
  ------------------
  |  Branch (1019:7): [True: 0, False: 124k]
  ------------------
 1020|      0|		{
 1021|      0|			ApplyFunc(a_stOpt, a_stVal, 2);
 1022|      0|		}
 1023|   124k|		else
 1024|   124k|		{
 1025|   124k|			if (a_stVal.size() < 2)
  ------------------
  |  Branch (1025:8): [True: 1, False: 124k]
  ------------------
 1026|      1|				Error(ecINTERNAL_ERROR, m_pTokenReader->GetPos(), _T("ApplyBinOprt: not enough values in value stack!"));
  ------------------
  |  |   69|      1|		#define _T(x) x
  ------------------
 1027|       |
 1028|   124k|			token_type valTok1 = a_stVal.top();
 1029|   124k|			a_stVal.pop();
 1030|       |
 1031|   124k|			token_type valTok2 = a_stVal.top();
 1032|   124k|			a_stVal.pop();
 1033|       |
 1034|   124k|			token_type optTok = a_stOpt.top();
 1035|   124k|			a_stOpt.pop();
 1036|       |
 1037|   124k|			token_type resTok;
 1038|       |
 1039|   124k|			if (valTok1.GetType() != valTok2.GetType() ||
  ------------------
  |  Branch (1039:8): [True: 12, False: 124k]
  ------------------
 1040|   124k|				(valTok1.GetType() == tpSTR && valTok2.GetType() == tpSTR))
  ------------------
  |  Branch (1040:6): [True: 15, False: 124k]
  |  Branch (1040:36): [True: 15, False: 0]
  ------------------
 1041|     26|				Error(ecOPRT_TYPE_CONFLICT, m_pTokenReader->GetPos(), optTok.GetAsString());
 1042|       |
 1043|   124k|			if (optTok.GetCode() == cmASSIGN)
  ------------------
  |  Branch (1043:8): [True: 0, False: 124k]
  ------------------
 1044|      0|			{
 1045|      0|				if (valTok2.GetCode() != cmVAR)
  ------------------
  |  Branch (1045:9): [True: 0, False: 0]
  ------------------
 1046|      0|					Error(ecUNEXPECTED_OPERATOR, -1, _T("="));
  ------------------
  |  |   69|      0|		#define _T(x) x
  ------------------
 1047|       |
 1048|      0|				m_vRPN.AddAssignOp(valTok2.GetVar());
 1049|      0|			}
 1050|   124k|			else
 1051|   124k|				m_vRPN.AddOp(optTok.GetCode());
 1052|       |
 1053|   124k|			resTok.SetVal(1);
 1054|   124k|			a_stVal.push(resTok);
 1055|   124k|		}
 1056|   124k|	}
_ZNK2mu10ParserBase18ApplyRemainingOprtERNSt3__15stackINS_11ParserTokenIdNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS1_5dequeISA_NS7_ISA_EEEEEESF_:
 1064|   641k|	{
 1065|   675k|		while (stOpt.size() &&
  ------------------
  |  Branch (1065:10): [True: 565k, False: 110k]
  ------------------
 1066|   565k|			stOpt.top().GetCode() != cmBO &&
  ------------------
  |  Branch (1066:4): [True: 234k, False: 330k]
  ------------------
 1067|   234k|			stOpt.top().GetCode() != cmIF)
  ------------------
  |  Branch (1067:4): [True: 34.0k, False: 200k]
  ------------------
 1068|  34.0k|		{
 1069|  34.0k|			token_type tok = stOpt.top();
 1070|  34.0k|			switch (tok.GetCode())
 1071|  34.0k|			{
 1072|  6.71k|			case cmOPRT_INFIX:
  ------------------
  |  Branch (1072:4): [True: 6.71k, False: 27.3k]
  ------------------
 1073|  6.71k|			case cmOPRT_BIN:
  ------------------
  |  Branch (1073:4): [True: 0, False: 34.0k]
  ------------------
 1074|  6.95k|			case cmLE:
  ------------------
  |  Branch (1074:4): [True: 238, False: 33.8k]
  ------------------
 1075|  7.26k|			case cmGE:
  ------------------
  |  Branch (1075:4): [True: 310, False: 33.7k]
  ------------------
 1076|  7.50k|			case cmNEQ:
  ------------------
  |  Branch (1076:4): [True: 243, False: 33.8k]
  ------------------
 1077|  7.96k|			case cmEQ:
  ------------------
  |  Branch (1077:4): [True: 466, False: 33.5k]
  ------------------
 1078|  8.84k|			case cmLT:
  ------------------
  |  Branch (1078:4): [True: 872, False: 33.1k]
  ------------------
 1079|  9.23k|			case cmGT:
  ------------------
  |  Branch (1079:4): [True: 394, False: 33.6k]
  ------------------
 1080|  9.75k|			case cmADD:
  ------------------
  |  Branch (1080:4): [True: 520, False: 33.5k]
  ------------------
 1081|  10.4k|			case cmSUB:
  ------------------
  |  Branch (1081:4): [True: 742, False: 33.3k]
  ------------------
 1082|  11.2k|			case cmMUL:
  ------------------
  |  Branch (1082:4): [True: 747, False: 33.3k]
  ------------------
 1083|  12.0k|			case cmDIV:
  ------------------
  |  Branch (1083:4): [True: 812, False: 33.2k]
  ------------------
 1084|  29.7k|			case cmPOW:
  ------------------
  |  Branch (1084:4): [True: 17.6k, False: 16.3k]
  ------------------
 1085|  30.3k|			case cmLAND:
  ------------------
  |  Branch (1085:4): [True: 616, False: 33.4k]
  ------------------
 1086|  31.0k|			case cmLOR:
  ------------------
  |  Branch (1086:4): [True: 704, False: 33.3k]
  ------------------
 1087|  31.0k|			case cmASSIGN:
  ------------------
  |  Branch (1087:4): [True: 0, False: 34.0k]
  ------------------
 1088|  31.0k|				if (stOpt.top().GetCode() == cmOPRT_INFIX)
  ------------------
  |  Branch (1088:9): [True: 6.71k, False: 24.3k]
  ------------------
 1089|  6.71k|					ApplyFunc(stOpt, stVal, 1);
 1090|  24.3k|				else
 1091|  24.3k|					ApplyBinOprt(stOpt, stVal);
 1092|  31.0k|				break;
 1093|       |
 1094|  3.01k|			case cmELSE:
  ------------------
  |  Branch (1094:4): [True: 3.01k, False: 31.0k]
  ------------------
 1095|  3.01k|				ApplyIfElse(stOpt, stVal);
 1096|  3.01k|				break;
 1097|       |
 1098|      0|			default:
  ------------------
  |  Branch (1098:4): [True: 0, False: 34.0k]
  ------------------
 1099|      0|				Error(ecINTERNAL_ERROR);
 1100|  34.0k|			}
 1101|  34.0k|		}
 1102|   641k|	}
_ZNK2mu10ParserBase12ParseCmdCodeEv:
 1113|  1.03k|	{
 1114|  1.03k|		return ParseCmdCodeBulk(0, 0);
 1115|  1.03k|	}
_ZNK2mu10ParserBase17ParseCmdCodeShortEv:
 1118|    582|	{
 1119|    582|		const SToken *const tok = m_vRPN.GetBase();
 1120|    582|		value_type buf;
 1121|       |
 1122|    582|		switch (tok->Cmd)
 1123|    582|		{
 1124|    579|		case cmVAL:		
  ------------------
  |  Branch (1124:3): [True: 579, False: 3]
  ------------------
 1125|    579|			return tok->Val.data2;
 1126|       |
 1127|      0|		case cmVAR:
  ------------------
  |  Branch (1127:3): [True: 0, False: 582]
  ------------------
 1128|      0|			if (!tok->Val.ptr)
  ------------------
  |  Branch (1128:8): [True: 0, False: 0]
  ------------------
 1129|      0|				throw ParserError(ecINVALID_VAR_PTR);
 1130|      0|			return *tok->Val.ptr;
 1131|       |
 1132|      0|		case cmVARMUL:
  ------------------
  |  Branch (1132:3): [True: 0, False: 582]
  ------------------
 1133|      0|			if (!tok->Val.ptr)
  ------------------
  |  Branch (1133:8): [True: 0, False: 0]
  ------------------
 1134|      0|				throw ParserError(ecINVALID_VAR_PTR);
 1135|      0|			return *tok->Val.ptr * tok->Val.data + tok->Val.data2;
 1136|       |
 1137|      0|		case cmVARPOW2:
  ------------------
  |  Branch (1137:3): [True: 0, False: 582]
  ------------------
 1138|      0|			if (!tok->Val.ptr)
  ------------------
  |  Branch (1138:8): [True: 0, False: 0]
  ------------------
 1139|      0|				throw ParserError(ecINVALID_VAR_PTR);
 1140|      0|			buf = *(tok->Val.ptr);
 1141|      0|			return buf * buf;
 1142|       |
 1143|      0|		case  cmVARPOW3:
  ------------------
  |  Branch (1143:3): [True: 0, False: 582]
  ------------------
 1144|      0|			if (!tok->Val.ptr)
  ------------------
  |  Branch (1144:8): [True: 0, False: 0]
  ------------------
 1145|      0|				throw ParserError(ecINVALID_VAR_PTR);
 1146|      0|			buf = *(tok->Val.ptr);
 1147|      0|			return buf * buf * buf;
 1148|       |
 1149|      0|		case  cmVARPOW4:
  ------------------
  |  Branch (1149:3): [True: 0, False: 582]
  ------------------
 1150|      0|			if (!tok->Val.ptr)
  ------------------
  |  Branch (1150:8): [True: 0, False: 0]
  ------------------
 1151|      0|				throw ParserError(ecINVALID_VAR_PTR);
 1152|      0|			buf = *(tok->Val.ptr);
 1153|      0|			return buf * buf * buf * buf;
 1154|       |
 1155|       |		// numerical function without any argument
 1156|      3|		case cmFUNC:
  ------------------
  |  Branch (1156:3): [True: 3, False: 579]
  ------------------
 1157|      3|			return tok->Fun.cb.call_fun<0>();
 1158|       |
 1159|       |		// String function without a numerical argument
 1160|      0|		case cmFUNC_STR:
  ------------------
  |  Branch (1160:3): [True: 0, False: 582]
  ------------------
 1161|      0|			if (m_vStringBuf.empty())
  ------------------
  |  Branch (1161:8): [True: 0, False: 0]
  ------------------
 1162|      0|				throw ParserError(ecINTERNAL_ERROR);
 1163|       |
 1164|      0|			return tok->Fun.cb.call_strfun<1>(m_vStringBuf[0].c_str());
 1165|       |
 1166|      0|		default:
  ------------------
  |  Branch (1166:3): [True: 0, False: 582]
  ------------------
 1167|      0|			throw ParserError(ecINTERNAL_ERROR);
 1168|    582|		}
 1169|    582|	}
_ZNK2mu10ParserBase16ParseCmdCodeBulkEii:
 1177|  1.03k|	{
 1178|  1.03k|		assert(nThreadID <= s_MaxNumOpenMPThreads);
 1179|       |
 1180|       |		// Note: The check for nOffset==0 and nThreadID here is not necessary but 
 1181|       |		//       brings a minor performance gain when not in bulk mode.
 1182|  1.03k|		value_type *stack = ((nOffset == 0) && (nThreadID == 0)) ? &m_vStackBuffer[0] : &m_vStackBuffer[nThreadID * (m_vStackBuffer.size() / s_MaxNumOpenMPThreads)];
  ------------------
  |  Branch (1182:24): [True: 1.03k, False: 0]
  |  Branch (1182:42): [True: 1.03k, False: 0]
  ------------------
 1183|       |		
 1184|  1.03k|		const int iStackMaxSize = (int)(m_vStackBuffer.size() / s_MaxNumOpenMPThreads);
 1185|       |
 1186|  1.03k|		value_type buf;
 1187|  1.03k|		int sidx(0);
 1188|   550k|		for (const SToken* pTok = m_vRPN.GetBase(); pTok->Cmd != cmEND; ++pTok)
  ------------------
  |  Branch (1188:47): [True: 549k, False: 1.03k]
  ------------------
 1189|   549k|		{
 1190|   549k|			switch (pTok->Cmd)
 1191|   549k|			{
 1192|       |			// built in binary operators
 1193|    259|			case  cmLE:     --sidx; MUP_ASSERT(sidx >= 0); stack[sidx] = stack[sidx] <= stack[sidx + 1]; continue;
  ------------------
  |  |   78|    259|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 259]
  |  |  ------------------
  |  |   79|    259|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  |  Branch (1193:4): [True: 259, False: 548k]
  ------------------
 1194|    279|			case  cmGE:     --sidx; MUP_ASSERT(sidx >= 0); stack[sidx] = stack[sidx] >= stack[sidx + 1]; continue;
  ------------------
  |  |   78|    279|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 279]
  |  |  ------------------
  |  |   79|    279|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  |  Branch (1194:4): [True: 279, False: 548k]
  ------------------
 1195|    339|			case  cmNEQ:    --sidx; MUP_ASSERT(sidx >= 0); stack[sidx] = stack[sidx] != stack[sidx + 1]; continue;
  ------------------
  |  |   78|    339|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 339]
  |  |  ------------------
  |  |   79|    339|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  |  Branch (1195:4): [True: 339, False: 548k]
  ------------------
 1196|    312|			case  cmEQ:     --sidx; MUP_ASSERT(sidx >= 0); stack[sidx] = stack[sidx] == stack[sidx + 1]; continue;
  ------------------
  |  |   78|    312|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 312]
  |  |  ------------------
  |  |   79|    312|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  |  Branch (1196:4): [True: 312, False: 548k]
  ------------------
 1197|    523|			case  cmLT:     --sidx; MUP_ASSERT(sidx >= 0); stack[sidx] = stack[sidx] < stack[sidx + 1];  continue;
  ------------------
  |  |   78|    523|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 523]
  |  |  ------------------
  |  |   79|    523|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  |  Branch (1197:4): [True: 523, False: 548k]
  ------------------
 1198|    472|			case  cmGT:     --sidx; MUP_ASSERT(sidx >= 0); stack[sidx] = stack[sidx] > stack[sidx + 1];  continue;
  ------------------
  |  |   78|    472|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 472]
  |  |  ------------------
  |  |   79|    472|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  |  Branch (1198:4): [True: 472, False: 548k]
  ------------------
 1199|    476|			case  cmADD:    --sidx; MUP_ASSERT(sidx >= 0); stack[sidx] += stack[1 + sidx]; continue;
  ------------------
  |  |   78|    476|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 476]
  |  |  ------------------
  |  |   79|    476|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  |  Branch (1199:4): [True: 476, False: 548k]
  ------------------
 1200|    542|			case  cmSUB:    --sidx; MUP_ASSERT(sidx >= 0); stack[sidx] -= stack[1 + sidx]; continue;
  ------------------
  |  |   78|    542|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 542]
  |  |  ------------------
  |  |   79|    542|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  |  Branch (1200:4): [True: 542, False: 548k]
  ------------------
 1201|  1.20k|			case  cmMUL:    --sidx; MUP_ASSERT(sidx >= 0); stack[sidx] *= stack[1 + sidx]; continue;
  ------------------
  |  |   78|  1.20k|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 1.20k]
  |  |  ------------------
  |  |   79|  1.20k|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  |  Branch (1201:4): [True: 1.20k, False: 547k]
  ------------------
 1202|  1.30k|			case  cmDIV:    --sidx; MUP_ASSERT(sidx >= 0); stack[sidx] /= stack[1 + sidx]; continue;
  ------------------
  |  |   78|  1.30k|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 1.30k]
  |  |  ------------------
  |  |   79|  1.30k|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  |  Branch (1202:4): [True: 1.30k, False: 547k]
  ------------------
 1203|  73.4k|			case  cmPOW:    --sidx; MUP_ASSERT(sidx >= 0); stack[sidx] = MathImpl<value_type>::Pow(stack[sidx], stack[1 + sidx]); continue;
  ------------------
  |  |   78|  73.4k|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 73.4k]
  |  |  ------------------
  |  |   79|  73.4k|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  |  Branch (1203:4): [True: 73.4k, False: 475k]
  ------------------
 1204|    622|			case  cmLAND:   --sidx; MUP_ASSERT(sidx >= 0); stack[sidx] = stack[sidx] && stack[sidx + 1]; continue;
  ------------------
  |  |   78|    622|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 622]
  |  |  ------------------
  |  |   79|    622|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  |  Branch (1204:4): [True: 622, False: 548k]
  |  Branch (1204:65): [True: 377, False: 245]
  |  Branch (1204:80): [True: 236, False: 141]
  ------------------
 1205|    478|			case  cmLOR:    --sidx; MUP_ASSERT(sidx >= 0); stack[sidx] = stack[sidx] || stack[sidx + 1]; continue;
  ------------------
  |  |   78|    478|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 478]
  |  |  ------------------
  |  |   79|    478|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  |  Branch (1205:4): [True: 478, False: 548k]
  |  Branch (1205:65): [True: 251, False: 227]
  |  Branch (1205:80): [True: 22, False: 205]
  ------------------
 1206|      0|			case  cmASSIGN: --sidx; MUP_ASSERT(sidx >= 0); stack[sidx] = *(pTok->Oprt.ptr + nOffset) = stack[sidx + 1]; continue;
  ------------------
  |  |   78|      0|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 0]
  |  |  ------------------
  |  |   79|      0|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  |  Branch (1206:4): [True: 0, False: 549k]
  ------------------
 1207|       |
 1208|  5.19k|			case  cmIF:
  ------------------
  |  Branch (1208:4): [True: 5.19k, False: 543k]
  ------------------
 1209|  5.19k|				if (stack[sidx--] == 0)
  ------------------
  |  Branch (1209:9): [True: 4.30k, False: 893]
  ------------------
 1210|  4.30k|					pTok += pTok->Oprt.offset;
 1211|       |
 1212|  5.19k|				MUP_ASSERT(sidx >= 0);
  ------------------
  |  |   78|  5.19k|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 5.19k]
  |  |  ------------------
  |  |   79|  5.19k|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
 1213|  5.19k|				continue;
 1214|       |
 1215|    893|			case  cmELSE:
  ------------------
  |  Branch (1215:4): [True: 893, False: 548k]
  ------------------
 1216|    893|				pTok += pTok->Oprt.offset;
 1217|    893|				continue;
 1218|       |
 1219|  4.30k|			case  cmENDIF:
  ------------------
  |  Branch (1219:4): [True: 4.30k, False: 544k]
  ------------------
 1220|  4.30k|				continue;
 1221|       |
 1222|       |				// value and variable tokens
 1223|      0|			case  cmVAR:    MUP_ASSERT(sidx < iStackMaxSize); stack[++sidx] = *(pTok->Val.ptr + nOffset);  continue;
  ------------------
  |  |   78|      0|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 0]
  |  |  ------------------
  |  |   79|      0|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  |  Branch (1223:4): [True: 0, False: 549k]
  ------------------
 1224|   453k|			case  cmVAL:    MUP_ASSERT(sidx < iStackMaxSize); stack[++sidx] = pTok->Val.data2;  continue;
  ------------------
  |  |   78|   453k|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 453k]
  |  |  ------------------
  |  |   79|   453k|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  |  Branch (1224:4): [True: 453k, False: 95.9k]
  ------------------
 1225|       |
 1226|      0|			case  cmVARPOW2: 
  ------------------
  |  Branch (1226:4): [True: 0, False: 549k]
  ------------------
 1227|      0|				MUP_ASSERT(sidx < iStackMaxSize);
  ------------------
  |  |   78|      0|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 0]
  |  |  ------------------
  |  |   79|      0|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
 1228|      0|				buf = *(pTok->Val.ptr + nOffset);
 1229|      0|				stack[++sidx] = buf * buf;
 1230|      0|				continue;
 1231|       |
 1232|      0|			case  cmVARPOW3: 
  ------------------
  |  Branch (1232:4): [True: 0, False: 549k]
  ------------------
 1233|      0|				MUP_ASSERT(sidx < iStackMaxSize);
  ------------------
  |  |   78|      0|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 0]
  |  |  ------------------
  |  |   79|      0|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
 1234|      0|				buf = *(pTok->Val.ptr + nOffset);
 1235|      0|				stack[++sidx] = buf * buf * buf;
 1236|      0|				continue;
 1237|       |
 1238|      0|			case  cmVARPOW4: 
  ------------------
  |  Branch (1238:4): [True: 0, False: 549k]
  ------------------
 1239|      0|				MUP_ASSERT(sidx < iStackMaxSize);
  ------------------
  |  |   78|      0|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 0]
  |  |  ------------------
  |  |   79|      0|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
 1240|      0|				buf = *(pTok->Val.ptr + nOffset);
 1241|      0|				stack[++sidx] = buf * buf * buf * buf;
 1242|      0|				continue;
 1243|       |
 1244|      0|			case  cmVARMUL:  
  ------------------
  |  Branch (1244:4): [True: 0, False: 549k]
  ------------------
 1245|      0|				MUP_ASSERT(sidx < iStackMaxSize);
  ------------------
  |  |   78|      0|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 0]
  |  |  ------------------
  |  |   79|      0|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
 1246|      0|				stack[++sidx] = *(pTok->Val.ptr + nOffset) * pTok->Val.data + pTok->Val.data2;
 1247|      0|				continue;
 1248|       |
 1249|       |				// Next is treatment of numeric functions
 1250|  5.30k|			case  cmFUNC:
  ------------------
  |  Branch (1250:4): [True: 5.30k, False: 543k]
  ------------------
 1251|  5.30k|			{
 1252|  5.30k|				int iArgCount = pTok->Fun.argc;
 1253|       |
 1254|       |				// switch according to argument count
 1255|  5.30k|				switch (iArgCount)
 1256|  5.30k|				{
 1257|    639|				case 0: sidx += 1; MUP_ASSERT(sidx < iStackMaxSize); stack[sidx] = pTok->Fun.cb.call_fun<0 >(); continue;
  ------------------
  |  |   78|    639|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 639]
  |  |  ------------------
  |  |   79|    639|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  |  Branch (1257:5): [True: 639, False: 4.66k]
  ------------------
 1258|    696|				case 1:                                              stack[sidx] = pTok->Fun.cb.call_fun<1 >(stack[sidx]); continue;
  ------------------
  |  Branch (1258:5): [True: 696, False: 4.60k]
  ------------------
 1259|    270|				case 2: sidx -= 1; MUP_ASSERT(sidx >= 0); stack[sidx] = pTok->Fun.cb.call_fun<2 >(stack[sidx], stack[sidx + 1]); continue;
  ------------------
  |  |   78|    270|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 270]
  |  |  ------------------
  |  |   79|    270|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  |  Branch (1259:5): [True: 270, False: 5.03k]
  ------------------
 1260|      0|				case 3: sidx -= 2; MUP_ASSERT(sidx >= 0); stack[sidx] = pTok->Fun.cb.call_fun<3 >(stack[sidx], stack[sidx + 1], stack[sidx + 2]); continue;
  ------------------
  |  |   78|      0|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 0]
  |  |  ------------------
  |  |   79|      0|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  |  Branch (1260:5): [True: 0, False: 5.30k]
  ------------------
 1261|      0|				case 4: sidx -= 3; MUP_ASSERT(sidx >= 0); stack[sidx] = pTok->Fun.cb.call_fun<4 >(stack[sidx], stack[sidx + 1], stack[sidx + 2], stack[sidx + 3]); continue;
  ------------------
  |  |   78|      0|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 0]
  |  |  ------------------
  |  |   79|      0|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  |  Branch (1261:5): [True: 0, False: 5.30k]
  ------------------
 1262|      0|				case 5: sidx -= 4; MUP_ASSERT(sidx >= 0); stack[sidx] = pTok->Fun.cb.call_fun<5 >(stack[sidx], stack[sidx + 1], stack[sidx + 2], stack[sidx + 3], stack[sidx + 4]); continue;
  ------------------
  |  |   78|      0|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 0]
  |  |  ------------------
  |  |   79|      0|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  |  Branch (1262:5): [True: 0, False: 5.30k]
  ------------------
 1263|      0|				case 6: sidx -= 5; MUP_ASSERT(sidx >= 0); stack[sidx] = pTok->Fun.cb.call_fun<6 >(stack[sidx], stack[sidx + 1], stack[sidx + 2], stack[sidx + 3], stack[sidx + 4], stack[sidx + 5]); continue;
  ------------------
  |  |   78|      0|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 0]
  |  |  ------------------
  |  |   79|      0|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  |  Branch (1263:5): [True: 0, False: 5.30k]
  ------------------
 1264|      0|				case 7: sidx -= 6; MUP_ASSERT(sidx >= 0); stack[sidx] = pTok->Fun.cb.call_fun<7 >(stack[sidx], stack[sidx + 1], stack[sidx + 2], stack[sidx + 3], stack[sidx + 4], stack[sidx + 5], stack[sidx + 6]); continue;
  ------------------
  |  |   78|      0|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 0]
  |  |  ------------------
  |  |   79|      0|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  |  Branch (1264:5): [True: 0, False: 5.30k]
  ------------------
 1265|      0|				case 8: sidx -= 7; MUP_ASSERT(sidx >= 0); stack[sidx] = pTok->Fun.cb.call_fun<8 >(stack[sidx], stack[sidx + 1], stack[sidx + 2], stack[sidx + 3], stack[sidx + 4], stack[sidx + 5], stack[sidx + 6], stack[sidx + 7]); continue;
  ------------------
  |  |   78|      0|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 0]
  |  |  ------------------
  |  |   79|      0|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  |  Branch (1265:5): [True: 0, False: 5.30k]
  ------------------
 1266|      0|				case 9: sidx -= 8; MUP_ASSERT(sidx >= 0); stack[sidx] = pTok->Fun.cb.call_fun<9 >(stack[sidx], stack[sidx + 1], stack[sidx + 2], stack[sidx + 3], stack[sidx + 4], stack[sidx + 5], stack[sidx + 6], stack[sidx + 7], stack[sidx + 8]); continue;
  ------------------
  |  |   78|      0|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 0]
  |  |  ------------------
  |  |   79|      0|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  |  Branch (1266:5): [True: 0, False: 5.30k]
  ------------------
 1267|      0|				case 10:sidx -= 9; MUP_ASSERT(sidx >= 0); stack[sidx] = pTok->Fun.cb.call_fun<10>(stack[sidx], stack[sidx + 1], stack[sidx + 2], stack[sidx + 3], stack[sidx + 4], stack[sidx + 5], stack[sidx + 6], stack[sidx + 7], stack[sidx + 8], stack[sidx + 9]); continue;
  ------------------
  |  |   78|      0|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 0]
  |  |  ------------------
  |  |   79|      0|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  |  Branch (1267:5): [True: 0, False: 5.30k]
  ------------------
 1268|  3.69k|				default:
  ------------------
  |  Branch (1268:5): [True: 3.69k, False: 1.60k]
  ------------------
 1269|       |					// function with variable arguments store the number as a negative value
 1270|  3.69k|					if (iArgCount > 0)
  ------------------
  |  Branch (1270:10): [True: 0, False: 3.69k]
  ------------------
 1271|      0|						Error(ecINTERNAL_ERROR, -1);
 1272|       |
 1273|  3.69k|					sidx -= -iArgCount - 1;
 1274|  3.69k|					MUP_ASSERT(sidx>=0 && sidx < iStackMaxSize);
  ------------------
  |  |   78|  7.39k|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:19): [True: 3.69k, False: 0]
  |  |  |  Branch (78:19): [True: 3.69k, False: 0]
  |  |  ------------------
  |  |   79|  3.69k|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
 1275|       |
 1276|  3.69k|					stack[sidx] = pTok->Fun.cb.call_multfun(&stack[sidx], -iArgCount);
 1277|  3.69k|					continue;
 1278|  5.30k|				}
 1279|  5.30k|			}
 1280|       |
 1281|       |			// Next is treatment of string functions (fixed-arg and vararg).
 1282|       |			// Negative argc signals vararg (multstrfun_type), same convention as cmFUNC vararg.
 1283|      0|			case  cmFUNC_STR:
  ------------------
  |  Branch (1283:4): [True: 0, False: 549k]
  ------------------
 1284|      0|			{
 1285|       |				// The index of the string argument in the string table
 1286|      0|				int iIdxStack = pTok->Fun.idx;
 1287|      0|				if (iIdxStack < 0 || iIdxStack >= (int)m_vStringBuf.size())
  ------------------
  |  Branch (1287:9): [True: 0, False: 0]
  |  Branch (1287:26): [True: 0, False: 0]
  ------------------
 1288|      0|					Error(ecINTERNAL_ERROR, m_pTokenReader->GetPos());
 1289|       |
 1290|      0|				if (pTok->Fun.argc < 0)
  ------------------
  |  Branch (1290:9): [True: 0, False: 0]
  ------------------
 1291|      0|				{
 1292|       |					// vararg: argc stored as -N where N is the numeric argument count
 1293|      0|					int nArgs = -pTok->Fun.argc;
 1294|      0|					sidx -= nArgs - 1;
 1295|      0|					MUP_ASSERT(sidx >= 0 && sidx < iStackMaxSize);
  ------------------
  |  |   78|      0|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:19): [True: 0, False: 0]
  |  |  |  Branch (78:19): [True: 0, False: 0]
  |  |  ------------------
  |  |   79|      0|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
 1296|      0|					stack[sidx] = pTok->Fun.cb.call_multstrfun(m_vStringBuf[iIdxStack].c_str(), &stack[sidx], nArgs);
 1297|      0|					continue;
 1298|      0|				}
 1299|       |
 1300|      0|				sidx -= pTok->Fun.argc - 1;
 1301|      0|				MUP_ASSERT(sidx >= 0 && sidx < iStackMaxSize);
  ------------------
  |  |   78|      0|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:19): [True: 0, False: 0]
  |  |  |  Branch (78:19): [True: 0, False: 0]
  |  |  ------------------
  |  |   79|      0|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
 1302|       |
 1303|      0|				switch (pTok->Fun.argc)  // switch according to argument count
  ------------------
  |  Branch (1303:13): [True: 0, False: 0]
  ------------------
 1304|      0|				{
 1305|      0|				case 0: stack[sidx] = pTok->Fun.cb.call_strfun<1>(m_vStringBuf[iIdxStack].c_str()); continue;
  ------------------
  |  Branch (1305:5): [True: 0, False: 0]
  ------------------
 1306|      0|				case 1: stack[sidx] = pTok->Fun.cb.call_strfun<2>(m_vStringBuf[iIdxStack].c_str(), stack[sidx]); continue;
  ------------------
  |  Branch (1306:5): [True: 0, False: 0]
  ------------------
 1307|      0|				case 2: stack[sidx] = pTok->Fun.cb.call_strfun<3>(m_vStringBuf[iIdxStack].c_str(), stack[sidx], stack[sidx + 1]); continue;
  ------------------
  |  Branch (1307:5): [True: 0, False: 0]
  ------------------
 1308|      0|				case 3: stack[sidx] = pTok->Fun.cb.call_strfun<4>(m_vStringBuf[iIdxStack].c_str(), stack[sidx], stack[sidx + 1], stack[sidx + 2]); continue;
  ------------------
  |  Branch (1308:5): [True: 0, False: 0]
  ------------------
 1309|      0|				case 4: stack[sidx] = pTok->Fun.cb.call_strfun<5>(m_vStringBuf[iIdxStack].c_str(), stack[sidx], stack[sidx + 1], stack[sidx + 2], stack[sidx + 3]); continue;
  ------------------
  |  Branch (1309:5): [True: 0, False: 0]
  ------------------
 1310|      0|				case 5: stack[sidx] = pTok->Fun.cb.call_strfun<6>(m_vStringBuf[iIdxStack].c_str(), stack[sidx], stack[sidx + 1], stack[sidx + 2], stack[sidx + 3], stack[sidx + 4]); continue;
  ------------------
  |  Branch (1310:5): [True: 0, False: 0]
  ------------------
 1311|      0|				}
 1312|       |
 1313|      0|				continue;
 1314|      0|			}
 1315|       |
 1316|      0|			case  cmFUNC_BULK:
  ------------------
  |  Branch (1316:4): [True: 0, False: 549k]
  ------------------
 1317|      0|			{
 1318|      0|				int iArgCount = pTok->Fun.argc;
 1319|       |
 1320|       |				// switch according to argument count
 1321|      0|				switch (iArgCount)
 1322|      0|				{
 1323|      0|				case 0: sidx += 1;  MUP_ASSERT(sidx < iStackMaxSize); stack[sidx] = pTok->Fun.cb.call_bulkfun<0 >(nOffset, nThreadID); continue;
  ------------------
  |  |   78|      0|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 0]
  |  |  ------------------
  |  |   79|      0|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  |  Branch (1323:5): [True: 0, False: 0]
  ------------------
 1324|      0|				case 1:            stack[sidx] = pTok->Fun.cb.call_bulkfun<1 >(nOffset, nThreadID, stack[sidx]); continue;
  ------------------
  |  Branch (1324:5): [True: 0, False: 0]
  ------------------
 1325|      0|				case 2: sidx -= 1; MUP_ASSERT(sidx >= 0); stack[sidx] = pTok->Fun.cb.call_bulkfun<2 >(nOffset, nThreadID, stack[sidx], stack[sidx + 1]); continue;
  ------------------
  |  |   78|      0|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 0]
  |  |  ------------------
  |  |   79|      0|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  |  Branch (1325:5): [True: 0, False: 0]
  ------------------
 1326|      0|				case 3: sidx -= 2; MUP_ASSERT(sidx >= 0); stack[sidx] = pTok->Fun.cb.call_bulkfun<3 >(nOffset, nThreadID, stack[sidx], stack[sidx + 1], stack[sidx + 2]); continue;
  ------------------
  |  |   78|      0|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 0]
  |  |  ------------------
  |  |   79|      0|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  |  Branch (1326:5): [True: 0, False: 0]
  ------------------
 1327|      0|				case 4: sidx -= 3; MUP_ASSERT(sidx >= 0); stack[sidx] = pTok->Fun.cb.call_bulkfun<4 >(nOffset, nThreadID, stack[sidx], stack[sidx + 1], stack[sidx + 2], stack[sidx + 3]); continue;
  ------------------
  |  |   78|      0|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 0]
  |  |  ------------------
  |  |   79|      0|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  |  Branch (1327:5): [True: 0, False: 0]
  ------------------
 1328|      0|				case 5: sidx -= 4; MUP_ASSERT(sidx >= 0); stack[sidx] = pTok->Fun.cb.call_bulkfun<5 >(nOffset, nThreadID, stack[sidx], stack[sidx + 1], stack[sidx + 2], stack[sidx + 3], stack[sidx + 4]); continue;
  ------------------
  |  |   78|      0|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 0]
  |  |  ------------------
  |  |   79|      0|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  |  Branch (1328:5): [True: 0, False: 0]
  ------------------
 1329|      0|				case 6: sidx -= 5; MUP_ASSERT(sidx >= 0); stack[sidx] = pTok->Fun.cb.call_bulkfun<6 >(nOffset, nThreadID, stack[sidx], stack[sidx + 1], stack[sidx + 2], stack[sidx + 3], stack[sidx + 4], stack[sidx + 5]); continue;
  ------------------
  |  |   78|      0|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 0]
  |  |  ------------------
  |  |   79|      0|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  |  Branch (1329:5): [True: 0, False: 0]
  ------------------
 1330|      0|				case 7: sidx -= 6; MUP_ASSERT(sidx >= 0); stack[sidx] = pTok->Fun.cb.call_bulkfun<7 >(nOffset, nThreadID, stack[sidx], stack[sidx + 1], stack[sidx + 2], stack[sidx + 3], stack[sidx + 4], stack[sidx + 5], stack[sidx + 6]); continue;
  ------------------
  |  |   78|      0|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 0]
  |  |  ------------------
  |  |   79|      0|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  |  Branch (1330:5): [True: 0, False: 0]
  ------------------
 1331|      0|				case 8: sidx -= 7; MUP_ASSERT(sidx >= 0); stack[sidx] = pTok->Fun.cb.call_bulkfun<8 >(nOffset, nThreadID, stack[sidx], stack[sidx + 1], stack[sidx + 2], stack[sidx + 3], stack[sidx + 4], stack[sidx + 5], stack[sidx + 6], stack[sidx + 7]); continue;
  ------------------
  |  |   78|      0|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 0]
  |  |  ------------------
  |  |   79|      0|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  |  Branch (1331:5): [True: 0, False: 0]
  ------------------
 1332|      0|				case 9: sidx -= 8; MUP_ASSERT(sidx >= 0); stack[sidx] = pTok->Fun.cb.call_bulkfun<9 >(nOffset, nThreadID, stack[sidx], stack[sidx + 1], stack[sidx + 2], stack[sidx + 3], stack[sidx + 4], stack[sidx + 5], stack[sidx + 6], stack[sidx + 7], stack[sidx + 8]); continue;
  ------------------
  |  |   78|      0|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 0]
  |  |  ------------------
  |  |   79|      0|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  |  Branch (1332:5): [True: 0, False: 0]
  ------------------
 1333|      0|				case 10:sidx -= 9; MUP_ASSERT(sidx >= 0); stack[sidx] = pTok->Fun.cb.call_bulkfun<10>(nOffset, nThreadID, stack[sidx], stack[sidx + 1], stack[sidx + 2], stack[sidx + 3], stack[sidx + 4], stack[sidx + 5], stack[sidx + 6], stack[sidx + 7], stack[sidx + 8], stack[sidx + 9]); continue;
  ------------------
  |  |   78|      0|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 0]
  |  |  ------------------
  |  |   79|      0|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  |  Branch (1333:5): [True: 0, False: 0]
  ------------------
 1334|      0|				default:
  ------------------
  |  Branch (1334:5): [True: 0, False: 0]
  ------------------
 1335|      0|					throw exception_type(ecINTERNAL_ERROR, 2, _T(""));
  ------------------
  |  |   69|      0|		#define _T(x) x
  ------------------
 1336|      0|				}
 1337|      0|			}
 1338|       |
 1339|      0|			default:
  ------------------
  |  Branch (1339:4): [True: 0, False: 549k]
  ------------------
 1340|      0|				throw exception_type(ecINTERNAL_ERROR, 3, _T(""));
  ------------------
  |  |   69|      0|		#define _T(x) x
  ------------------
 1341|   549k|			} // switch CmdCode
 1342|   549k|		} // for all bytecode tokens
 1343|       |
 1344|  1.03k|		return stack[m_nFinalResultIdx];
 1345|  1.03k|	}
_ZNK2mu10ParserBase9CreateRPNEv:
 1349|  3.68k|	{
 1350|  3.68k|		if (!m_pTokenReader->GetExpr().length())
  ------------------
  |  Branch (1350:7): [True: 0, False: 3.68k]
  ------------------
 1351|      0|			Error(ecUNEXPECTED_EOF, 0);
 1352|       |
 1353|  3.68k|		std::stack<token_type> stOpt, stVal;
 1354|  3.68k|		std::stack<int> stArgCount;
 1355|  3.68k|		token_type opta, opt;  // for storing operators
 1356|  3.68k|		token_type val, tval;  // for storing value
 1357|  3.68k|		int ifElseCounter = 0;
 1358|       |
 1359|  3.68k|		ReInit();
 1360|       |
 1361|       |		// The outermost counter counts the number of separated items
 1362|       |		// such as in "a=10,b=20,c=c+a"
 1363|  3.68k|		stArgCount.push(1);
 1364|       |
 1365|  3.68k|		for (;;)
 1366|  2.17M|		{
 1367|  2.17M|			opt = m_pTokenReader->ReadNextToken();
 1368|       |
 1369|  2.17M|			switch (opt.GetCode())
 1370|  2.17M|			{
 1371|       |			//
 1372|       |			// Next three are different kind of value entries
 1373|       |			//
 1374|  4.26k|			case cmSTRING:
  ------------------
  |  Branch (1374:4): [True: 4.26k, False: 2.16M]
  ------------------
 1375|  4.26k|				if (stOpt.empty())
  ------------------
  |  Branch (1375:9): [True: 74, False: 4.19k]
  ------------------
 1376|     74|					Error(ecSTR_RESULT, m_pTokenReader->GetPos(), opt.GetAsString());
 1377|       |
 1378|  4.26k|				stVal.push(opt);
 1379|  4.26k|				break;
 1380|       |
 1381|      0|			case cmVAR:
  ------------------
  |  Branch (1381:4): [True: 0, False: 2.17M]
  ------------------
 1382|      0|				stVal.push(opt);
 1383|      0|				m_vRPN.AddVar(static_cast<value_type*>(opt.GetVar()));
 1384|      0|				break;
 1385|       |
 1386|   810k|			case cmVAL:
  ------------------
  |  Branch (1386:4): [True: 810k, False: 1.36M]
  ------------------
 1387|   810k|				stVal.push(opt);
 1388|   810k|				m_vRPN.AddVal(opt.GetVal());
 1389|   810k|				break;
 1390|       |
 1391|  68.9k|			case cmELSE:
  ------------------
  |  Branch (1391:4): [True: 68.9k, False: 2.10M]
  ------------------
 1392|  68.9k|				if (stArgCount.empty())
  ------------------
  |  Branch (1392:9): [True: 0, False: 68.9k]
  ------------------
 1393|      0|					Error(ecMISPLACED_COLON, m_pTokenReader->GetPos());
 1394|       |
 1395|  68.9k|				if (stArgCount.top() > 1)
  ------------------
  |  Branch (1395:9): [True: 4, False: 68.9k]
  ------------------
 1396|      4|					Error(ecUNEXPECTED_ARG_SEP, m_pTokenReader->GetPos());
 1397|       |
 1398|  68.9k|				stArgCount.pop();
 1399|       |
 1400|  68.9k|				ifElseCounter--;
 1401|  68.9k|				if (ifElseCounter < 0)
  ------------------
  |  Branch (1401:9): [True: 12, False: 68.9k]
  ------------------
 1402|     12|					Error(ecMISPLACED_COLON, m_pTokenReader->GetPos());
 1403|       |
 1404|  68.9k|				ApplyRemainingOprt(stOpt, stVal);
 1405|  68.9k|				m_vRPN.AddIfElse(cmELSE);
 1406|  68.9k|				stOpt.push(opt);
 1407|  68.9k|				break;
 1408|       |
 1409|   422k|			case cmARG_SEP:
  ------------------
  |  Branch (1409:4): [True: 422k, False: 1.74M]
  ------------------
 1410|   422k|				if (!stOpt.empty() && stOpt.top().GetCode() == cmIF)
  ------------------
  |  Branch (1410:9): [True: 317k, False: 104k]
  |  Branch (1410:27): [True: 5, False: 317k]
  ------------------
 1411|      5|					Error(ecUNEXPECTED_ARG_SEP, m_pTokenReader->GetPos());
 1412|       |
 1413|   422k|				if (stArgCount.empty())
  ------------------
  |  Branch (1413:9): [True: 0, False: 422k]
  ------------------
 1414|      0|					Error(ecUNEXPECTED_ARG_SEP, m_pTokenReader->GetPos());
 1415|       |
 1416|   422k|				++stArgCount.top();
 1417|       |				// Falls through.
 1418|       |				// intentional (no break!)
 1419|       |
 1420|   423k|			case cmEND:
  ------------------
  |  Branch (1420:4): [True: 1.81k, False: 2.16M]
  ------------------
 1421|   423k|				ApplyRemainingOprt(stOpt, stVal);
 1422|   423k|				break;
 1423|       |
 1424|   148k|			case cmBC:
  ------------------
  |  Branch (1424:4): [True: 148k, False: 2.02M]
  ------------------
 1425|   148k|			{
 1426|       |				// The argument count for parameterless functions is zero
 1427|       |				// by default an opening bracket sets parameter count to 1
 1428|       |				// in preparation of arguments to come. If the last token
 1429|       |				// was an opening bracket we know better...
 1430|   148k|				if (opta.GetCode() == cmBO)
  ------------------
  |  Branch (1430:9): [True: 736, False: 147k]
  ------------------
 1431|    736|					--stArgCount.top();
 1432|       |
 1433|   148k|				ApplyRemainingOprt(stOpt, stVal);
 1434|       |
 1435|       |				// Check if the bracket content has been evaluated completely
 1436|   148k|				if (stOpt.size() && stOpt.top().GetCode() == cmBO)
  ------------------
  |  Branch (1436:9): [True: 148k, False: 1]
  |  Branch (1436:25): [True: 17.6k, False: 130k]
  ------------------
 1437|  17.6k|				{
 1438|       |					// if opt is ")" and opta is "(" the bracket has been evaluated, now its time to check
 1439|       |					// if there is either a function or a sign pending
 1440|       |					// neither the opening nor the closing bracket will be pushed back to
 1441|       |					// the operator stack
 1442|       |					// Check if a function is standing in front of the opening bracket, 
 1443|       |					// if yes evaluate it afterwards check for infix operators
 1444|  17.6k|					MUP_ASSERT(stArgCount.size());
  ------------------
  |  |   78|  17.6k|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 17.6k]
  |  |  ------------------
  |  |   79|  17.6k|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
 1445|  17.6k|					int iArgCount = stArgCount.top();
 1446|  17.6k|					stArgCount.pop();
 1447|       |
 1448|  17.6k|					stOpt.pop(); // Take opening bracket from stack
 1449|       |
 1450|  17.6k|					if (iArgCount > 1 && (stOpt.size() == 0 ||
  ------------------
  |  Branch (1450:10): [True: 3.34k, False: 14.3k]
  |  Branch (1450:28): [True: 2, False: 3.34k]
  ------------------
 1451|  3.34k|						(stOpt.top().GetCode() != cmFUNC &&
  ------------------
  |  Branch (1451:8): [True: 20, False: 3.32k]
  ------------------
 1452|     20|							stOpt.top().GetCode() != cmFUNC_BULK &&
  ------------------
  |  Branch (1452:8): [True: 20, False: 0]
  ------------------
 1453|     20|							stOpt.top().GetCode() != cmFUNC_STR &&
  ------------------
  |  Branch (1453:8): [True: 20, False: 0]
  ------------------
 1454|     20|							stOpt.top().GetCode() != cmFUNC_STR)))
  ------------------
  |  Branch (1454:8): [True: 20, False: 0]
  ------------------
 1455|     22|						Error(ecUNEXPECTED_ARG, m_pTokenReader->GetPos());
 1456|       |
 1457|       |					// The opening bracket was popped from the stack now check if there
 1458|       |					// was a function before this bracket
 1459|  17.6k|					if (stOpt.size() &&
  ------------------
  |  Branch (1459:10): [True: 17.3k, False: 325]
  |  Branch (1459:10): [True: 13.4k, False: 4.19k]
  ------------------
 1460|  17.3k|						stOpt.top().GetCode() != cmOPRT_INFIX &&
  ------------------
  |  Branch (1460:7): [True: 16.9k, False: 401]
  ------------------
 1461|  16.9k|						stOpt.top().GetCode() != cmOPRT_BIN &&
  ------------------
  |  Branch (1461:7): [True: 16.9k, False: 0]
  ------------------
 1462|  16.9k|						stOpt.top().GetFuncAddr() != 0)
  ------------------
  |  Branch (1462:7): [True: 13.4k, False: 3.46k]
  ------------------
 1463|  13.4k|					{
 1464|  13.4k|						ApplyFunc(stOpt, stVal, iArgCount);
 1465|  13.4k|					}
 1466|  17.6k|				}
 1467|   148k|			} // if bracket content is evaluated
 1468|   148k|			break;
 1469|       |
 1470|       |			//
 1471|       |			// Next are the binary operator entries
 1472|       |			//
 1473|   148k|			case cmIF:
  ------------------
  |  Branch (1473:4): [True: 130k, False: 2.04M]
  ------------------
 1474|   130k|				ifElseCounter++;
 1475|   130k|				if (ifElseCounter > MaxNestingDepth)
  ------------------
  |  Branch (1475:9): [True: 2, False: 130k]
  ------------------
 1476|      2|					Error(ecNESTING_LIMIT, m_pTokenReader->GetPos());
 1477|       |
 1478|   130k|				stArgCount.push(1);
 1479|       |				// Falls through.
 1480|       |				// intentional (no break!)
 1481|       |
 1482|   133k|			case cmLAND:
  ------------------
  |  Branch (1482:4): [True: 2.28k, False: 2.16M]
  ------------------
 1483|   135k|			case cmLOR:
  ------------------
  |  Branch (1483:4): [True: 2.16k, False: 2.16M]
  ------------------
 1484|   138k|			case cmLT:
  ------------------
  |  Branch (1484:4): [True: 3.09k, False: 2.16M]
  ------------------
 1485|   140k|			case cmGT:
  ------------------
  |  Branch (1485:4): [True: 2.26k, False: 2.16M]
  ------------------
 1486|   141k|			case cmLE:
  ------------------
  |  Branch (1486:4): [True: 822, False: 2.17M]
  ------------------
 1487|   142k|			case cmGE:
  ------------------
  |  Branch (1487:4): [True: 955, False: 2.17M]
  ------------------
 1488|   144k|			case cmNEQ:
  ------------------
  |  Branch (1488:4): [True: 1.43k, False: 2.17M]
  ------------------
 1489|   145k|			case cmEQ:
  ------------------
  |  Branch (1489:4): [True: 1.13k, False: 2.17M]
  ------------------
 1490|   152k|			case cmADD:
  ------------------
  |  Branch (1490:4): [True: 7.83k, False: 2.16M]
  ------------------
 1491|   156k|			case cmSUB:
  ------------------
  |  Branch (1491:4): [True: 3.13k, False: 2.16M]
  ------------------
 1492|   159k|			case cmMUL:
  ------------------
  |  Branch (1492:4): [True: 3.39k, False: 2.16M]
  ------------------
 1493|   162k|			case cmDIV:
  ------------------
  |  Branch (1493:4): [True: 3.39k, False: 2.16M]
  ------------------
 1494|   322k|			case cmPOW:
  ------------------
  |  Branch (1494:4): [True: 159k, False: 2.01M]
  ------------------
 1495|   322k|			case cmASSIGN:
  ------------------
  |  Branch (1495:4): [True: 0, False: 2.17M]
  ------------------
 1496|   322k|			case cmOPRT_BIN:
  ------------------
  |  Branch (1496:4): [True: 0, False: 2.17M]
  ------------------
 1497|       |
 1498|       |				// A binary operator (user defined or built in) has been found. 
 1499|   322k|				while (
 1500|   426k|					stOpt.size() &&
  ------------------
  |  Branch (1500:6): [True: 402k, False: 23.8k]
  ------------------
 1501|   402k|					stOpt.top().GetCode() != cmBO &&
  ------------------
  |  Branch (1501:6): [True: 397k, False: 5.33k]
  ------------------
 1502|   397k|					stOpt.top().GetCode() != cmELSE &&
  ------------------
  |  Branch (1502:6): [True: 331k, False: 66.4k]
  ------------------
 1503|   331k|					stOpt.top().GetCode() != cmIF)
  ------------------
  |  Branch (1503:6): [True: 267k, False: 63.6k]
  ------------------
 1504|   267k|				{
 1505|   267k|					int nPrec1 = GetOprtPrecedence(stOpt.top()),
 1506|   267k|						nPrec2 = GetOprtPrecedence(opt);
 1507|       |
 1508|   267k|					if (stOpt.top().GetCode() == opt.GetCode())
  ------------------
  |  Branch (1508:10): [True: 130k, False: 137k]
  ------------------
 1509|   130k|					{
 1510|       |
 1511|       |						// Deal with operator associativity
 1512|   130k|						EOprtAssociativity eOprtAsct = GetOprtAssociativity(opt);
 1513|   130k|						if ((eOprtAsct == oaRIGHT && (nPrec1 <= nPrec2)) ||
  ------------------
  |  Branch (1513:12): [True: 108k, False: 21.7k]
  |  Branch (1513:36): [True: 108k, False: 0]
  ------------------
 1514|  21.7k|							(eOprtAsct == oaLEFT && (nPrec1 < nPrec2)))
  ------------------
  |  Branch (1514:9): [True: 21.7k, False: 0]
  |  Branch (1514:32): [True: 0, False: 21.7k]
  ------------------
 1515|   108k|						{
 1516|   108k|							break;
 1517|   108k|						}
 1518|   130k|					}
 1519|   137k|					else if (nPrec1 < nPrec2)
  ------------------
  |  Branch (1519:15): [True: 54.7k, False: 82.3k]
  ------------------
 1520|  54.7k|					{
 1521|       |						// In case the operators are not equal the precedence decides alone...
 1522|  54.7k|						break;
 1523|  54.7k|					}
 1524|       |
 1525|   104k|					if (stOpt.top().GetCode() == cmOPRT_INFIX)
  ------------------
  |  Branch (1525:10): [True: 4.45k, False: 99.7k]
  ------------------
 1526|  4.45k|						ApplyFunc(stOpt, stVal, 1);
 1527|  99.7k|					else
 1528|  99.7k|						ApplyBinOprt(stOpt, stVal);
 1529|   104k|				} // while ( ... )
 1530|       |
 1531|   322k|				if (opt.GetCode() == cmIF)
  ------------------
  |  Branch (1531:9): [True: 130k, False: 191k]
  ------------------
 1532|   130k|					m_vRPN.AddIfElse(opt.GetCode());
 1533|       |
 1534|       |				// The operator can't be evaluated right now, push back to the operator stack
 1535|   322k|				stOpt.push(opt);
 1536|   322k|				break;
 1537|       |
 1538|       |				//
 1539|       |				// Last section contains functions and operators implicitly mapped to functions
 1540|       |				//
 1541|   302k|			case cmBO:
  ------------------
  |  Branch (1541:4): [True: 302k, False: 1.86M]
  ------------------
 1542|   302k|				stArgCount.push(1);
 1543|   302k|				stOpt.push(opt);
 1544|   302k|				break;
 1545|       |
 1546|  74.0k|			case cmOPRT_INFIX:
  ------------------
  |  Branch (1546:4): [True: 74.0k, False: 2.09M]
  ------------------
 1547|  88.9k|			case cmFUNC:
  ------------------
  |  Branch (1547:4): [True: 14.9k, False: 2.15M]
  ------------------
 1548|  88.9k|			case cmFUNC_BULK:
  ------------------
  |  Branch (1548:4): [True: 0, False: 2.17M]
  ------------------
 1549|  88.9k|			case cmFUNC_STR:
  ------------------
  |  Branch (1549:4): [True: 0, False: 2.17M]
  ------------------
 1550|  88.9k|				stOpt.push(opt);
 1551|  88.9k|				break;
 1552|       |
 1553|      0|			case cmOPRT_POSTFIX:
  ------------------
  |  Branch (1553:4): [True: 0, False: 2.17M]
  ------------------
 1554|      0|				stOpt.push(opt);
 1555|      0|				ApplyFunc(stOpt, stVal, 1);  // this is the postfix operator
 1556|      0|				break;
 1557|       |
 1558|      0|			default:  Error(ecINTERNAL_ERROR, 3);
  ------------------
  |  Branch (1558:4): [True: 0, False: 2.17M]
  ------------------
 1559|  2.17M|			} // end of switch operator-token
 1560|       |
 1561|  2.16M|			opta = opt;
 1562|       |
 1563|  2.16M|			if (opt.GetCode() == cmEND)
  ------------------
  |  Branch (1563:8): [True: 1.78k, False: 2.16M]
  ------------------
 1564|  1.78k|			{
 1565|  1.78k|				m_vRPN.Finalize();
 1566|  1.78k|				break;
 1567|  1.78k|			}
 1568|       |
 1569|  2.16M|			if (ParserBase::g_DbgDumpStack)
  ------------------
  |  Branch (1569:8): [True: 0, False: 2.16M]
  ------------------
 1570|      0|			{
 1571|      0|				StackDump(stVal, stOpt);
 1572|      0|				m_vRPN.AsciiDump();
 1573|      0|			}
 1574|       |
 1575|       |//			if (ParserBase::g_DbgDumpCmdCode)
 1576|       |				//m_vRPN.AsciiDump();
 1577|  2.16M|		} // while (true)
 1578|       |
 1579|  1.78k|		if (ParserBase::g_DbgDumpCmdCode)
  ------------------
  |  Branch (1579:7): [True: 0, False: 1.78k]
  ------------------
 1580|      0|			m_vRPN.AsciiDump();
 1581|       |
 1582|  1.78k|		if (ifElseCounter > 0)
  ------------------
  |  Branch (1582:7): [True: 144, False: 1.64k]
  ------------------
 1583|    144|			Error(ecMISSING_ELSE_CLAUSE);
 1584|       |
 1585|       |		// get the last value (= final result) from the stack
 1586|  1.78k|		MUP_ASSERT(stArgCount.size() == 1);
  ------------------
  |  |   78|  1.78k|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 4, False: 1.78k]
  |  |  ------------------
  |  |   79|  1.78k|            {														\
  |  |   80|      4|              stringstream_type ss;									\
  |  |   81|      4|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      4|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      4|		#define _T(x) x
  |  |  ------------------
  |  |   82|      4|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      4|		#define _T(x) x
  |  |  ------------------
  |  |   83|      4|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      4|		#define _T(x) x
  |  |  ------------------
  |  |   84|      4|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      4|            }
  ------------------
 1587|  1.78k|		m_nFinalResultIdx = stArgCount.top();
 1588|  1.78k|		if (m_nFinalResultIdx == 0)
  ------------------
  |  Branch (1588:7): [True: 0, False: 1.78k]
  ------------------
 1589|      0|			Error(ecINTERNAL_ERROR, 9);
 1590|       |
 1591|  1.78k|		if (stVal.size() == 0)
  ------------------
  |  Branch (1591:7): [True: 20, False: 1.76k]
  ------------------
 1592|     20|			Error(ecEMPTY_EXPRESSION);
 1593|       |
 1594|       |		// 2020-09-17; fix for https://oss-fuzz.com/testcase-detail/5758791700971520
 1595|       |		// I don't need the value stack any more. Destructively check if all values in the value 
 1596|       |		// stack represent floating point values
 1597|  95.7k|		while (stVal.size())
  ------------------
  |  Branch (1597:10): [True: 93.9k, False: 1.78k]
  ------------------
 1598|  93.9k|		{
 1599|  93.9k|			if (stVal.top().GetType() != tpDBL)
  ------------------
  |  Branch (1599:8): [True: 2, False: 93.9k]
  ------------------
 1600|      2|				Error(ecSTR_RESULT);
 1601|       |
 1602|  93.9k|			stVal.pop();
 1603|  93.9k|		}
 1604|       |
 1605|  1.78k|		m_vStackBuffer.resize(m_vRPN.GetMaxStackSize() * s_MaxNumOpenMPThreads);
 1606|  1.78k|	}
_ZNK2mu10ParserBase11ParseStringEv:
 1618|  3.68k|	{
 1619|  3.68k|		try
 1620|  3.68k|		{
 1621|  3.68k|			CreateRPN();
 1622|       |
 1623|  3.68k|			if (m_vRPN.GetSize() == 2)
  ------------------
  |  Branch (1623:8): [True: 582, False: 3.10k]
  ------------------
 1624|    582|			{
 1625|    582|				m_vRPN.StoreEnvironment(m_pTokenReader->GetExpr(), m_vStringBuf);
 1626|    582|				m_pParseFormula = &ParserBase::ParseCmdCodeShort;
 1627|    582|				m_vStackBuffer[1] = (this->*m_pParseFormula)();
 1628|    582|				return m_vStackBuffer[1];
 1629|    582|			}
 1630|  3.10k|			else
 1631|  3.10k|			{
 1632|  3.10k|				m_vRPN.StoreEnvironment(m_pTokenReader->GetExpr(), m_vStringBuf);
 1633|  3.10k|				m_pParseFormula = &ParserBase::ParseCmdCode;
 1634|  3.10k|				return (this->*m_pParseFormula)();
 1635|  3.10k|			}
 1636|  3.68k|		}
 1637|  3.68k|		catch (ParserError& exc)
 1638|  3.68k|		{
 1639|  2.06k|			exc.SetFormula(m_pTokenReader->GetExpr());
 1640|  2.06k|			throw;
 1641|  2.06k|		}
 1642|  3.68k|	}
_ZNK2mu10ParserBase5ErrorENS_11EErrorCodesEiRKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
 1656|  2.08k|	{
 1657|  2.08k|		throw exception_type(a_iErrc, a_sTok, m_pTokenReader->GetExpr(), a_iPos);
 1658|  2.08k|	}
_ZNK2mu10ParserBase14HasBuiltInOprtEv:
 1793|  5.90M|	{
 1794|  5.90M|		return m_bBuiltInOp;
 1795|  5.90M|	}
_ZNK2mu10ParserBase4EvalEv:
 1910|  3.68k|	{
 1911|  3.68k|		return (this->*m_pParseFormula)();
 1912|  3.68k|	}

_ZN2mu14ParserByteCodeC2Ev:
   52|  3.71k|		: m_iStackPos(0)
   53|  3.71k| 		, m_stringBuffer()
   54|  3.71k|		, m_expr()
   55|  3.71k|		, m_iMaxStackSize(0)
   56|  3.71k|		, m_vRPN()
   57|  3.71k|		, m_bEnableOptimizer(true)
   58|  3.71k|	{
   59|  3.71k|		m_vRPN.reserve(50);
   60|  3.71k|	}
_ZN2mu14ParserByteCode6AddValEd:
  141|   810k|	{
  142|   810k|		++m_iStackPos;
  143|   810k|		m_iMaxStackSize = std::max(m_iMaxStackSize, (size_t)m_iStackPos);
  144|       |
  145|       |		// If optimization does not apply
  146|   810k|		SToken tok;
  147|   810k|		tok.Cmd = cmVAL;
  148|   810k|		tok.Val.ptr = nullptr;
  149|   810k|		tok.Val.data = 0;
  150|   810k|		tok.Val.data2 = a_fVal;
  151|   810k|		m_vRPN.push_back(tok);
  152|   810k|	}
_ZN2mu14ParserByteCode15ConstantFoldingENS_8ECmdCodeE:
  156|  36.8k|	{
  157|  36.8k|		std::size_t sz = m_vRPN.size();
  158|  36.8k|		value_type& x = m_vRPN[sz - 2].Val.data2;
  159|  36.8k|		value_type& y = m_vRPN[sz - 1].Val.data2;
  160|       |
  161|  36.8k|		switch (a_Oprt)
  162|  36.8k|		{
  163|  1.30k|		case cmLAND: x = (x != 0) && (y != 0); m_vRPN.pop_back(); break;
  ------------------
  |  Branch (163:3): [True: 1.30k, False: 35.5k]
  |  Branch (163:20): [True: 699, False: 601]
  |  Branch (163:32): [True: 541, False: 158]
  ------------------
  164|  1.56k|		case cmLOR:  x = (x != 0) || (y != 0); m_vRPN.pop_back(); break;
  ------------------
  |  Branch (164:3): [True: 1.56k, False: 35.2k]
  |  Branch (164:20): [True: 879, False: 689]
  |  Branch (164:32): [True: 321, False: 368]
  ------------------
  165|  2.30k|		case cmLT:   x = x < y;  m_vRPN.pop_back();  break;
  ------------------
  |  Branch (165:3): [True: 2.30k, False: 34.5k]
  ------------------
  166|  1.70k|		case cmGT:   x = x > y;  m_vRPN.pop_back();  break;
  ------------------
  |  Branch (166:3): [True: 1.70k, False: 35.1k]
  ------------------
  167|    514|		case cmLE:   x = x <= y; m_vRPN.pop_back();  break;
  ------------------
  |  Branch (167:3): [True: 514, False: 36.3k]
  ------------------
  168|    648|		case cmGE:   x = x >= y; m_vRPN.pop_back();  break;
  ------------------
  |  Branch (168:3): [True: 648, False: 36.1k]
  ------------------
  169|    816|		case cmNEQ:  x = x != y; m_vRPN.pop_back();  break;
  ------------------
  |  Branch (169:3): [True: 816, False: 36.0k]
  ------------------
  170|    760|		case cmEQ:   x = x == y; m_vRPN.pop_back();  break;
  ------------------
  |  Branch (170:3): [True: 760, False: 36.0k]
  ------------------
  171|  2.56k|		case cmADD:  x = x + y;  m_vRPN.pop_back();  break;
  ------------------
  |  Branch (171:3): [True: 2.56k, False: 34.2k]
  ------------------
  172|  2.34k|		case cmSUB:  x = x - y;  m_vRPN.pop_back();  break;
  ------------------
  |  Branch (172:3): [True: 2.34k, False: 34.5k]
  ------------------
  173|  1.77k|		case cmMUL:  x = x * y;  m_vRPN.pop_back();  break;
  ------------------
  |  Branch (173:3): [True: 1.77k, False: 35.0k]
  ------------------
  174|  1.40k|		case cmDIV:
  ------------------
  |  Branch (174:3): [True: 1.40k, False: 35.4k]
  ------------------
  175|       |			// Leave a division by zero to the evaluation, so it gives inf or nan.
  176|  1.40k|			if (y == 0)
  ------------------
  |  Branch (176:8): [True: 509, False: 894]
  ------------------
  177|    509|				return false;
  178|    894|			x = x / y;
  179|    894|			m_vRPN.pop_back();
  180|    894|			break;
  181|       |
  182|  19.1k|		case cmPOW: x = MathImpl<value_type>::Pow(x, y);
  ------------------
  |  Branch (182:3): [True: 19.1k, False: 17.6k]
  ------------------
  183|  19.1k|			m_vRPN.pop_back();
  184|  19.1k|			break;
  185|       |
  186|      0|		default:
  ------------------
  |  Branch (186:3): [True: 0, False: 36.8k]
  ------------------
  187|      0|			break;
  188|  36.8k|		} // switch opcode
  189|       |
  190|  36.3k|		return true;
  191|  36.8k|	}
_ZN2mu14ParserByteCode5AddOpENS_8ECmdCodeE:
  205|   124k|	{
  206|   124k|		bool bOptimized = false;
  207|       |
  208|   124k|		if (m_bEnableOptimizer)
  ------------------
  |  Branch (208:7): [True: 124k, False: 0]
  ------------------
  209|   124k|		{
  210|   124k|			std::size_t sz = m_vRPN.size();
  211|       |
  212|       |			// Check for foldable constants like:
  213|       |			//   cmVAL cmVAL cmADD 
  214|       |			// where cmADD can stand fopr any binary operator applied to
  215|       |			// two constant values.
  216|   124k|			if (sz >= 2 && m_vRPN[sz - 2].Cmd == cmVAL && m_vRPN[sz - 1].Cmd == cmVAL)
  ------------------
  |  Branch (216:8): [True: 124k, False: 0]
  |  Branch (216:19): [True: 38.7k, False: 85.3k]
  |  Branch (216:50): [True: 36.8k, False: 1.88k]
  ------------------
  217|  36.8k|			{
  218|  36.8k|				bOptimized = ConstantFolding(a_Oprt);
  219|  36.8k|			}
  220|  87.1k|			else
  221|  87.1k|			{
  222|  87.1k|				switch (a_Oprt)
  223|  87.1k|				{
  224|  74.0k|				case  cmPOW:
  ------------------
  |  Branch (224:5): [True: 74.0k, False: 13.1k]
  ------------------
  225|       |					// Optimization for polynomials of low order
  226|  74.0k|					if (m_vRPN[sz - 2].Cmd == cmVAR && m_vRPN[sz - 1].Cmd == cmVAL)
  ------------------
  |  Branch (226:10): [True: 0, False: 74.0k]
  |  Branch (226:41): [True: 0, False: 0]
  ------------------
  227|      0|					{
  228|      0|						if (m_vRPN[sz - 1].Val.data2 == 0)
  ------------------
  |  Branch (228:11): [True: 0, False: 0]
  ------------------
  229|      0|						{
  230|      0|							m_vRPN[sz - 2].Cmd = cmVAL;
  231|      0|							m_vRPN[sz - 2].Val.ptr = nullptr;
  232|      0|							m_vRPN[sz - 2].Val.data = 0;
  233|      0|							m_vRPN[sz - 2].Val.data2 = 1;
  234|      0|						}
  235|      0|						else if (m_vRPN[sz - 1].Val.data2 == 1)
  ------------------
  |  Branch (235:16): [True: 0, False: 0]
  ------------------
  236|      0|							m_vRPN[sz - 2].Cmd = cmVAR;
  237|      0|						else if (m_vRPN[sz - 1].Val.data2 == 2)
  ------------------
  |  Branch (237:16): [True: 0, False: 0]
  ------------------
  238|      0|							m_vRPN[sz - 2].Cmd = cmVARPOW2;
  239|      0|						else if (m_vRPN[sz - 1].Val.data2 == 3)
  ------------------
  |  Branch (239:16): [True: 0, False: 0]
  ------------------
  240|      0|							m_vRPN[sz - 2].Cmd = cmVARPOW3;
  241|      0|						else if (m_vRPN[sz - 1].Val.data2 == 4)
  ------------------
  |  Branch (241:16): [True: 0, False: 0]
  ------------------
  242|      0|							m_vRPN[sz - 2].Cmd = cmVARPOW4;
  243|      0|						else
  244|      0|							break;
  245|       |
  246|      0|						m_vRPN.pop_back();
  247|      0|						bOptimized = true;
  248|      0|					}
  249|  74.0k|					break;
  250|       |
  251|  74.0k|				case  cmSUB:
  ------------------
  |  Branch (251:5): [True: 641, False: 86.5k]
  ------------------
  252|  5.57k|				case  cmADD:
  ------------------
  |  Branch (252:5): [True: 4.93k, False: 82.2k]
  ------------------
  253|       |					// Simple optimization based on pattern recognition for a shitload of different
  254|       |					// bytecode combinations of addition/subtraction
  255|  5.57k|					if ((m_vRPN[sz - 1].Cmd == cmVAR && m_vRPN[sz - 2].Cmd == cmVAL) ||
  ------------------
  |  Branch (255:11): [True: 0, False: 5.57k]
  |  Branch (255:42): [True: 0, False: 0]
  ------------------
  256|  5.57k|						(m_vRPN[sz - 1].Cmd == cmVAL && m_vRPN[sz - 2].Cmd == cmVAR) ||
  ------------------
  |  Branch (256:8): [True: 5.05k, False: 522]
  |  Branch (256:39): [True: 0, False: 5.05k]
  ------------------
  257|  5.57k|						(m_vRPN[sz - 1].Cmd == cmVAL && m_vRPN[sz - 2].Cmd == cmVARMUL) ||
  ------------------
  |  Branch (257:8): [True: 5.05k, False: 522]
  |  Branch (257:39): [True: 0, False: 5.05k]
  ------------------
  258|  5.57k|						(m_vRPN[sz - 1].Cmd == cmVARMUL && m_vRPN[sz - 2].Cmd == cmVAL) ||
  ------------------
  |  Branch (258:8): [True: 0, False: 5.57k]
  |  Branch (258:42): [True: 0, False: 0]
  ------------------
  259|  5.57k|						(m_vRPN[sz - 1].Cmd == cmVAR && m_vRPN[sz - 2].Cmd == cmVAR && m_vRPN[sz - 2].Val.ptr == m_vRPN[sz - 1].Val.ptr) ||
  ------------------
  |  Branch (259:8): [True: 0, False: 5.57k]
  |  Branch (259:39): [True: 0, False: 0]
  |  Branch (259:70): [True: 0, False: 0]
  ------------------
  260|  5.57k|						(m_vRPN[sz - 1].Cmd == cmVAR && m_vRPN[sz - 2].Cmd == cmVARMUL && m_vRPN[sz - 2].Val.ptr == m_vRPN[sz - 1].Val.ptr) ||
  ------------------
  |  Branch (260:8): [True: 0, False: 5.57k]
  |  Branch (260:39): [True: 0, False: 0]
  |  Branch (260:73): [True: 0, False: 0]
  ------------------
  261|  5.57k|						(m_vRPN[sz - 1].Cmd == cmVARMUL && m_vRPN[sz - 2].Cmd == cmVAR && m_vRPN[sz - 2].Val.ptr == m_vRPN[sz - 1].Val.ptr) ||
  ------------------
  |  Branch (261:8): [True: 0, False: 5.57k]
  |  Branch (261:42): [True: 0, False: 0]
  |  Branch (261:73): [True: 0, False: 0]
  ------------------
  262|  5.57k|						(m_vRPN[sz - 1].Cmd == cmVARMUL && m_vRPN[sz - 2].Cmd == cmVARMUL && m_vRPN[sz - 2].Val.ptr == m_vRPN[sz - 1].Val.ptr))
  ------------------
  |  Branch (262:8): [True: 0, False: 5.57k]
  |  Branch (262:42): [True: 0, False: 0]
  |  Branch (262:76): [True: 0, False: 0]
  ------------------
  263|      0|					{
  264|      0|						MUP_ASSERT(
  ------------------
  |  |   78|      0|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:19): [True: 0, False: 0]
  |  |  |  Branch (78:19): [True: 0, False: 0]
  |  |  |  Branch (78:19): [True: 0, False: 0]
  |  |  |  Branch (78:19): [True: 0, False: 0]
  |  |  |  Branch (78:19): [True: 0, False: 0]
  |  |  ------------------
  |  |   79|      0|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  265|      0|							(m_vRPN[sz - 2].Val.ptr == nullptr && m_vRPN[sz - 1].Val.ptr != nullptr) ||
  266|      0|							(m_vRPN[sz - 2].Val.ptr != nullptr && m_vRPN[sz - 1].Val.ptr == nullptr) ||
  267|      0|							(m_vRPN[sz - 2].Val.ptr == m_vRPN[sz - 1].Val.ptr));
  268|       |
  269|      0|						m_vRPN[sz - 2].Cmd = cmVARMUL;
  270|      0|						m_vRPN[sz - 2].Val.ptr = m_vRPN[sz - 2].Val.ptr ? m_vRPN[sz - 2].Val.ptr : m_vRPN[sz - 1].Val.ptr;    // variable
  ------------------
  |  Branch (270:32): [True: 0, False: 0]
  ------------------
  271|      0|						m_vRPN[sz - 2].Val.data2 += ((a_Oprt == cmSUB) ? -1 : 1) * m_vRPN[sz - 1].Val.data2;  // offset
  ------------------
  |  Branch (271:36): [True: 0, False: 0]
  ------------------
  272|      0|						m_vRPN[sz - 2].Val.data += ((a_Oprt == cmSUB) ? -1 : 1) * m_vRPN[sz - 1].Val.data;   // multiplicand
  ------------------
  |  Branch (272:35): [True: 0, False: 0]
  ------------------
  273|      0|						m_vRPN.pop_back();
  274|      0|						bOptimized = true;
  275|      0|					}
  276|  5.57k|					break;
  277|       |
  278|  5.57k|				case  cmMUL:
  ------------------
  |  Branch (278:5): [True: 1.44k, False: 85.7k]
  ------------------
  279|  1.44k|					if ((m_vRPN[sz - 1].Cmd == cmVAR && m_vRPN[sz - 2].Cmd == cmVAL) ||
  ------------------
  |  Branch (279:11): [True: 0, False: 1.44k]
  |  Branch (279:42): [True: 0, False: 0]
  ------------------
  280|  1.44k|						(m_vRPN[sz - 1].Cmd == cmVAL && m_vRPN[sz - 2].Cmd == cmVAR))
  ------------------
  |  Branch (280:8): [True: 610, False: 839]
  |  Branch (280:39): [True: 0, False: 610]
  ------------------
  281|      0|					{
  282|      0|						m_vRPN[sz - 2].Cmd = cmVARMUL;
  283|      0|						m_vRPN[sz - 2].Val.ptr = m_vRPN[sz - 2].Val.ptr ? m_vRPN[sz - 2].Val.ptr : m_vRPN[sz - 1].Val.ptr;
  ------------------
  |  Branch (283:32): [True: 0, False: 0]
  ------------------
  284|      0|						m_vRPN[sz - 2].Val.data = m_vRPN[sz - 2].Val.data2 + m_vRPN[sz - 1].Val.data2;
  285|      0|						m_vRPN[sz - 2].Val.data2 = 0;
  286|      0|						m_vRPN.pop_back();
  287|      0|						bOptimized = true;
  288|      0|					}
  289|  1.44k|					else if (
  290|  1.44k|						(m_vRPN[sz - 1].Cmd == cmVAL && m_vRPN[sz - 2].Cmd == cmVARMUL) ||
  ------------------
  |  Branch (290:8): [True: 610, False: 839]
  |  Branch (290:39): [True: 0, False: 610]
  ------------------
  291|  1.44k|						(m_vRPN[sz - 1].Cmd == cmVARMUL && m_vRPN[sz - 2].Cmd == cmVAL))
  ------------------
  |  Branch (291:8): [True: 0, False: 1.44k]
  |  Branch (291:42): [True: 0, False: 0]
  ------------------
  292|      0|					{
  293|       |						// Optimization: 2*(3*b+1) or (3*b+1)*2 -> 6*b+2
  294|      0|						m_vRPN[sz - 2].Cmd = cmVARMUL;
  295|      0|						m_vRPN[sz - 2].Val.ptr = m_vRPN[sz - 2].Val.ptr ? m_vRPN[sz - 2].Val.ptr : m_vRPN[sz - 1].Val.ptr;
  ------------------
  |  Branch (295:32): [True: 0, False: 0]
  ------------------
  296|      0|						if (m_vRPN[sz - 1].Cmd == cmVAL)
  ------------------
  |  Branch (296:11): [True: 0, False: 0]
  ------------------
  297|      0|						{
  298|      0|							m_vRPN[sz - 2].Val.data *= m_vRPN[sz - 1].Val.data2;
  299|      0|							m_vRPN[sz - 2].Val.data2 *= m_vRPN[sz - 1].Val.data2;
  300|      0|						}
  301|      0|						else
  302|      0|						{
  303|      0|							m_vRPN[sz - 2].Val.data = m_vRPN[sz - 1].Val.data * m_vRPN[sz - 2].Val.data2;
  304|      0|							m_vRPN[sz - 2].Val.data2 = m_vRPN[sz - 1].Val.data2 * m_vRPN[sz - 2].Val.data2;
  305|      0|						}
  306|      0|						m_vRPN.pop_back();
  307|      0|						bOptimized = true;
  308|      0|					}
  309|  1.44k|					else if (
  310|  1.44k|						m_vRPN[sz - 1].Cmd == cmVAR && m_vRPN[sz - 2].Cmd == cmVAR &&
  ------------------
  |  Branch (310:7): [True: 0, False: 1.44k]
  |  Branch (310:38): [True: 0, False: 0]
  ------------------
  311|      0|						m_vRPN[sz - 1].Val.ptr == m_vRPN[sz - 2].Val.ptr)
  ------------------
  |  Branch (311:7): [True: 0, False: 0]
  ------------------
  312|      0|					{
  313|       |						// Optimization: a*a -> a^2
  314|      0|						m_vRPN[sz - 2].Cmd = cmVARPOW2;
  315|      0|						m_vRPN.pop_back();
  316|      0|						bOptimized = true;
  317|      0|					}
  318|  1.44k|					break;
  319|       |
  320|  1.89k|				case cmDIV:
  ------------------
  |  Branch (320:5): [True: 1.89k, False: 85.2k]
  ------------------
  321|  1.89k|					if (m_vRPN[sz - 1].Cmd == cmVAL && m_vRPN[sz - 2].Cmd == cmVARMUL && m_vRPN[sz - 1].Val.data2 != 0)
  ------------------
  |  Branch (321:10): [True: 1.42k, False: 472]
  |  Branch (321:41): [True: 0, False: 1.42k]
  |  Branch (321:75): [True: 0, False: 0]
  ------------------
  322|      0|					{
  323|       |						// Optimization: 4*a/2 -> 2*a
  324|      0|						m_vRPN[sz - 2].Val.data /= m_vRPN[sz - 1].Val.data2;
  325|      0|						m_vRPN[sz - 2].Val.data2 /= m_vRPN[sz - 1].Val.data2;
  326|      0|						m_vRPN.pop_back();
  327|      0|						bOptimized = true;
  328|      0|					}
  329|  1.89k|					break;
  330|       |
  331|       |					// no optimization for other opcodes
  332|  4.19k|				default:
  ------------------
  |  Branch (332:5): [True: 4.19k, False: 82.9k]
  ------------------
  333|  4.19k|					break;
  334|  87.1k|				} // switch a_Oprt
  335|  87.1k|			}
  336|   124k|		}
  337|       |
  338|       |		// If optimization can't be applied just write the value
  339|   124k|		if (!bOptimized)
  ------------------
  |  Branch (339:7): [True: 87.6k, False: 36.3k]
  ------------------
  340|  87.6k|		{
  341|  87.6k|			--m_iStackPos;
  342|  87.6k|			SToken tok;
  343|  87.6k|			tok.Cmd = a_Oprt;
  344|  87.6k|			m_vRPN.push_back(tok);
  345|  87.6k|		}
  346|   124k|	}
_ZN2mu14ParserByteCode9AddIfElseENS_8ECmdCodeE:
  350|   246k|	{
  351|   246k|		SToken tok;
  352|   246k|		tok.Cmd = a_Oprt;
  353|   246k|		m_vRPN.push_back(tok);
  354|   246k|	}
_ZN2mu14ParserByteCode6AddFunENS_21generic_callable_typeEib:
  384|  24.6k|	{
  385|  24.6k|		std::size_t sz = m_vRPN.size();
  386|  24.6k|		bool optimize = false;
  387|       |
  388|       |		// only optimize functions with fixed number of more than a single arguments
  389|  24.6k|		if (isFunctionOptimizable && m_bEnableOptimizer && a_iArgc > 0)
  ------------------
  |  Branch (389:7): [True: 23.8k, False: 734]
  |  Branch (389:32): [True: 23.8k, False: 0]
  |  Branch (389:54): [True: 19.8k, False: 4.01k]
  ------------------
  390|  19.8k|		{
  391|       |			// <ibg 2020-06-10/> Unary Plus is a no-op, optimize it away
  392|  19.8k|			if (a_pFun == generic_callable_type{(erased_fun_type)&MathImpl<value_type>::UnaryPlus, nullptr})
  ------------------
  |  Branch (392:8): [True: 2.42k, False: 17.4k]
  ------------------
  393|  2.42k|				return;
  394|       |
  395|  17.4k|			optimize = true;
  396|       |
  397|  27.6k|			for (int i = 0; i < std::abs(a_iArgc); ++i)
  ------------------
  |  Branch (397:20): [True: 17.6k, False: 9.99k]
  ------------------
  398|  17.6k|			{
  399|  17.6k|				if (m_vRPN[sz - i - 1].Cmd != cmVAL)
  ------------------
  |  Branch (399:9): [True: 7.45k, False: 10.1k]
  ------------------
  400|  7.45k|				{
  401|  7.45k|					optimize = false;
  402|  7.45k|					break;
  403|  7.45k|				}
  404|  17.6k|			}
  405|  17.4k|		}
  406|       |
  407|  22.1k|		if (optimize)
  ------------------
  |  Branch (407:7): [True: 9.99k, False: 12.2k]
  ------------------
  408|  9.99k|		{
  409|  9.99k|			value_type val = 0;
  410|  9.99k|			switch (a_iArgc)
  411|  9.99k|			{
  412|  9.79k|			case 1:  val = a_pFun.call_fun<1>(m_vRPN[sz - 1].Val.data2); break;
  ------------------
  |  Branch (412:4): [True: 9.79k, False: 195]
  ------------------
  413|    195|			case 2:  val = a_pFun.call_fun<2>(m_vRPN[sz - 2].Val.data2, m_vRPN[sz - 1].Val.data2); break;
  ------------------
  |  Branch (413:4): [True: 195, False: 9.79k]
  ------------------
  414|      0|			case 3:  val = a_pFun.call_fun<3>(m_vRPN[sz - 3].Val.data2, m_vRPN[sz - 2].Val.data2, m_vRPN[sz - 1].Val.data2); break;
  ------------------
  |  Branch (414:4): [True: 0, False: 9.99k]
  ------------------
  415|      0|			case 4:  val = a_pFun.call_fun<4>(m_vRPN[sz - 4].Val.data2, m_vRPN[sz - 3].Val.data2, m_vRPN[sz - 2].Val.data2, m_vRPN[sz - 1].Val.data2); break;
  ------------------
  |  Branch (415:4): [True: 0, False: 9.99k]
  ------------------
  416|      0|			case 5:  val = a_pFun.call_fun<5>(m_vRPN[sz - 5].Val.data2, m_vRPN[sz - 4].Val.data2, m_vRPN[sz - 3].Val.data2, m_vRPN[sz - 2].Val.data2, m_vRPN[sz - 1].Val.data2); break;
  ------------------
  |  Branch (416:4): [True: 0, False: 9.99k]
  ------------------
  417|      0|			case 6:  val = a_pFun.call_fun<6>(m_vRPN[sz - 6].Val.data2, m_vRPN[sz - 5].Val.data2, m_vRPN[sz - 4].Val.data2, m_vRPN[sz - 3].Val.data2, m_vRPN[sz - 2].Val.data2, m_vRPN[sz - 1].Val.data2); break;
  ------------------
  |  Branch (417:4): [True: 0, False: 9.99k]
  ------------------
  418|      0|			case 7:  val = a_pFun.call_fun<7>(m_vRPN[sz - 7].Val.data2, m_vRPN[sz - 6].Val.data2, m_vRPN[sz - 5].Val.data2, m_vRPN[sz - 4].Val.data2, m_vRPN[sz - 3].Val.data2, m_vRPN[sz - 2].Val.data2, m_vRPN[sz - 1].Val.data2); break;
  ------------------
  |  Branch (418:4): [True: 0, False: 9.99k]
  ------------------
  419|      0|			case 8:  val = a_pFun.call_fun<8>(m_vRPN[sz - 8].Val.data2, m_vRPN[sz - 7].Val.data2, m_vRPN[sz - 6].Val.data2, m_vRPN[sz - 5].Val.data2, m_vRPN[sz - 4].Val.data2, m_vRPN[sz - 3].Val.data2, m_vRPN[sz - 2].Val.data2, m_vRPN[sz - 1].Val.data2); break;
  ------------------
  |  Branch (419:4): [True: 0, False: 9.99k]
  ------------------
  420|      0|			case 9:  val = a_pFun.call_fun<9>(m_vRPN[sz - 9].Val.data2, m_vRPN[sz - 8].Val.data2, m_vRPN[sz - 7].Val.data2, m_vRPN[sz - 6].Val.data2, m_vRPN[sz - 5].Val.data2, m_vRPN[sz - 4].Val.data2, m_vRPN[sz - 3].Val.data2, m_vRPN[sz - 2].Val.data2, m_vRPN[sz - 1].Val.data2); break;
  ------------------
  |  Branch (420:4): [True: 0, False: 9.99k]
  ------------------
  421|      0|			case 10: val = a_pFun.call_fun<10>(m_vRPN[sz - 10].Val.data2, m_vRPN[sz - 9].Val.data2, m_vRPN[sz - 8].Val.data2, m_vRPN[sz - 7].Val.data2, m_vRPN[sz - 6].Val.data2, m_vRPN[sz - 5].Val.data2, m_vRPN[sz - 4].Val.data2, m_vRPN[sz - 3].Val.data2, m_vRPN[sz - 2].Val.data2, m_vRPN[sz - 1].Val.data2); break;
  ------------------
  |  Branch (421:4): [True: 0, False: 9.99k]
  ------------------
  422|      0|			default:
  ------------------
  |  Branch (422:4): [True: 0, False: 9.99k]
  ------------------
  423|       |				// For now functions with unlimited number of arguments are not optimized
  424|      0|				throw ParserError(ecINTERNAL_ERROR);
  425|  9.99k|			}
  426|       |
  427|       |			// remove the folded values
  428|  9.99k|			m_vRPN.erase(m_vRPN.end() - a_iArgc, m_vRPN.end());
  429|       |
  430|  9.99k|			SToken tok;
  431|  9.99k|			tok.Cmd = cmVAL;
  432|  9.99k|			tok.Val.data = 0;
  433|  9.99k|			tok.Val.data2 = val;
  434|  9.99k|			tok.Val.ptr = nullptr;
  435|  9.99k|			m_vRPN.push_back(tok);
  436|  9.99k|		}
  437|  12.2k|		else
  438|  12.2k|		{
  439|  12.2k|			SToken tok;
  440|  12.2k|			tok.Cmd = cmFUNC;
  441|  12.2k|			tok.Fun.argc = a_iArgc;
  442|  12.2k|			tok.Fun.cb = a_pFun;
  443|  12.2k|			m_vRPN.push_back(tok);
  444|  12.2k|		}
  445|       |
  446|  22.1k|		m_iStackPos = m_iStackPos - std::abs(a_iArgc) + 1;
  447|  22.1k|		m_iMaxStackSize = std::max(m_iMaxStackSize, (size_t)m_iStackPos);
  448|       |
  449|  22.1k|	}
_ZN2mu14ParserByteCode8FinalizeEv:
  519|  1.78k|	{
  520|  1.78k|		SToken tok;
  521|  1.78k|		tok.Cmd = cmEND;
  522|  1.78k|		m_vRPN.push_back(tok);
  523|  1.78k|		rpn_type(m_vRPN).swap(m_vRPN);     // shrink bytecode vector to fit
  524|       |
  525|       |		// Determine the if-then-else jump offsets
  526|  1.78k|		std::stack<int> stIf, stElse;
  527|  1.78k|		int idx;
  528|   863k|		for (int i = 0; i < (int)m_vRPN.size(); ++i)
  ------------------
  |  Branch (528:19): [True: 861k, False: 1.78k]
  ------------------
  529|   861k|		{
  530|   861k|			switch (m_vRPN[i].Cmd)
  531|   861k|			{
  532|  80.3k|			case cmIF:
  ------------------
  |  Branch (532:4): [True: 80.3k, False: 781k]
  ------------------
  533|  80.3k|				stIf.push(i);
  534|  80.3k|				break;
  535|       |
  536|  60.9k|			case cmELSE:
  ------------------
  |  Branch (536:4): [True: 60.9k, False: 800k]
  ------------------
  537|  60.9k|				stElse.push(i);
  538|  60.9k|				if (stIf.empty())
  ------------------
  |  Branch (538:9): [True: 0, False: 60.9k]
  ------------------
  539|      0|					throw ParserError(ecINTERNAL_ERROR);
  540|  60.9k|				idx = stIf.top();
  541|  60.9k|				stIf.pop();
  542|  60.9k|				m_vRPN[idx].Oprt.offset = i - idx;
  543|  60.9k|				break;
  544|       |
  545|  42.7k|			case cmENDIF:
  ------------------
  |  Branch (545:4): [True: 42.7k, False: 819k]
  ------------------
  546|  42.7k|				if (stElse.empty())
  ------------------
  |  Branch (546:9): [True: 0, False: 42.7k]
  ------------------
  547|      0|					throw ParserError(ecINTERNAL_ERROR);
  548|  42.7k|				idx = stElse.top();
  549|  42.7k|				stElse.pop();
  550|  42.7k|				m_vRPN[idx].Oprt.offset = i - idx;
  551|  42.7k|				break;
  552|       |
  553|   677k|			default:
  ------------------
  |  Branch (553:4): [True: 677k, False: 184k]
  ------------------
  554|   677k|				break;
  555|   861k|			}
  556|   861k|		}
  557|  1.78k|	}
_ZNK2mu14ParserByteCode15GetMaxStackSizeEv:
  561|  1.61k|	{
  562|  1.61k|		return m_iMaxStackSize + 1;
  563|  1.61k|	}
_ZN2mu14ParserByteCode5clearEv:
  575|   129k|	{
  576|   129k|		m_vRPN.clear();
  577|   129k|		m_iStackPos = 0;
  578|   129k|		m_iMaxStackSize = 0;
  579|   129k|	}

_ZN2mu14ParserCallbackC2EPFdvEb:
   55|  3.71k|		:m_pFun((void*)a_pFun)
   56|  3.71k|		, m_iArgc(0)
   57|  3.71k|		, m_iPri(-1)
   58|  3.71k|		, m_eOprtAsct(oaNONE)
   59|  3.71k|		, m_iCode(cmFUNC)
   60|  3.71k|		, m_iType(tpDBL)
   61|  3.71k|		, m_bAllowOpti(a_bAllowOpti)
   62|  3.71k|	{}
_ZN2mu14ParserCallbackC2EPFddEbiNS_8ECmdCodeE:
   66|  92.8k|		:m_pFun((void*)a_pFun)
   67|  92.8k|		, m_iArgc(1)
   68|  92.8k|		, m_iPri(a_iPrec)
   69|  92.8k|		, m_eOprtAsct(oaNONE)
   70|  92.8k|		, m_iCode(a_iCode)
   71|  92.8k|		, m_iType(tpDBL)
   72|  92.8k|		, m_bAllowOpti(a_bAllowOpti)
   73|  92.8k|	{}
_ZN2mu14ParserCallbackC2EPFddEb:
   77|  85.4k|		: ParserCallback(a_pFun, a_bAllowOpti, -1, cmFUNC)
   78|  85.4k|	{}
_ZN2mu14ParserCallbackC2EPFdddEb:
   85|  3.71k|		:m_pFun((void*)a_pFun)
   86|  3.71k|		, m_iArgc(2)
   87|  3.71k|		, m_iPri(-1)
   88|  3.71k|		, m_eOprtAsct(oaNONE)
   89|  3.71k|		, m_iCode(cmFUNC)
   90|  3.71k|		, m_iType(tpDBL)
   91|  3.71k|		, m_bAllowOpti(a_bAllowOpti)
   92|  3.71k|	{}
_ZN2mu14ParserCallbackC2EPFdPKdiEb:
  571|  14.8k|		:m_pFun((void*)a_pFun)
  572|  14.8k|		, m_iArgc(CALLBACK_INTERNAL_VAR_ARGS)
  573|  14.8k|		, m_iPri(-1)
  574|  14.8k|		, m_eOprtAsct(oaNONE)
  575|  14.8k|		, m_iCode(cmFUNC)
  576|  14.8k|		, m_iType(tpDBL)
  577|  14.8k|		, m_bAllowOpti(a_bAllowOpti)
  578|  14.8k|	{}
_ZN2mu14ParserCallbackC2Ev:
  737|   680k|		:m_pFun(0)
  738|   680k|		, m_iArgc(0)
  739|   680k|		, m_iPri(-1)
  740|   680k|		, m_eOprtAsct(oaNONE)
  741|   680k|		, m_iCode(cmUNKNOWN)
  742|   680k|		, m_iType(tpVOID)
  743|   680k|		, m_bAllowOpti(0)
  744|   680k|	{}
_ZN2mu14ParserCallbackC2ERKS0_:
  751|   565k|		:ParserCallback()
  752|   565k|	{
  753|   565k|		Assign(ref);
  754|   565k|	}
_ZN2mu14ParserCallbackaSERKS0_:
  757|   115k|	{
  758|   115k|		Assign(ref);
  759|   115k|		return *this;
  760|   115k|	}
_ZN2mu14ParserCallbackD2Ev:
  764|   795k|	{
  765|   795k|		if (m_iArgc & CALLBACK_INTERNAL_WITH_USER_DATA)
  ------------------
  |  Branch (765:7): [True: 0, False: 795k]
  ------------------
  766|      0|			delete reinterpret_cast<CbWithUserData*>(m_pFun);
  767|   795k|	}
_ZN2mu14ParserCallback6AssignERKS0_:
  775|   680k|	{
  776|   680k|		if (this == &ref)
  ------------------
  |  Branch (776:7): [True: 0, False: 680k]
  ------------------
  777|      0|			return;
  778|       |
  779|   680k|		void* newFun = nullptr;
  780|   680k|		if (ref.m_iArgc & CALLBACK_INTERNAL_WITH_USER_DATA)
  ------------------
  |  Branch (780:7): [True: 0, False: 680k]
  ------------------
  781|      0|			newFun = new CbWithUserData(*reinterpret_cast<CbWithUserData*>(ref.m_pFun));
  782|       |
  783|   680k|		if (m_iArgc & CALLBACK_INTERNAL_WITH_USER_DATA)
  ------------------
  |  Branch (783:7): [True: 0, False: 680k]
  ------------------
  784|      0|			delete reinterpret_cast<CbWithUserData*>(m_pFun);
  785|       |
  786|   680k|		if (ref.m_iArgc & CALLBACK_INTERNAL_WITH_USER_DATA)
  ------------------
  |  Branch (786:7): [True: 0, False: 680k]
  ------------------
  787|      0|			m_pFun = newFun;
  788|   680k|		else
  789|   680k|			m_pFun = ref.m_pFun;
  790|       |
  791|   680k|		m_iArgc = ref.m_iArgc;
  792|   680k|		m_bAllowOpti = ref.m_bAllowOpti;
  793|   680k|		m_iCode = ref.m_iCode;
  794|   680k|		m_iType = ref.m_iType;
  795|   680k|		m_iPri = ref.m_iPri;
  796|   680k|		m_eOprtAsct = ref.m_eOprtAsct;
  797|   680k|	}
_ZNK2mu14ParserCallback5CloneEv:
  802|   476k|	{
  803|   476k|		return new ParserCallback(*this);
  804|   476k|	}
_ZNK2mu14ParserCallback13IsOptimizableEv:
  813|  24.6k|	{
  814|  24.6k|		return m_bAllowOpti;
  815|  24.6k|	}
_ZNK2mu14ParserCallback7GetAddrEv:
  826|   418k|	{
  827|   418k|		if (m_iArgc & CALLBACK_INTERNAL_WITH_USER_DATA)
  ------------------
  |  Branch (827:7): [True: 0, False: 418k]
  ------------------
  828|      0|			return reinterpret_cast<CbWithUserData*>(m_pFun)->pFun;
  829|   418k|		else
  830|   418k|			return m_pFun;
  831|   418k|	}
_ZNK2mu14ParserCallback11GetUserDataEv:
  839|  91.1k|	{
  840|  91.1k|		if (m_iArgc & CALLBACK_INTERNAL_WITH_USER_DATA)
  ------------------
  |  Branch (840:7): [True: 0, False: 91.1k]
  ------------------
  841|      0|			return reinterpret_cast<CbWithUserData*>(m_pFun)->pUserData;
  842|  91.1k|		else
  843|  91.1k|			return nullptr;
  844|  91.1k|	}
_ZNK2mu14ParserCallback7IsValidEv:
  854|   327k|	{
  855|   327k|		return GetAddr() != nullptr
  ------------------
  |  Branch (855:10): [True: 327k, False: 0]
  ------------------
  856|   327k|			&& !((m_iArgc & CALLBACK_INTERNAL_WITH_USER_DATA)
  ------------------
  |  Branch (856:9): [True: 0, False: 327k]
  ------------------
  857|      0|			     && GetUserData() == nullptr);
  ------------------
  |  Branch (857:12): [True: 0, False: 0]
  ------------------
  858|   327k|	}
_ZNK2mu14ParserCallback7GetCodeEv:
  863|   865k|	{
  864|   865k|		return m_iCode;
  865|   865k|	}
_ZNK2mu14ParserCallback7GetTypeEv:
  869|  49.3k|	{
  870|  49.3k|		return m_iType;
  871|  49.3k|	}
_ZNK2mu14ParserCallback6GetPriEv:
  880|  54.4k|	{
  881|  54.4k|		return m_iPri;
  882|  54.4k|	}
_ZNK2mu14ParserCallback7GetArgcEv:
  901|  98.5k|	{
  902|  98.5k|		return (m_iArgc & CALLBACK_INTERNAL_VAR_ARGS) ? -1 : (m_iArgc & CALLBACK_INTERNAL_FIXED_ARGS_MASK);
  ------------------
  |  Branch (902:10): [True: 16.0k, False: 82.4k]
  ------------------
  903|  98.5k|	}

_ZN2mu14ParserErrorMsg8InstanceEv:
   41|  2.09k|	{
   42|  2.09k|		static const ParserErrorMsg instance;
   43|  2.09k|		return instance;
   44|  2.09k|	}
_ZNK2mu14ParserErrorMsgixEj:
   48|  2.09k|	{
   49|  2.09k|		return (a_iIdx < m_vErrMsg.size()) ? m_vErrMsg[a_iIdx] : string_type();
  ------------------
  |  Branch (49:10): [True: 2.09k, False: 0]
  ------------------
   50|  2.09k|	}
_ZN2mu14ParserErrorMsgC2Ev:
   54|      1|		:m_vErrMsg(0)
   55|      1|	{
   56|      1|		m_vErrMsg.resize(ecCOUNT);
   57|       |
   58|      1|		m_vErrMsg[ecUNASSIGNABLE_TOKEN] = _T("Unexpected token \"$TOK$\" found at position $POS$.");
  ------------------
  |  |   69|      1|		#define _T(x) x
  ------------------
   59|      1|		m_vErrMsg[ecINTERNAL_ERROR] = _T("Internal error");
  ------------------
  |  |   69|      1|		#define _T(x) x
  ------------------
   60|      1|		m_vErrMsg[ecINVALID_NAME] = _T("Invalid function-, variable- or constant name: \"$TOK$\".");
  ------------------
  |  |   69|      1|		#define _T(x) x
  ------------------
   61|      1|		m_vErrMsg[ecINVALID_BINOP_IDENT] = _T("Invalid binary operator identifier: \"$TOK$\".");
  ------------------
  |  |   69|      1|		#define _T(x) x
  ------------------
   62|      1|		m_vErrMsg[ecINVALID_INFIX_IDENT] = _T("Invalid infix operator identifier: \"$TOK$\".");
  ------------------
  |  |   69|      1|		#define _T(x) x
  ------------------
   63|      1|		m_vErrMsg[ecINVALID_POSTFIX_IDENT] = _T("Invalid postfix operator identifier: \"$TOK$\".");
  ------------------
  |  |   69|      1|		#define _T(x) x
  ------------------
   64|      1|		m_vErrMsg[ecINVALID_FUN_PTR] = _T("Invalid pointer to callback function.");
  ------------------
  |  |   69|      1|		#define _T(x) x
  ------------------
   65|      1|		m_vErrMsg[ecEMPTY_EXPRESSION] = _T("Expression is empty.");
  ------------------
  |  |   69|      1|		#define _T(x) x
  ------------------
   66|      1|		m_vErrMsg[ecINVALID_VAR_PTR] = _T("Invalid pointer to variable.");
  ------------------
  |  |   69|      1|		#define _T(x) x
  ------------------
   67|      1|		m_vErrMsg[ecUNEXPECTED_OPERATOR] = _T("Unexpected operator \"$TOK$\" found at position $POS$");
  ------------------
  |  |   69|      1|		#define _T(x) x
  ------------------
   68|      1|		m_vErrMsg[ecUNEXPECTED_EOF] = _T("Unexpected end of expression at position $POS$");
  ------------------
  |  |   69|      1|		#define _T(x) x
  ------------------
   69|      1|		m_vErrMsg[ecUNEXPECTED_ARG_SEP] = _T("Unexpected argument separator at position $POS$");
  ------------------
  |  |   69|      1|		#define _T(x) x
  ------------------
   70|      1|		m_vErrMsg[ecUNEXPECTED_PARENS] = _T("Unexpected parenthesis \"$TOK$\" at position $POS$");
  ------------------
  |  |   69|      1|		#define _T(x) x
  ------------------
   71|      1|		m_vErrMsg[ecUNEXPECTED_FUN] = _T("Unexpected function \"$TOK$\" at position $POS$");
  ------------------
  |  |   69|      1|		#define _T(x) x
  ------------------
   72|      1|		m_vErrMsg[ecUNEXPECTED_VAL] = _T("Unexpected value \"$TOK$\" found at position $POS$");
  ------------------
  |  |   69|      1|		#define _T(x) x
  ------------------
   73|      1|		m_vErrMsg[ecUNEXPECTED_VAR] = _T("Unexpected variable \"$TOK$\" found at position $POS$");
  ------------------
  |  |   69|      1|		#define _T(x) x
  ------------------
   74|      1|		m_vErrMsg[ecUNEXPECTED_ARG] = _T("Function arguments used without a function (position: $POS$)");
  ------------------
  |  |   69|      1|		#define _T(x) x
  ------------------
   75|      1|		m_vErrMsg[ecMISSING_PARENS] = _T("Missing parenthesis");
  ------------------
  |  |   69|      1|		#define _T(x) x
  ------------------
   76|      1|		m_vErrMsg[ecTOO_MANY_PARAMS] = _T("Too many parameters for function \"$TOK$\" at expression position $POS$");
  ------------------
  |  |   69|      1|		#define _T(x) x
  ------------------
   77|      1|		m_vErrMsg[ecTOO_FEW_PARAMS] = _T("Too few parameters for function \"$TOK$\" at expression position $POS$");
  ------------------
  |  |   69|      1|		#define _T(x) x
  ------------------
   78|      1|		m_vErrMsg[ecDIV_BY_ZERO] = _T("Divide by zero");
  ------------------
  |  |   69|      1|		#define _T(x) x
  ------------------
   79|      1|		m_vErrMsg[ecDOMAIN_ERROR] = _T("Domain error");
  ------------------
  |  |   69|      1|		#define _T(x) x
  ------------------
   80|      1|		m_vErrMsg[ecNAME_CONFLICT] = _T("Name conflict");
  ------------------
  |  |   69|      1|		#define _T(x) x
  ------------------
   81|      1|		m_vErrMsg[ecOPT_PRI] = _T("Invalid value for operator priority (must be greater or equal to zero).");
  ------------------
  |  |   69|      1|		#define _T(x) x
  ------------------
   82|      1|		m_vErrMsg[ecBUILTIN_OVERLOAD] = _T("user defined binary operator \"$TOK$\" conflicts with a built in operator.");
  ------------------
  |  |   69|      1|		#define _T(x) x
  ------------------
   83|      1|		m_vErrMsg[ecUNEXPECTED_STR] = _T("Unexpected string token found at position $POS$.");
  ------------------
  |  |   69|      1|		#define _T(x) x
  ------------------
   84|      1|		m_vErrMsg[ecUNTERMINATED_STRING] = _T("Unterminated string starting at position $POS$.");
  ------------------
  |  |   69|      1|		#define _T(x) x
  ------------------
   85|      1|		m_vErrMsg[ecSTRING_EXPECTED] = _T("String function called with a non string type of argument.");
  ------------------
  |  |   69|      1|		#define _T(x) x
  ------------------
   86|      1|		m_vErrMsg[ecVAL_EXPECTED] = _T("String value used where a numerical argument is expected.");
  ------------------
  |  |   69|      1|		#define _T(x) x
  ------------------
   87|      1|		m_vErrMsg[ecOPRT_TYPE_CONFLICT] = _T("No suitable overload for operator \"$TOK$\" at position $POS$.");
  ------------------
  |  |   69|      1|		#define _T(x) x
  ------------------
   88|      1|		m_vErrMsg[ecSTR_RESULT] = _T("Strings must only be used as function arguments!");
  ------------------
  |  |   69|      1|		#define _T(x) x
  ------------------
   89|      1|		m_vErrMsg[ecGENERIC] = _T("Parser error.");
  ------------------
  |  |   69|      1|		#define _T(x) x
  ------------------
   90|      1|		m_vErrMsg[ecLOCALE] = _T("Decimal separator is identic to function argument separator.");
  ------------------
  |  |   69|      1|		#define _T(x) x
  ------------------
   91|      1|		m_vErrMsg[ecUNEXPECTED_CONDITIONAL] = _T("The \"$TOK$\" operator must be preceded by a closing bracket.");
  ------------------
  |  |   69|      1|		#define _T(x) x
  ------------------
   92|      1|		m_vErrMsg[ecMISSING_ELSE_CLAUSE] = _T("If-then-else operator is missing an else clause");
  ------------------
  |  |   69|      1|		#define _T(x) x
  ------------------
   93|      1|		m_vErrMsg[ecMISPLACED_COLON] = _T("Misplaced colon at position $POS$");
  ------------------
  |  |   69|      1|		#define _T(x) x
  ------------------
   94|      1|		m_vErrMsg[ecUNREASONABLE_NUMBER_OF_COMPUTATIONS] = _T("Number of computations to small for bulk mode. (Vectorisation overhead too costly)");
  ------------------
  |  |   69|      1|		#define _T(x) x
  ------------------
   95|      1|		m_vErrMsg[ecIDENTIFIER_TOO_LONG] = _T("Identifier too long.");
  ------------------
  |  |   69|      1|		#define _T(x) x
  ------------------
   96|      1|		m_vErrMsg[ecEXPRESSION_TOO_LONG] = _T("Expression too long.");
  ------------------
  |  |   69|      1|		#define _T(x) x
  ------------------
   97|      1|		m_vErrMsg[ecINVALID_CHARACTERS_FOUND] = _T("Invalid non printable characters found in expression/identifer!");
  ------------------
  |  |   69|      1|		#define _T(x) x
  ------------------
   98|      1|		m_vErrMsg[ecBYTECODE_IMPORT_EXPORT_DISABLED] = _T("Bytecode cannot be imported or exported when parser is using a variable factory!");
  ------------------
  |  |   69|      1|		#define _T(x) x
  ------------------
   99|      1|		m_vErrMsg[ecUNARY_PLUS_IN_FRONT_OF_FUNCTION] = _T("Unary plus operator is not allowed in front of functions!");
  ------------------
  |  |   69|      1|		#define _T(x) x
  ------------------
  100|      1|		m_vErrMsg[ecNESTING_LIMIT] = _T("Expression too complex. Nesting limit reached!");
  ------------------
  |  |   69|      1|		#define _T(x) x
  ------------------
  101|       |
  102|     44|		for (int i = 0; i < ecCOUNT; ++i)
  ------------------
  |  Branch (102:19): [True: 43, False: 1]
  ------------------
  103|     43|		{
  104|     43|			if (!m_vErrMsg[i].length())
  ------------------
  |  Branch (104:8): [True: 0, False: 43]
  ------------------
  105|      0|				throw std::runtime_error("Error definitions are incomplete!");
  106|     43|		}
  107|      1|	}
_ZN2mu11ParserErrorC2ENS_11EErrorCodesE:
  132|      3|		:m_strMsg()
  133|      3|		, m_strFormula()
  134|      3|		, m_strTok()
  135|      3|		, m_iPos(-1)
  136|      3|		, m_iErrc(a_iErrc)
  137|      3|		, m_ErrMsg(ParserErrorMsg::Instance())
  138|      3|	{
  139|      3|		m_strMsg = m_ErrMsg[m_iErrc];
  140|      3|		stringstream_type stream;
  141|      3|		stream << (int)m_iPos;
  142|      3|		ReplaceSubString(m_strMsg, _T("$POS$"), stream.str());
  ------------------
  |  |   69|      3|		#define _T(x) x
  ------------------
  143|      3|		ReplaceSubString(m_strMsg, _T("$TOK$"), m_strTok);
  ------------------
  |  |   69|      3|		#define _T(x) x
  ------------------
  144|      3|	}
_ZN2mu11ParserErrorC2ENS_11EErrorCodesERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEESA_i:
  166|  2.08k|		:m_strMsg()
  167|  2.08k|		, m_strFormula(sExpr)
  168|  2.08k|		, m_strTok(sTok)
  169|  2.08k|		, m_iPos(iPos)
  170|  2.08k|		, m_iErrc(iErrc)
  171|  2.08k|		, m_ErrMsg(ParserErrorMsg::Instance())
  172|  2.08k|	{
  173|  2.08k|		m_strMsg = m_ErrMsg[m_iErrc];
  174|  2.08k|		stringstream_type stream;
  175|  2.08k|		stream << (int)m_iPos;
  176|  2.08k|		ReplaceSubString(m_strMsg, _T("$POS$"), stream.str());
  ------------------
  |  |   69|  2.08k|		#define _T(x) x
  ------------------
  177|  2.08k|		ReplaceSubString(m_strMsg, _T("$TOK$"), m_strTok);
  ------------------
  |  |   69|  2.08k|		#define _T(x) x
  ------------------
  178|  2.08k|	}
_ZN2mu11ParserErrorC2ENS_11EErrorCodesEiRKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
  187|     13|		:m_strMsg()
  188|     13|		, m_strFormula()
  189|     13|		, m_strTok(sTok)
  190|     13|		, m_iPos(iPos)
  191|     13|		, m_iErrc(iErrc)
  192|     13|		, m_ErrMsg(ParserErrorMsg::Instance())
  193|     13|	{
  194|     13|		m_strMsg = m_ErrMsg[m_iErrc];
  195|     13|		stringstream_type stream;
  196|     13|		stream << (int)m_iPos;
  197|     13|		ReplaceSubString(m_strMsg, _T("$POS$"), stream.str());
  ------------------
  |  |   69|     13|		#define _T(x) x
  ------------------
  198|     13|		ReplaceSubString(m_strMsg, _T("$TOK$"), m_strTok);
  ------------------
  |  |   69|     13|		#define _T(x) x
  ------------------
  199|     13|	}
_ZN2mu11ParserErrorD2Ev:
  250|  2.09k|	{}
_ZN2mu11ParserError16ReplaceSubStringERNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKS7_SA_:
  260|  4.19k|	{
  261|  4.19k|		string_type strResult;
  262|  4.19k|		string_type::size_type iPos(0), iNext(0);
  263|       |
  264|  4.19k|		for (;;)
  265|  6.71k|		{
  266|  6.71k|			iNext = strSource.find(strFind, iPos);
  267|  6.71k|			strResult.append(strSource, iPos, iNext - iPos);
  268|       |
  269|  6.71k|			if (iNext == string_type::npos)
  ------------------
  |  Branch (269:8): [True: 4.19k, False: 2.52k]
  ------------------
  270|  4.19k|				break;
  271|       |
  272|  2.52k|			strResult.append(strReplaceWith);
  273|  2.52k|			iPos = iNext + strFind.length();
  274|  2.52k|		}
  275|       |
  276|  4.19k|		strSource.swap(strResult);
  277|  4.19k|	}
_ZN2mu11ParserError10SetFormulaERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  293|  2.06k|	{
  294|  2.06k|		m_strFormula = a_strFormula;
  295|  2.06k|	}

_ZN2mu17ParserTokenReaderC2EPNS_10ParserBaseE:
  122|  3.71k|		:m_pParser(a_pParent)
  123|  3.71k|		, m_strFormula()
  124|  3.71k|		, m_iPos(0)
  125|  3.71k|		, m_iSynFlags(0)
  126|  3.71k|		, m_bIgnoreUndefVar(false)
  127|  3.71k|		, m_pFunDef(nullptr)
  128|  3.71k|		, m_pPostOprtDef(nullptr)
  129|  3.71k|		, m_pInfixOprtDef(nullptr)
  130|  3.71k|		, m_pOprtDef(nullptr)
  131|  3.71k|		, m_pConstDef(nullptr)
  132|  3.71k|		, m_pStrVarDef(nullptr)
  133|  3.71k|		, m_pVarDef(nullptr)
  134|  3.71k|		, m_pFactory(nullptr)
  135|  3.71k|		, m_pFactoryData(nullptr)
  136|  3.71k|		, m_vIdentFun()
  137|  3.71k|		, m_UsedVar()
  138|  3.71k|		, m_fZero(0)
  139|  3.71k|		, m_bracketStack()
  140|  3.71k|		, m_lastTok()
  141|  3.71k|		, m_cArgSep(',')
  142|  3.71k|	{
  143|  3.71k|		MUP_ASSERT(m_pParser != nullptr);
  ------------------
  |  |   78|  3.71k|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 3.71k]
  |  |  ------------------
  |  |   79|  3.71k|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  144|  3.71k|		SetParent(m_pParser);
  145|  3.71k|	}
_ZN2mu17ParserTokenReader16SaveBeforeReturnERKNS_11ParserTokenIdNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE:
  165|  2.17M|	{
  166|  2.17M|		m_lastTok = tok;
  167|  2.17M|		return m_lastTok;
  168|  2.17M|	}
_ZN2mu17ParserTokenReader11AddValIdentEPFiPKcPiPdE:
  172|  3.71k|	{
  173|       |		// Use push_front is used to give user defined callbacks a higher priority than
  174|       |		// the built in ones. Otherwise reading hex numbers would not work
  175|       |		// since the "0" in "0xff" would always be read first making parsing of 
  176|       |		// the rest impossible.
  177|       |		// reference:
  178|       |		// http://sourceforge.net/projects/muparser/forums/forum/462843/topic/4824956
  179|  3.71k|		m_vIdentFun.push_front(a_pCallback);
  180|  3.71k|	}
_ZNK2mu17ParserTokenReader6GetPosEv:
  196|    191|	{
  197|    191|		return m_iPos;
  198|    191|	}
_ZNK2mu17ParserTokenReader7GetExprEv:
  207|  9.45k|	{
  208|  9.45k|		return m_strFormula;
  209|  9.45k|	}
_ZN2mu17ParserTokenReader10SetFormulaERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  225|  3.68k|	{
  226|  3.68k|		m_strFormula = a_strFormula;
  227|  3.68k|		ReInit();
  228|  3.68k|	}
_ZN2mu17ParserTokenReader6ReInitEv:
  254|   133k|	{
  255|   133k|		m_iPos = 0;
  256|   133k|		m_iSynFlags = sfSTART_OF_LINE;
  257|   133k|		m_bracketStack = std::stack<int>();
  258|   133k|		m_UsedVar.clear();
  259|   133k|		m_lastTok = token_type();
  260|   133k|	}
_ZN2mu17ParserTokenReader13ReadNextTokenEv:
  265|  2.17M|	{
  266|  2.17M|		MUP_ASSERT(m_pParser != nullptr);
  ------------------
  |  |   78|  2.17M|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 2.17M]
  |  |  ------------------
  |  |   79|  2.17M|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  267|       |
  268|  2.17M|		const char_type* szExpr = m_strFormula.c_str();
  269|  2.17M|		token_type tok;
  270|       |
  271|       |		// Ignore all non printable characters when reading the expression
  272|  2.17M|		while (szExpr[m_iPos] > 0 && szExpr[m_iPos] <= 0x20)
  ------------------
  |  Branch (272:10): [True: 2.17M, False: 2.68k]
  |  Branch (272:32): [True: 4.79k, False: 2.16M]
  ------------------
  273|  4.79k|		{
  274|       |			// 14-31 are control characters. I don't want to have to deal with such strings at all!
  275|       |			// (see https://en.cppreference.com/w/cpp/string/byte/isprint)
  276|  4.79k|			if (szExpr[m_iPos] >= 14 && szExpr[m_iPos] <= 31)
  ------------------
  |  Branch (276:8): [True: 3.02k, False: 1.77k]
  |  Branch (276:32): [True: 15, False: 3.01k]
  ------------------
  277|     15|				Error(ecINVALID_CHARACTERS_FOUND, m_iPos);
  278|       |
  279|  4.79k|			++m_iPos;
  280|  4.79k|		}
  281|       |
  282|       |		// Check for end of formula
  283|  2.17M|		if (IsEOF(tok))
  ------------------
  |  Branch (283:7): [True: 1.81k, False: 2.16M]
  ------------------
  284|  1.81k|			return SaveBeforeReturn(tok);
  285|       |
  286|       |		// Check for user defined binary operator
  287|  2.16M|		if (IsOprt(tok))
  ------------------
  |  Branch (287:7): [True: 0, False: 2.16M]
  ------------------
  288|      0|			return SaveBeforeReturn(tok);
  289|       |
  290|       |		// Check for function token
  291|  2.16M|		if (IsFunTok(tok))
  ------------------
  |  Branch (291:7): [True: 14.9k, False: 2.15M]
  ------------------
  292|  14.9k|			return SaveBeforeReturn(tok);
  293|       |
  294|       |		// Check built in operators / tokens
  295|  2.15M|		if (IsBuiltIn(tok))
  ------------------
  |  Branch (295:7): [True: 916k, False: 1.23M]
  ------------------
  296|   916k|			return SaveBeforeReturn(tok);
  297|       |
  298|       |		// Check for function argument separators
  299|  1.23M|		if (IsArgSep(tok))
  ------------------
  |  Branch (299:7): [True: 422k, False: 816k]
  ------------------
  300|   422k|			return SaveBeforeReturn(tok);
  301|       |
  302|       |		// Check for values / constant tokens
  303|   816k|		if (IsValTok(tok))
  ------------------
  |  Branch (303:7): [True: 810k, False: 5.96k]
  ------------------
  304|   810k|			return SaveBeforeReturn(tok);
  305|       |
  306|       |		// Check for variable tokens
  307|  5.96k|		if (IsVarTok(tok))
  ------------------
  |  Branch (307:7): [True: 0, False: 5.96k]
  ------------------
  308|      0|			return SaveBeforeReturn(tok);
  309|       |
  310|       |		// Check for string variables
  311|  5.96k|		if (IsStrVarTok(tok))
  ------------------
  |  Branch (311:7): [True: 0, False: 5.96k]
  ------------------
  312|      0|			return SaveBeforeReturn(tok);
  313|       |
  314|       |		// Check for String tokens
  315|  5.96k|		if (IsString(tok))
  ------------------
  |  Branch (315:7): [True: 4.26k, False: 1.69k]
  ------------------
  316|  4.26k|			return SaveBeforeReturn(tok);
  317|       |
  318|       |		// Check for unary operators
  319|  1.69k|		if (IsInfixOpTok(tok))
  ------------------
  |  Branch (319:7): [True: 0, False: 1.69k]
  ------------------
  320|      0|			return SaveBeforeReturn(tok);
  321|       |
  322|       |		// Check for unary operators
  323|  1.69k|		if (IsPostOpTok(tok))
  ------------------
  |  Branch (323:7): [True: 0, False: 1.69k]
  ------------------
  324|      0|			return SaveBeforeReturn(tok);
  325|       |
  326|       |		// Check String for undefined variable token. Done only if a 
  327|       |		// flag is set indicating to ignore undefined variables.
  328|       |		// This is a way to conditionally avoid an error if 
  329|       |		// undefined variables occur. 
  330|       |		// (The GetUsedVar function must suppress the error for
  331|       |		// undefined variables in order to collect all variable 
  332|       |		// names including the undefined ones.)
  333|  1.69k|		if ((m_bIgnoreUndefVar || m_pFactory) && IsUndefVarTok(tok))
  ------------------
  |  Branch (333:8): [True: 1.07k, False: 618]
  |  Branch (333:29): [True: 0, False: 618]
  |  Branch (333:44): [True: 0, False: 0]
  ------------------
  334|      0|			return SaveBeforeReturn(tok);
  335|       |
  336|       |		// Check for unknown token
  337|       |		// 
  338|       |		// !!! From this point on there is no exit without an exception possible...
  339|       |		// 
  340|  1.69k|		string_type strTok;
  341|  1.69k|		auto iEnd = ExtractToken(m_pParser->ValidNameChars(), strTok, (std::size_t)m_iPos);
  342|  1.69k|		if (iEnd != m_iPos)
  ------------------
  |  Branch (342:7): [True: 406, False: 1.29k]
  ------------------
  343|    406|			Error(ecUNASSIGNABLE_TOKEN, m_iPos, strTok);
  344|       |
  345|  1.69k|		Error(ecUNASSIGNABLE_TOKEN, m_iPos, m_strFormula.substr(m_iPos));
  346|  1.69k|		return token_type(); // never reached
  347|  1.69k|	}
_ZN2mu17ParserTokenReader9SetParentEPNS_10ParserBaseE:
  351|  3.71k|	{
  352|  3.71k|		m_pParser = a_pParent;
  353|  3.71k|		m_pFunDef = &a_pParent->m_FunDef;
  354|  3.71k|		m_pOprtDef = &a_pParent->m_OprtDef;
  355|  3.71k|		m_pInfixOprtDef = &a_pParent->m_InfixOprtDef;
  356|  3.71k|		m_pPostOprtDef = &a_pParent->m_PostOprtDef;
  357|  3.71k|		m_pVarDef = &a_pParent->m_VarDef;
  358|  3.71k|		m_pStrVarDef = &a_pParent->m_StrVarDef;
  359|  3.71k|		m_pConstDef = &a_pParent->m_ConstDef;
  360|  3.71k|	}
_ZNK2mu17ParserTokenReader12ExtractTokenEPKcRNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEm:
  372|  4.81M|	{
  373|  4.81M|		auto iEnd = m_strFormula.find_first_not_of(a_szCharSet, a_iPos);
  374|       |
  375|  4.81M|		if (iEnd == string_type::npos)
  ------------------
  |  Branch (375:7): [True: 0, False: 4.81M]
  ------------------
  376|      0|			iEnd = m_strFormula.length();
  377|       |
  378|       |		// Assign token string if there was something found
  379|  4.81M|		if (a_iPos != iEnd)
  ------------------
  |  Branch (379:7): [True: 1.70M, False: 3.10M]
  ------------------
  380|  1.70M|			a_sTok = string_type(m_strFormula.begin() + a_iPos, m_strFormula.begin() + iEnd);
  381|       |
  382|  4.81M|		return static_cast<int>(iEnd);
  383|  4.81M|	}
_ZNK2mu17ParserTokenReader20ExtractOperatorTokenERNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEm:
  394|  2.16M|	{
  395|       |		// Changed as per Issue 6: https://code.google.com/p/muparser/issues/detail?id=6
  396|  2.16M|		auto iEnd = m_strFormula.find_first_not_of(m_pParser->ValidOprtChars(), a_iPos);
  397|  2.16M|		if (iEnd == string_type::npos)
  ------------------
  |  Branch (397:7): [True: 0, False: 2.16M]
  ------------------
  398|      0|			iEnd = m_strFormula.length();
  399|       |
  400|       |		// Assign token string if there was something found
  401|  2.16M|		if (a_iPos != iEnd)
  ------------------
  |  Branch (401:7): [True: 414k, False: 1.75M]
  ------------------
  402|   414k|		{
  403|   414k|			a_sTok = string_type(m_strFormula.begin() + a_iPos, m_strFormula.begin() + iEnd);
  404|   414k|			return static_cast<int>(iEnd);
  405|   414k|		}
  406|  1.75M|		else
  407|  1.75M|		{
  408|       |			// There is still the chance of having to deal with an operator consisting exclusively
  409|       |			// of alphabetic characters.
  410|  1.75M|			return ExtractToken(_T("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"), a_sTok, (std::size_t)a_iPos);
  ------------------
  |  |   69|  1.75M|		#define _T(x) x
  ------------------
  411|  1.75M|		}
  412|  2.16M|	}
_ZN2mu17ParserTokenReader9IsBuiltInERNS_11ParserTokenIdNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE:
  420|  2.15M|	{
  421|  2.15M|		const char_type** const pOprtDef = m_pParser->GetOprtDef(),
  422|  2.15M|			* const szFormula = m_strFormula.c_str();
  423|       |
  424|       |		// Compare token with function and operator strings
  425|       |		// check string for operator/function
  426|  36.4M|		for (int i = 0; pOprtDef[i]; i++)
  ------------------
  |  Branch (426:19): [True: 35.2M, False: 1.23M]
  ------------------
  427|  35.2M|		{
  428|  35.2M|			std::size_t len(std::char_traits<char_type>::length(pOprtDef[i]));
  429|  35.2M|			if (string_type(pOprtDef[i]) == string_type(szFormula + m_iPos, szFormula + m_iPos + len))
  ------------------
  |  Branch (429:8): [True: 916k, False: 34.3M]
  ------------------
  430|   916k|			{
  431|   916k|				switch (i)
  432|   916k|				{
  433|  2.29k|				case cmLAND:
  ------------------
  |  Branch (433:5): [True: 2.29k, False: 914k]
  ------------------
  434|  4.46k|				case cmLOR:
  ------------------
  |  Branch (434:5): [True: 2.17k, False: 914k]
  ------------------
  435|  7.56k|				case cmLT:
  ------------------
  |  Branch (435:5): [True: 3.09k, False: 913k]
  ------------------
  436|  9.84k|				case cmGT:
  ------------------
  |  Branch (436:5): [True: 2.28k, False: 914k]
  ------------------
  437|  10.6k|				case cmLE:
  ------------------
  |  Branch (437:5): [True: 828, False: 916k]
  ------------------
  438|  11.6k|				case cmGE:
  ------------------
  |  Branch (438:5): [True: 959, False: 915k]
  ------------------
  439|  13.0k|				case cmNEQ:
  ------------------
  |  Branch (439:5): [True: 1.44k, False: 915k]
  ------------------
  440|  14.2k|				case cmEQ:
  ------------------
  |  Branch (440:5): [True: 1.14k, False: 915k]
  ------------------
  441|  40.0k|				case cmADD:
  ------------------
  |  Branch (441:5): [True: 25.8k, False: 891k]
  ------------------
  442|  99.2k|				case cmSUB:
  ------------------
  |  Branch (442:5): [True: 59.1k, False: 857k]
  ------------------
  443|   102k|				case cmMUL:
  ------------------
  |  Branch (443:5): [True: 3.39k, False: 913k]
  ------------------
  444|   106k|				case cmDIV:
  ------------------
  |  Branch (444:5): [True: 3.40k, False: 913k]
  ------------------
  445|   265k|				case cmPOW:
  ------------------
  |  Branch (445:5): [True: 159k, False: 757k]
  ------------------
  446|   265k|				case cmASSIGN:
  ------------------
  |  Branch (446:5): [True: 9, False: 916k]
  ------------------
  447|       |					// The assignment operator need special treatment
  448|   265k|					if (i == cmASSIGN && m_iSynFlags & noASSIGN)
  ------------------
  |  Branch (448:10): [True: 9, False: 265k]
  |  Branch (448:27): [True: 7, False: 2]
  ------------------
  449|      7|						Error(ecUNEXPECTED_OPERATOR, m_iPos, pOprtDef[i]);
  450|       |
  451|   265k|					if (!m_pParser->HasBuiltInOprt()) continue;
  ------------------
  |  Branch (451:10): [True: 0, False: 265k]
  ------------------
  452|   265k|					if (m_iSynFlags & noOPT)
  ------------------
  |  Branch (452:10): [True: 74.1k, False: 191k]
  ------------------
  453|  74.1k|					{
  454|       |						// Maybe its an infix operator not an operator
  455|       |						// Both operator types can share characters in 
  456|       |						// their identifiers
  457|  74.1k|						if (IsInfixOpTok(a_Tok))
  ------------------
  |  Branch (457:11): [True: 74.0k, False: 118]
  ------------------
  458|  74.0k|							return true;
  459|       |
  460|    118|						Error(ecUNEXPECTED_OPERATOR, m_iPos, pOprtDef[i]);
  461|    118|					}
  462|       |
  463|   191k|					m_iSynFlags = noBC | noOPT | noARG_SEP | noPOSTOP | noASSIGN | noIF | noELSE | noEND;
  464|   191k|					break;
  465|       |
  466|   302k|				case cmBO:
  ------------------
  |  Branch (466:5): [True: 302k, False: 614k]
  ------------------
  467|   302k|					if (m_iSynFlags & noBO)
  ------------------
  |  Branch (467:10): [True: 14, False: 302k]
  ------------------
  468|     14|						Error(ecUNEXPECTED_PARENS, m_iPos, pOprtDef[i]);
  469|       |
  470|   302k|					if (m_lastTok.GetCode() == cmFUNC)
  ------------------
  |  Branch (470:10): [True: 14.9k, False: 287k]
  ------------------
  471|  14.9k|						m_iSynFlags = noOPT | noEND | noARG_SEP | noPOSTOP | noASSIGN | noIF | noELSE;
  472|   287k|					else
  473|   287k|						m_iSynFlags = noBC | noOPT | noEND | noARG_SEP | noPOSTOP | noASSIGN | noIF | noELSE;
  474|       |
  475|   302k|					if ((int)m_bracketStack.size() >= MaxNestingDepth)
  ------------------
  |  Branch (475:10): [True: 8, False: 302k]
  ------------------
  476|      8|						Error(ecNESTING_LIMIT, m_iPos, pOprtDef[i]);
  477|       |
  478|   302k|					m_bracketStack.push(cmBO);
  479|   302k|					break;
  480|       |
  481|   148k|				case cmBC:
  ------------------
  |  Branch (481:5): [True: 148k, False: 768k]
  ------------------
  482|   148k|					if (m_iSynFlags & noBC)
  ------------------
  |  Branch (482:10): [True: 6, False: 148k]
  ------------------
  483|      6|						Error(ecUNEXPECTED_PARENS, m_iPos, pOprtDef[i]);
  484|       |
  485|   148k|					m_iSynFlags = noBO | noVAR | noVAL | noFUN | noINFIXOP | noSTR | noASSIGN;
  486|       |
  487|   148k|					if (!m_bracketStack.empty())
  ------------------
  |  Branch (487:10): [True: 148k, False: 16]
  ------------------
  488|   148k|						m_bracketStack.pop();
  489|     16|					else
  490|     16|						Error(ecUNEXPECTED_PARENS, m_iPos, pOprtDef[i]);
  491|   148k|					break;
  492|       |
  493|  69.0k|				case cmELSE:
  ------------------
  |  Branch (493:5): [True: 69.0k, False: 847k]
  ------------------
  494|  69.0k|					if (m_iSynFlags & noELSE)
  ------------------
  |  Branch (494:10): [True: 4, False: 68.9k]
  ------------------
  495|      4|						Error(ecUNEXPECTED_CONDITIONAL, m_iPos, pOprtDef[i]);
  496|       |
  497|  69.0k|					m_iSynFlags = noBC | noPOSTOP | noEND | noOPT | noIF | noELSE | noSTR;
  498|  69.0k|					break;
  499|       |
  500|   130k|				case cmIF:
  ------------------
  |  Branch (500:5): [True: 130k, False: 785k]
  ------------------
  501|   130k|					if (m_iSynFlags & noIF)
  ------------------
  |  Branch (501:10): [True: 15, False: 130k]
  ------------------
  502|     15|						Error(ecUNEXPECTED_CONDITIONAL, m_iPos, pOprtDef[i]);
  503|       |
  504|   130k|					m_iSynFlags = noBC | noPOSTOP | noEND | noOPT | noIF | noELSE | noSTR;
  505|   130k|					break;
  506|       |
  507|      0|				default:      // The operator is listed in c_DefaultOprt, but not here. This is a bad thing...
  ------------------
  |  Branch (507:5): [True: 0, False: 916k]
  ------------------
  508|      0|					Error(ecINTERNAL_ERROR);
  509|   916k|				} // switch operator id
  510|       |
  511|   842k|				m_iPos += (int)len;
  512|   842k|				a_Tok.Set((ECmdCode)i, pOprtDef[i]);
  513|   842k|				return true;
  514|   916k|			} // if operator string found
  515|  35.2M|		} // end of for all operator strings
  516|       |
  517|  1.23M|		return false;
  518|  2.15M|	}
_ZN2mu17ParserTokenReader8IsArgSepERNS_11ParserTokenIdNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE:
  522|  1.23M|	{
  523|  1.23M|		const char_type* szFormula = m_strFormula.c_str();
  524|       |
  525|  1.23M|		if (szFormula[m_iPos] == m_cArgSep)
  ------------------
  |  Branch (525:7): [True: 422k, False: 815k]
  ------------------
  526|   422k|		{
  527|       |			// copy the separator into null terminated string
  528|   422k|			char_type szSep[2];
  529|   422k|			szSep[0] = m_cArgSep;
  530|   422k|			szSep[1] = 0;
  531|       |
  532|   422k|			if (m_iSynFlags & noARG_SEP)
  ------------------
  |  Branch (532:8): [True: 4, False: 422k]
  ------------------
  533|      4|				Error(ecUNEXPECTED_ARG_SEP, m_iPos, szSep);
  534|       |
  535|   422k|			m_iSynFlags = noBC | noOPT | noEND | noARG_SEP | noPOSTOP | noASSIGN;
  536|   422k|			m_iPos++;
  537|   422k|			a_Tok.Set(cmARG_SEP, szSep);
  538|   422k|			return true;
  539|   422k|		}
  540|       |
  541|   815k|		return false;
  542|  1.23M|	}
_ZN2mu17ParserTokenReader5IsEOFERNS_11ParserTokenIdNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE:
  553|  2.17M|	{
  554|  2.17M|		const char_type* szFormula = m_strFormula.c_str();
  555|       |
  556|       |		// check for EOF
  557|  2.17M|		if (!szFormula[m_iPos] /*|| szFormula[m_iPos] == '\n'*/)
  ------------------
  |  Branch (557:7): [True: 2.57k, False: 2.16M]
  ------------------
  558|  2.57k|		{
  559|  2.57k|			if (m_iSynFlags & noEND)
  ------------------
  |  Branch (559:8): [True: 638, False: 1.93k]
  ------------------
  560|    638|				Error(ecUNEXPECTED_EOF, m_iPos);
  561|       |
  562|  2.57k|			if (!m_bracketStack.empty())
  ------------------
  |  Branch (562:8): [True: 119, False: 2.45k]
  ------------------
  563|    119|				Error(ecMISSING_PARENS, m_iPos, _T(")"));
  ------------------
  |  |   69|    119|		#define _T(x) x
  ------------------
  564|       |
  565|  2.57k|			m_iSynFlags = 0;
  566|  2.57k|			a_Tok.Set(cmEND);
  567|  2.57k|			return true;
  568|  2.57k|		}
  569|       |
  570|  2.16M|		return false;
  571|  2.17M|	}
_ZN2mu17ParserTokenReader12IsInfixOpTokERNS_11ParserTokenIdNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE:
  578|  74.7k|	{
  579|  74.7k|		string_type sTok;
  580|  74.7k|		auto iEnd = ExtractToken(m_pParser->ValidInfixOprtChars(), sTok, (std::size_t)m_iPos);
  581|  74.7k|		if (iEnd == m_iPos)
  ------------------
  |  Branch (581:7): [True: 388, False: 74.3k]
  ------------------
  582|    388|			return false;
  583|       |
  584|       |		// iterate over all postfix operator strings
  585|  74.3k|		funmap_type::const_reverse_iterator it = m_pInfixOprtDef->rbegin();
  586|  93.0k|		for (; it != m_pInfixOprtDef->rend(); ++it)
  ------------------
  |  Branch (586:10): [True: 92.7k, False: 309]
  ------------------
  587|  92.7k|		{
  588|  92.7k|			if (sTok.find(it->first) != 0)
  ------------------
  |  Branch (588:8): [True: 18.6k, False: 74.0k]
  ------------------
  589|  18.6k|				continue;
  590|       |
  591|  74.0k|			a_Tok.Set(it->second, it->first);
  592|  74.0k|			m_iPos += (int)it->first.length();
  593|       |
  594|  74.0k|			if (m_iSynFlags & noINFIXOP)
  ------------------
  |  Branch (594:8): [True: 39, False: 74.0k]
  ------------------
  595|     39|				Error(ecUNEXPECTED_OPERATOR, m_iPos, a_Tok.GetAsString());
  596|       |
  597|  74.0k|			m_iSynFlags |= noPOSTOP | noINFIXOP | noOPT | noBC | noSTR | noASSIGN | noARG_SEP;
  598|  74.0k|			return true;
  599|  92.7k|		}
  600|       |
  601|    309|		return false;
  602|  74.3k|	}
_ZN2mu17ParserTokenReader8IsFunTokERNS_11ParserTokenIdNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE:
  612|  2.16M|	{
  613|  2.16M|		string_type strTok;
  614|  2.16M|		auto iEnd = ExtractToken(m_pParser->ValidNameChars(), strTok, (std::size_t)m_iPos);
  615|  2.16M|		if (iEnd == m_iPos)
  ------------------
  |  Branch (615:7): [True: 1.34M, False: 824k]
  ------------------
  616|  1.34M|			return false;
  617|       |
  618|   824k|		funmap_type::const_iterator item = m_pFunDef->find(strTok);
  619|   824k|		if (item == m_pFunDef->end())
  ------------------
  |  Branch (619:7): [True: 809k, False: 14.9k]
  ------------------
  620|   809k|			return false;
  621|       |
  622|       |		// Check if the next sign is an opening bracket
  623|  14.9k|		const char_type* szFormula = m_strFormula.c_str();
  624|  14.9k|		if (szFormula[iEnd] != '(')
  ------------------
  |  Branch (624:7): [True: 25, False: 14.9k]
  ------------------
  625|     25|			return false;
  626|       |
  627|       |		// fix for #164: https://github.com/beltoforion/muparser/issues/164
  628|  14.9k|		if (m_lastTok.GetFuncAddr() == generic_callable_type{ (erased_fun_type)&MathImpl<value_type>::UnaryPlus, nullptr })
  ------------------
  |  Branch (628:7): [True: 1, False: 14.9k]
  ------------------
  629|      1|		{
  630|      1|			Error(ecUNARY_PLUS_IN_FRONT_OF_FUNCTION, m_iPos - (int)a_Tok.GetAsString().length(), a_Tok.GetAsString());
  631|      1|		}
  632|       |
  633|  14.9k|		a_Tok.Set(item->second, strTok);
  634|       |
  635|  14.9k|		m_iPos = (int)iEnd;
  636|  14.9k|		if (m_iSynFlags & noFUN)
  ------------------
  |  Branch (636:7): [True: 3, False: 14.9k]
  ------------------
  637|      3|			Error(ecUNEXPECTED_FUN, m_iPos - (int)a_Tok.GetAsString().length(), a_Tok.GetAsString());
  638|       |
  639|  14.9k|		m_iSynFlags = noANY ^ noBO;
  640|  14.9k|		return true;
  641|  14.9k|	}
_ZN2mu17ParserTokenReader6IsOprtERNS_11ParserTokenIdNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE:
  649|  2.16M|	{
  650|  2.16M|		const char_type* const szExpr = m_strFormula.c_str();
  651|  2.16M|		string_type strTok;
  652|       |
  653|  2.16M|		auto iEnd = ExtractOperatorToken(strTok, (std::size_t)m_iPos);
  654|  2.16M|		if (iEnd == m_iPos)
  ------------------
  |  Branch (654:7): [True: 1.75M, False: 414k]
  ------------------
  655|  1.75M|			return false;
  656|       |
  657|       |		// Check if the operator is a built in operator, if so ignore it here
  658|   414k|		const char_type** const pOprtDef = m_pParser->GetOprtDef();
  659|  5.63M|		for (int i = 0; m_pParser->HasBuiltInOprt() && pOprtDef[i]; ++i)
  ------------------
  |  Branch (659:19): [True: 5.63M, False: 0]
  |  Branch (659:50): [True: 5.55M, False: 78.6k]
  ------------------
  660|  5.55M|		{
  661|  5.55M|			if (string_type(pOprtDef[i]) == strTok)
  ------------------
  |  Branch (661:8): [True: 335k, False: 5.22M]
  ------------------
  662|   335k|				return false;
  663|  5.55M|		}
  664|       |
  665|       |		// Note:
  666|       |		// All tokens in oprt_bin_maptype are have been sorted by their length
  667|       |		// Long operators must come first! Otherwise short names (like: "add") that
  668|       |		// are part of long token names (like: "add123") will be found instead 
  669|       |		// of the long ones.
  670|       |		// Length sorting is done with ascending length so we use a reverse iterator here.
  671|  78.6k|		funmap_type::const_reverse_iterator it = m_pOprtDef->rbegin();
  672|  78.6k|		for (; it != m_pOprtDef->rend(); ++it)
  ------------------
  |  Branch (672:10): [True: 0, False: 78.6k]
  ------------------
  673|      0|		{
  674|      0|			const string_type& sID = it->first;
  675|      0|			if (sID == string_type(szExpr + m_iPos, szExpr + m_iPos + sID.length()))
  ------------------
  |  Branch (675:8): [True: 0, False: 0]
  ------------------
  676|      0|			{
  677|      0|				a_Tok.Set(it->second, strTok);
  678|       |
  679|       |				// operator was found
  680|      0|				if (m_iSynFlags & noOPT)
  ------------------
  |  Branch (680:9): [True: 0, False: 0]
  ------------------
  681|      0|				{
  682|       |					// An operator was found but is not expected to occur at
  683|       |					// this position of the formula, maybe it is an infix 
  684|       |					// operator, not a binary operator. Both operator types
  685|       |					// can share characters in their identifiers.
  686|      0|					if (IsInfixOpTok(a_Tok))
  ------------------
  |  Branch (686:10): [True: 0, False: 0]
  ------------------
  687|      0|						return true;
  688|      0|					else
  689|      0|					{
  690|       |						// nope, no infix operator
  691|      0|						return false;
  692|       |						//Error(ecUNEXPECTED_OPERATOR, m_iPos, a_Tok.GetAsString()); 
  693|      0|					}
  694|       |
  695|      0|				}
  696|       |
  697|      0|				m_iPos += (int)sID.length();
  698|      0|				m_iSynFlags = noBC | noOPT | noARG_SEP | noPOSTOP | noEND | noASSIGN;
  699|      0|				return true;
  700|      0|			}
  701|      0|		}
  702|       |
  703|  78.6k|		return false;
  704|  78.6k|	}
_ZN2mu17ParserTokenReader11IsPostOpTokERNS_11ParserTokenIdNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE:
  709|    618|	{
  710|       |		// <ibg 20110629> Do not check for postfix operators if they are not allowed at
  711|       |		//                the current expression index.
  712|       |		//
  713|       |		//  This will fix the bug reported here:  
  714|       |		//
  715|       |		//  http://sourceforge.net/tracker/index.php?func=detail&aid=3343891&group_id=137191&atid=737979
  716|       |		//
  717|    618|		if (m_iSynFlags & noPOSTOP)
  ------------------
  |  Branch (717:7): [True: 411, False: 207]
  ------------------
  718|    411|			return false;
  719|       |		// </ibg>
  720|       |
  721|       |		// Tricky problem with equations like "3m+5":
  722|       |		//     m is a postfix operator, + is a valid sign for postfix operators and 
  723|       |		//     for binary operators parser detects "m+" as operator string and 
  724|       |		//     finds no matching postfix operator.
  725|       |		// 
  726|       |		// This is a special case so this routine slightly differs from the other
  727|       |		// token readers.
  728|       |
  729|       |		// Test if there could be a postfix operator
  730|    207|		string_type sTok;
  731|    207|		auto iEnd = ExtractToken(m_pParser->ValidOprtChars(), sTok, (std::size_t)m_iPos);
  732|    207|		if (iEnd == m_iPos)
  ------------------
  |  Branch (732:7): [True: 43, False: 164]
  ------------------
  733|     43|			return false;
  734|       |
  735|       |		// iterate over all postfix operator strings
  736|    164|		funmap_type::const_reverse_iterator it = m_pPostOprtDef->rbegin();
  737|    164|		for (; it != m_pPostOprtDef->rend(); ++it)
  ------------------
  |  Branch (737:10): [True: 0, False: 164]
  ------------------
  738|      0|		{
  739|      0|			if (sTok.find(it->first) != 0)
  ------------------
  |  Branch (739:8): [True: 0, False: 0]
  ------------------
  740|      0|				continue;
  741|       |
  742|      0|			a_Tok.Set(it->second, sTok);
  743|      0|			m_iPos += (int)it->first.length();
  744|       |
  745|      0|			m_iSynFlags = noVAL | noVAR | noFUN | noBO | noPOSTOP | noSTR | noASSIGN;
  746|      0|			return true;
  747|      0|		}
  748|       |
  749|    164|		return false;
  750|    164|	}
_ZN2mu17ParserTokenReader8IsValTokERNS_11ParserTokenIdNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE:
  761|   815k|	{
  762|   815k|		MUP_ASSERT(m_pConstDef != nullptr);
  ------------------
  |  |   78|   815k|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 815k]
  |  |  ------------------
  |  |   79|   815k|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  763|   815k|		MUP_ASSERT(m_pParser != nullptr);
  ------------------
  |  |   78|   815k|            if (!(COND))											\
  |  |  ------------------
  |  |  |  Branch (78:17): [True: 0, False: 815k]
  |  |  ------------------
  |  |   79|   815k|            {														\
  |  |   80|      0|              stringstream_type ss;									\
  |  |   81|      0|              ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |                             ss << _T("Assertion \"") _T(#COND) _T("\" failed: ")	\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   82|      0|                 << __FILE__ << _T(" line ")						\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   83|      0|                 << __LINE__ << _T(".");							\
  |  |  ------------------
  |  |  |  |   69|      0|		#define _T(x) x
  |  |  ------------------
  |  |   84|      0|              throw ParserError( ecINTERNAL_ERROR, -1, ss.str());   \
  |  |   85|      0|            }
  ------------------
  764|       |
  765|   815k|		string_type strTok;
  766|   815k|		value_type fVal(0);
  767|       |
  768|       |		// 2.) Check for user defined constant
  769|       |		// Read everything that could be a constant name
  770|   815k|		auto iEnd = ExtractToken(m_pParser->ValidNameChars(), strTok, (std::size_t)m_iPos);
  771|   815k|		if (iEnd != m_iPos)
  ------------------
  |  Branch (771:7): [True: 809k, False: 5.54k]
  ------------------
  772|   809k|		{
  773|   809k|			valmap_type::const_iterator item = m_pConstDef->find(strTok);
  774|   809k|			if (item != m_pConstDef->end())
  ------------------
  |  Branch (774:8): [True: 2.25k, False: 807k]
  ------------------
  775|  2.25k|			{
  776|  2.25k|				m_iPos = iEnd;
  777|  2.25k|				a_Tok.SetVal(item->second, strTok);
  778|       |
  779|  2.25k|				if (m_iSynFlags & noVAL)
  ------------------
  |  Branch (779:9): [True: 2, False: 2.25k]
  ------------------
  780|      2|					Error(ecUNEXPECTED_VAL, m_iPos - (int)strTok.length(), strTok);
  781|       |
  782|  2.25k|				m_iSynFlags = noVAL | noVAR | noFUN | noBO | noINFIXOP | noSTR | noASSIGN;
  783|  2.25k|				return true;
  784|  2.25k|			}
  785|   809k|		}
  786|       |
  787|       |		// 3.call the value recognition functions provided by the user
  788|       |		// Call user defined value recognition functions
  789|   812k|		std::list<identfun_type>::const_iterator item = m_vIdentFun.begin();
  790|   817k|		for (item = m_vIdentFun.begin(); item != m_vIdentFun.end(); ++item)
  ------------------
  |  Branch (790:36): [True: 812k, False: 4.97k]
  ------------------
  791|   812k|		{
  792|   812k|			int iStart = m_iPos;
  793|   812k|			if ((*item)(m_strFormula.c_str() + m_iPos, &m_iPos, &fVal) == 1)
  ------------------
  |  Branch (793:8): [True: 807k, False: 4.97k]
  ------------------
  794|   807k|			{
  795|       |				// 2013-11-27 Issue 2:  https://code.google.com/p/muparser/issues/detail?id=2
  796|   807k|				strTok.assign(m_strFormula.c_str(), iStart, (std::size_t)m_iPos - iStart);
  797|       |
  798|   807k|				if (m_iSynFlags & noVAL)
  ------------------
  |  Branch (798:9): [True: 27, False: 807k]
  ------------------
  799|     27|					Error(ecUNEXPECTED_VAL, m_iPos - (int)strTok.length(), strTok);
  800|       |
  801|   807k|				a_Tok.SetVal(fVal, strTok);
  802|   807k|				m_iSynFlags = noVAL | noVAR | noFUN | noBO | noINFIXOP | noSTR | noASSIGN;
  803|   807k|				return true;
  804|   807k|			}
  805|   812k|		}
  806|       |
  807|  4.97k|		return false;
  808|   812k|	}
_ZN2mu17ParserTokenReader8IsVarTokERNS_11ParserTokenIdNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE:
  816|  4.97k|	{
  817|  4.97k|		if (m_pVarDef->empty())
  ------------------
  |  Branch (817:7): [True: 4.97k, False: 0]
  ------------------
  818|  4.97k|			return false;
  819|       |
  820|      0|		string_type strTok;
  821|      0|		auto iEnd = ExtractToken(m_pParser->ValidNameChars(), strTok, (std::size_t)m_iPos);
  822|      0|		if (iEnd == m_iPos)
  ------------------
  |  Branch (822:7): [True: 0, False: 0]
  ------------------
  823|      0|			return false;
  824|       |
  825|      0|		varmap_type::const_iterator item = m_pVarDef->find(strTok);
  826|      0|		if (item == m_pVarDef->end())
  ------------------
  |  Branch (826:7): [True: 0, False: 0]
  ------------------
  827|      0|			return false;
  828|       |
  829|      0|		if (m_iSynFlags & noVAR)
  ------------------
  |  Branch (829:7): [True: 0, False: 0]
  ------------------
  830|      0|			Error(ecUNEXPECTED_VAR, m_iPos, strTok);
  831|       |
  832|      0|		m_pParser->OnDetectVar(&m_strFormula, m_iPos, iEnd);
  833|       |
  834|      0|		m_iPos = iEnd;
  835|      0|		a_Tok.SetVar(item->second, strTok);
  836|      0|		m_UsedVar[item->first] = item->second;  // Add variable to used-var-list
  837|       |
  838|      0|		m_iSynFlags = noVAL | noVAR | noFUN | noBO | noINFIXOP | noSTR;
  839|       |
  840|       |		//  Zur Info hier die SynFlags von IsVal():
  841|       |		//    m_iSynFlags = noVAL | noVAR | noFUN | noBO | noINFIXOP | noSTR | noASSIGN; 
  842|      0|		return true;
  843|      0|	}
_ZN2mu17ParserTokenReader11IsStrVarTokERNS_11ParserTokenIdNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE:
  847|  4.97k|	{
  848|  4.97k|		if (!m_pStrVarDef || m_pStrVarDef->empty())
  ------------------
  |  Branch (848:7): [True: 0, False: 4.97k]
  |  Branch (848:24): [True: 4.97k, False: 0]
  ------------------
  849|  4.97k|			return false;
  850|       |
  851|      0|		string_type strTok;
  852|      0|		auto iEnd = ExtractToken(m_pParser->ValidNameChars(), strTok, (std::size_t)m_iPos);
  853|      0|		if (iEnd == m_iPos)
  ------------------
  |  Branch (853:7): [True: 0, False: 0]
  ------------------
  854|      0|			return false;
  855|       |
  856|      0|		strmap_type::const_iterator item = m_pStrVarDef->find(strTok);
  857|      0|		if (item == m_pStrVarDef->end())
  ------------------
  |  Branch (857:7): [True: 0, False: 0]
  ------------------
  858|      0|			return false;
  859|       |
  860|      0|		if (m_iSynFlags & noSTR)
  ------------------
  |  Branch (860:7): [True: 0, False: 0]
  ------------------
  861|      0|			Error(ecUNEXPECTED_VAR, m_iPos, strTok);
  862|       |
  863|      0|		m_iPos = iEnd;
  864|      0|		if (!m_pParser->m_vStringVarBuf.size())
  ------------------
  |  Branch (864:7): [True: 0, False: 0]
  ------------------
  865|      0|			Error(ecINTERNAL_ERROR);
  866|       |		
  867|      0|		auto strVal = m_pParser->m_vStringVarBuf[item->second];
  868|      0|		m_pParser->m_vStringBuf.push_back(strVal);
  869|      0|		a_Tok.SetString(strVal, m_pParser->m_vStringBuf.size()-1);
  870|       |
  871|      0|		m_iSynFlags = noANY ^ (noBC | noOPT | noEND | noARG_SEP);
  872|      0|		return true;
  873|      0|	}
_ZN2mu17ParserTokenReader8IsStringERNS_11ParserTokenIdNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE:
  936|  4.97k|	{
  937|  4.97k|		if (m_strFormula[m_iPos] != '"')
  ------------------
  |  Branch (937:7): [True: 618, False: 4.35k]
  ------------------
  938|    618|			return false;
  939|       |
  940|  4.35k|		string_type strBuf(&m_strFormula[(std::size_t)m_iPos + 1]);
  941|  4.35k|		std::size_t iEnd(0), iSkip(0);
  942|       |
  943|       |		// parser over escaped '\"' end replace them with '"'
  944|  4.87k|		for (iEnd = strBuf.find(_T('\"')); iEnd != string_type::npos; iEnd = strBuf.find(_T('\"'), iEnd))
  ------------------
  |  |   69|  4.35k|		#define _T(x) x
  ------------------
              		for (iEnd = strBuf.find(_T('\"')); iEnd != string_type::npos; iEnd = strBuf.find(_T('\"'), iEnd))
  ------------------
  |  |   69|    522|		#define _T(x) x
  ------------------
  |  Branch (944:38): [True: 4.82k, False: 49]
  ------------------
  945|  4.82k|		{
  946|  4.82k|			if (iEnd==0 || strBuf[iEnd - 1] != '\\') 
  ------------------
  |  Branch (946:8): [True: 2.52k, False: 2.29k]
  |  Branch (946:19): [True: 1.77k, False: 522]
  ------------------
  947|  4.30k|				break;
  948|       |
  949|    522|			strBuf.replace(iEnd - 1, 2, _T("\""));
  ------------------
  |  |   69|    522|		#define _T(x) x
  ------------------
  950|    522|			iSkip++;
  951|    522|		}
  952|       |
  953|  4.35k|		if (iEnd == string_type::npos)
  ------------------
  |  Branch (953:7): [True: 49, False: 4.30k]
  ------------------
  954|     49|			Error(ecUNTERMINATED_STRING, m_iPos, _T("\""));
  ------------------
  |  |   69|     49|		#define _T(x) x
  ------------------
  955|       |
  956|  4.35k|		string_type strTok(strBuf.begin(), strBuf.begin() + iEnd);
  957|       |
  958|  4.35k|		if (m_iSynFlags & noSTR)
  ------------------
  |  Branch (958:7): [True: 38, False: 4.31k]
  ------------------
  959|     38|			Error(ecUNEXPECTED_STR, m_iPos, strTok);
  960|       |
  961|  4.35k|		m_pParser->m_vStringBuf.push_back(strTok); // Store string in internal buffer
  962|  4.35k|		a_Tok.SetString(strTok, m_pParser->m_vStringBuf.size()-1);
  963|       |
  964|  4.35k|		m_iPos += (int)strTok.length() + 2 + (int)iSkip;  // +2 for quotes; +iSkip for escape characters 
  965|  4.35k|		m_iSynFlags = noANY ^ (noARG_SEP | noBC | noOPT | noEND);
  966|       |
  967|  4.35k|		return true;
  968|  4.97k|	}
_ZNK2mu17ParserTokenReader5ErrorENS_11EErrorCodesEiRKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
  981|  1.69k|	{
  982|  1.69k|		m_pParser->Error(a_iErrc, a_iPos, a_sTok);
  983|  1.69k|	}
_ZNK2mu17ParserTokenReader9GetArgSepEv:
  993|  3.71k|	{
  994|  3.71k|		return m_cArgSep;
  995|  3.71k|	}

LLVMFuzzerTestOneInput:
   22|  3.71k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
   23|  3.71k|  std::string line_string((char *)data, size);
   24|  3.71k|  try {
   25|  3.71k|    mu::Parser parser;
   26|  3.71k|    parser.SetExpr(line_string);
   27|  3.71k|    parser.Eval();
   28|  3.71k|  } catch (mu::Parser::exception_type &e) {
   29|  2.09k|  } catch (mu::ParserError &e) {
   30|      0|  }
   31|  3.71k|  return 0;
   32|  3.71k|}